import warnings import numpy as np import pandas as pd import os import json import random import gradio as gr import torch from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from sklearn.preprocessing import OneHotEncoder from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM, pipeline from deap import base, creator, tools, algorithms import gc 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 (DialoGPT-medium) _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: model_name = "microsoft/DialoGPT-medium" _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side='left') _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", low_cpu_mem_usage=True) _finetuned_lm_tokenizer.pad_token = _finetuned_lm_tokenizer.eos_token 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}, 'neutral': {'percentage': 10, 'motivation': 'balanced', 'intensity': 0}, 'wit': {'percentage': 15, 'motivation': 'clever', 'intensity': 0}, 'curiosity': {'percentage': 20, 'motivation': 'inquisitive', '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): if percentage > emotions['ideal_state']['percentage']: percentage = emotions['ideal_state']['percentage'] emotions['ideal_state']['percentage'] -= percentage emotions[emotion]['percentage'] += percentage emotions[emotion]['intensity'] = intensity # Introduce some randomness in emotional evolution for e in emotions: if e != emotion and e != 'ideal_state': change = random.uniform(-2, 2) emotions[e]['percentage'] = max(0, emotions[e]['percentage'] + change) 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() def evaluate(individual): emotion_values = individual[:len(emotions) - 1] intensities = individual[len(emotions) - 1:-1] ideal_state = individual[-1] ideal_diff = abs(100 - ideal_state) sum_non_ideal = sum(emotion_values) intensity_range = max(intensities) - min(intensities) return ideal_diff, sum_non_ideal, intensity_range def evolve_emotions(): creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2)) 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) - 1) + (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[len(emotions) - 1:-1] ideal_state = best_individual[-1] for i, emotion in enumerate(emotions): if emotion != 'ideal_state': emotions[emotion]['percentage'] = emotion_values[i] emotions[emotion]['intensity'] = intensities[i] emotions['ideal_state']['percentage'] = ideal_state def update_emotion_history(emotion, percentage, intensity, context): entry = { 'emotion': emotion, 'percentage': percentage, 'intensity': intensity, 'context': context, 'timestamp': pd.Timestamp.now().isoformat() } emotion_history.append(entry) if len(emotion_history) > 100: emotion_history.pop(0) save_historical_data(emotion_history) def predict_emotion(context): tokens = emotion_prediction_tokenizer(context, return_tensors='pt', padding=True, truncation=True) outputs = emotion_prediction_model(**tokens) logits = outputs.logits predicted_class = torch.argmax(logits, dim=1).item() predicted_emotion = emotion_classes[predicted_class] # Get percentage and intensity based on context percentage = np.random.uniform(5, 20) intensity = np.random.uniform(1, 10) update_emotion(predicted_emotion, percentage, intensity) update_emotion_history(predicted_emotion, percentage, intensity, context) return predicted_emotion def generate_response(context): tokenizer, model = get_finetuned_lm_model() inputs = tokenizer.encode(context, return_tensors='pt') outputs = model.generate(inputs, max_length=500, num_return_sequences=1, pad_token_id=tokenizer.eos_token) response = tokenizer.decode(outputs[0], skip_special_tokens=True) return response def handle_conversation(user_input): user_input = normalize_context(user_input) predicted_emotion = predict_emotion(user_input) bot_response = generate_response(user_input) return f"Emotion: {predicted_emotion}, Response: {bot_response}" def update_ui(user_input): response = handle_conversation(user_input) return response with gr.Blocks() as demo: user_input = gr.Textbox(label="User Input") response = gr.Textbox(label="Bot Response") submit = gr.Button("Submit") submit.click(update_ui, user_input, response) if __name__ == "__main__": demo.launch(share=True)