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 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") # 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, return_all_scores=True) predictions = emotion_prediction_pipeline(context) emotion_scores = predictions[0] emotion_pred = max(emotion_scores, key=emotion_scores.get) return emotion_pred def generate_text(prompt, max_length=100, emotion=None): finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model() input_ids = finetuned_lm_tokenizer.encode(prompt, return_tensors='pt').to(finetuned_lm_model.device) if emotion is not None: emotion_intensity = emotions[emotion]['intensity'] top_p = 0.95 - (emotion_intensity / 10) # Adjust top_p based on emotion intensity temperature = 0.7 + (emotion_intensity / 5) # Adjust temperature based on emotion intensity else: top_p = 0.95 temperature = 0.7 with torch.no_grad(): output = finetuned_lm_model.generate( input_ids, max_length=max_length, num_return_sequences=1, no_repeat_ngram_size=2, do_sample=True, top_k=50, top_p=top_p, temperature=temperature ) generated_text = finetuned_lm_tokenizer.decode(output[0], skip_special_tokens=True) return generated_text def generate_response(context, emotion=None): prompt = context generated_text = generate_text(prompt, emotion=emotion) return generated_text with gr.Blocks() as demo: gr.Markdown("# Emotion-Aware Language Model") context_input = gr.Textbox(label="Enter a context") predict_btn = gr.Button("Predict Emotion and Generate Text") with gr.Row(): emotion_output = gr.Textbox(label="Predicted Emotion", show_label=True) generated_text_output = gr.Textbox(label="Generated Text", show_label=True) predict_btn.click(fn=lambda context: (predict_emotion(context), generate_response(context, emotion=predict_emotion(context))), inputs=context_input, outputs=[emotion_output, generated_text_output]) demo.launch()