Spaces:
Sleeping
Sleeping
| import warnings | |
| import numpy as np | |
| import pandas as pd | |
| import os | |
| import json | |
| import random | |
| import gradio as gr | |
| import torch | |
| import torch.nn as nn | |
| import torch.optim as optim | |
| from torch.utils.data import DataLoader, IterableDataset | |
| from sklearn.ensemble import IsolationForest, RandomForestClassifier | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.preprocessing import OneHotEncoder | |
| from sklearn.neural_network import MLPClassifier | |
| from deap import base, creator, tools, algorithms | |
| from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, AutoModelForSequenceClassification | |
| import gc | |
| import multiprocessing as mp | |
| from joblib import Parallel, delayed | |
| warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download') | |
| # Initialize Example Emotions Dataset | |
| data = { | |
| 'context': [ | |
| 'I am happy', 'I am sad', 'I am angry', 'I am excited', 'I am calm', | |
| 'I am feeling joyful', 'I am grieving', 'I am feeling peaceful', 'I am frustrated', | |
| 'I am determined', 'I feel resentment', 'I am feeling glorious', 'I am motivated', | |
| 'I am surprised', 'I am fearful', 'I am trusting', 'I feel disgust', 'I am optimistic', | |
| 'I am pessimistic', 'I feel bored', 'I am envious' | |
| ], | |
| 'emotion': [ | |
| 'joy', 'sadness', 'anger', 'joy', 'calmness', 'joy', 'grief', 'calmness', 'anger', | |
| 'determination', 'resentment', 'glory', 'motivation', 'surprise', 'fear', 'trust', | |
| 'disgust', 'optimism', 'pessimism', 'boredom', 'envy' | |
| ] | |
| } | |
| df = pd.DataFrame(data) | |
| # Encoding the contexts using One-Hot Encoding (memory-efficient) | |
| encoder = OneHotEncoder(handle_unknown='ignore', sparse=True) | |
| contexts_encoded = encoder.fit_transform(df[['context']]) | |
| # Encoding emotions | |
| emotions_target = pd.Categorical(df['emotion']).codes | |
| emotion_classes = pd.Categorical(df['emotion']).categories | |
| # Load pre-trained BERT model for emotion prediction | |
| emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") | |
| emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") | |
| # Lazy loading for the fine-tuned language model | |
| _finetuned_lm_tokenizer = None | |
| _finetuned_lm_model = None | |
| def get_finetuned_lm_model(): | |
| global _finetuned_lm_tokenizer, _finetuned_lm_model | |
| if _finetuned_lm_tokenizer is None or _finetuned_lm_model is None: | |
| finetuned_lm_model_name = "microsoft/DialoGPT-large" # Replace with your fine-tuned language model name | |
| _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(finetuned_lm_model_name) | |
| _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(finetuned_lm_model_name, device_map="auto", low_cpu_mem_usage=True) | |
| return _finetuned_lm_tokenizer, _finetuned_lm_model | |
| # Enhanced Emotional States | |
| emotions = { | |
| 'joy': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, | |
| 'pleasure': {'percentage': 10, 'motivation': 'selfish', 'intensity': 0}, | |
| 'sadness': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, | |
| 'grief': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, | |
| 'anger': {'percentage': 10, 'motivation': 'traumatic or strong', 'intensity': 0}, | |
| 'calmness': {'percentage': 10, 'motivation': 'neutral', 'intensity': 0}, | |
| 'determination': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, | |
| 'resentment': {'percentage': 10, 'motivation': 'negative', 'intensity': 0}, | |
| 'glory': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, | |
| 'motivation': {'percentage': 10, 'motivation': 'positive', 'intensity': 0}, | |
| 'ideal_state': {'percentage': 100, 'motivation': 'balanced', 'intensity': 0}, | |
| 'fear': {'percentage': 10, 'motivation': 'defensive', 'intensity': 0}, | |
| 'surprise': {'percentage': 10, 'motivation': 'unexpected', 'intensity': 0}, | |
| 'anticipation': {'percentage': 10, 'motivation': 'predictive', 'intensity': 0}, | |
| 'trust': {'percentage': 10, 'motivation': 'reliable', 'intensity': 0}, | |
| 'disgust': {'percentage': 10, 'motivation': 'repulsive', 'intensity': 0}, | |
| 'optimism': {'percentage': 10, 'motivation': 'hopeful', 'intensity': 0}, | |
| 'pessimism': {'percentage': 10, 'motivation': 'doubtful', 'intensity': 0}, | |
| 'boredom': {'percentage': 10, 'motivation': 'indifferent', 'intensity': 0}, | |
| 'envy': {'percentage': 10, 'motivation': 'jealous', 'intensity': 0} | |
| } | |
| total_percentage = 200 | |
| emotion_history_file = 'emotion_history.json' | |
| def load_historical_data(file_path=emotion_history_file): | |
| if os.path.exists(file_path): | |
| with open(file_path, 'r') as file: | |
| return json.load(file) | |
| return [] | |
| def save_historical_data(historical_data, file_path=emotion_history_file): | |
| with open(file_path, 'w') as file: | |
| json.dump(historical_data, file) | |
| emotion_history = load_historical_data() | |
| def update_emotion(emotion, percentage, intensity): | |
| emotions['ideal_state']['percentage'] -= percentage | |
| emotions[emotion]['percentage'] += percentage | |
| emotions[emotion]['intensity'] = intensity | |
| total_current = sum(e['percentage'] for e in emotions.values()) | |
| adjustment = total_percentage - total_current | |
| emotions['ideal_state']['percentage'] += adjustment | |
| def normalize_context(context): | |
| return context.lower().strip() | |
| # Memory-efficient genetic algorithm for emotion evolution | |
| def evolve_emotions(): | |
| def evaluate(individual): | |
| ideal_state = individual[-1] | |
| other_emotions = individual[:-1] | |
| intensities = individual[-21:-1] | |
| return (abs(ideal_state - 100), | |
| sum(other_emotions), | |
| max(intensities) - min(intensities)) | |
| creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0)) | |
| creator.create("Individual", list, fitness=creator.FitnessMulti) | |
| toolbox = base.Toolbox() | |
| toolbox.register("attr_float", random.uniform, 0, 20) | |
| toolbox.register("attr_intensity", random.uniform, 0, 10) | |
| toolbox.register("individual", tools.initCycle, creator.Individual, | |
| (toolbox.attr_float,) * (len(emotions) - 1) + | |
| (toolbox.attr_intensity,) * len(emotions) + | |
| (lambda: 100,), n=1) | |
| toolbox.register("population", tools.initRepeat, list, toolbox.individual) | |
| toolbox.register("mate", tools.cxTwoPoint) | |
| toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2) | |
| toolbox.register("select", tools.selNSGA2) | |
| toolbox.register("evaluate", evaluate) | |
| population = toolbox.population(n=100) | |
| algorithms.eaMuPlusLambda(population, toolbox, mu=50, lambda_=100, cxpb=0.7, mutpb=0.2, ngen=100, | |
| stats=None, halloffame=None, verbose=False) | |
| best_individual = tools.selBest(population, k=1)[0] | |
| emotion_values = best_individual[:len(emotions)-1] | |
| intensities = best_individual[-21:-1] | |
| ideal_state = best_individual[-1] | |
| for i, emotion in enumerate(emotions): | |
| emotions[emotion]['percentage'] = emotion_values[i] | |
| emotions[emotion]['intensity'] = intensities[i] | |
| emotions['ideal_state']['percentage'] = ideal_state | |
| def predict_emotion(context): | |
| emotion_prediction_pipeline = pipeline('text-classification', model=emotion_prediction_model, tokenizer=emotion_prediction_tokenizer, top_k=None) | |
| predictions = emotion_prediction_pipeline(context) | |
| emotion_scores = {emotion['label']: emotion['score'] for emotion in predictions} | |
| emotion_pred = emotion_classes[np.argmax([emotion_scores.get(label, 0) for label in emotion_classes])] | |
| return emotion_pred | |
| def generate_text(prompt, model, tokenizer, max_length=50): | |
| input_ids = tokenizer.encode(prompt, return_tensors='pt') | |
| output = model.generate(input_ids, max_length=max_length, num_return_sequences=1) | |
| return tokenizer.decode(output[0], skip_special_tokens=True) | |
| def optimize_ai_model(emotion_history): | |
| X = [normalize_context(e['context']) for e in emotion_history] | |
| y = [e['emotion'] for e in emotion_history] | |
| X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) | |
| rf = RandomForestClassifier(n_estimators=100, random_state=42) | |
| rf.fit(X_train, y_train) | |
| score = rf.score(X_test, y_test) | |
| return rf, score | |
| def ai_response(input_text, emotion_model): | |
| emotion_pred = predict_emotion(input_text) | |
| context_emotion = {'context': input_text, 'emotion': emotion_pred} | |
| emotion_history.append(context_emotion) | |
| save_historical_data(emotion_history) | |
| percentage_change = random.randint(1, 10) | |
| intensity_change = random.randint(1, 10) | |
| update_emotion(emotion_pred, percentage_change, intensity_change) | |
| evolve_emotions() | |
| finetuned_tokenizer, finetuned_model = get_finetuned_lm_model() | |
| response_text = generate_text(input_text, finetuned_model, finetuned_tokenizer) | |
| return response_text | |
| def run_genetic_algorithm_parallel(): | |
| num_cores = mp.cpu_count() | |
| results = Parallel(n_jobs=num_cores)(delayed(evolve_emotions)() for _ in range(3)) | |
| def clear_emotion_history(): | |
| global emotion_history | |
| emotion_history = [] | |
| save_historical_data(emotion_history) | |
| # Gradio Interface | |
| def respond(input_text): | |
| emotion_model, score = optimize_ai_model(emotion_history) | |
| response = ai_response(input_text, emotion_model) | |
| return response, score | |
| with gr.Blocks() as app: | |
| gr.Markdown("# Advanced AI Model") | |
| input_text = gr.Textbox(label="Input Text") | |
| response_text = gr.Textbox(label="Response Text", interactive=False) | |
| model_score = gr.Number(label="Model Accuracy", interactive=False) | |
| respond_button = gr.Button("Respond") | |
| respond_button.click(fn=respond, inputs=[input_text], outputs=[response_text, model_score]) | |
| clear_button = gr.Button("Clear Emotion History") | |
| clear_button.click(fn=clear_emotion_history, inputs=[], outputs=[]) | |
| app.launch() | |