Update app.py

app.py

@@ -6,7 +6,6 @@ import json
 import random
 import gradio as gr
 import torch
-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
@@ -50,6 +49,8 @@ try:
     encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=True)
 except TypeError:
     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
@@ -66,32 +67,18 @@ response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
 # 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},
+    'love': {'percentage': 10, 'motivation': 'affectionate', '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},
+    'neutral': {'percentage': 40, 'motivation': 'balanced', 'intensity': 0},
 }
 
-total_percentage = 200
+total_percentage = 100
 emotion_history_file = 'emotion_history.json'
+conversation_history = []
+max_history_length = 30
 
 def load_historical_data(file_path=emotion_history_file):
     if os.path.exists(file_path):
@@ -106,22 +93,13 @@ def save_historical_data(historical_data, file_path=emotion_history_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
+    # Normalize percentages
+    total = sum(e['percentage'] for e in emotions.values())
     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
+        emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100
 
 def normalize_context(context):
     return context.lower().strip()
@@ -131,24 +109,22 @@ creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2))
 creator.create("Individual", list, fitness=creator.FitnessMulti)
 
 def evaluate(individual):
-    emotion_values = individual[:len(emotions) - 1]
-    intensities = individual[len(emotions) - 1:-1]
-    ideal_state = individual[-1]
+    emotion_values = individual[:len(emotions)]
+    intensities = individual[len(emotions):]
     
-    ideal_diff = abs(100 - ideal_state)
-    sum_non_ideal = sum(emotion_values)
+    total_diff = abs(100 - sum(emotion_values))
     intensity_range = max(intensities) - min(intensities)
+    emotion_balance = max(emotion_values) - min(emotion_values)
     
-    return ideal_diff, sum_non_ideal, intensity_range
+    return total_diff, intensity_range, emotion_balance
 
 def evolve_emotions():
     toolbox = base.Toolbox()
-    toolbox.register("attr_float", random.uniform, 0, 20)
+    toolbox.register("attr_float", random.uniform, 0, 100)
     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.attr_float,) * len(emotions) +
+                     (toolbox.attr_intensity,) * len(emotions), 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)
@@ -156,21 +132,21 @@ def evolve_emotions():
     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,
+    algorithms.eaMuPlusLambda(population, toolbox, mu=50, lambda_=100, cxpb=0.7, mutpb=0.2, ngen=50,
                                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]
+    emotion_values = best_individual[:len(emotions)]
+    intensities = best_individual[len(emotions):]
 
-    for i, (emotion, data) in enumerate(list(emotions.items())[:-1]):  # Exclude 'ideal_state'
-        if i < len(emotion_values):
-            data['percentage'] = emotion_values[i]
-        if i < len(intensities):
-            data['intensity'] = intensities[i]
+    for i, (emotion, data) in enumerate(emotions.items()):
+        data['percentage'] = emotion_values[i]
+        data['intensity'] = intensities[i]
 
-    emotions['ideal_state']['percentage'] = ideal_state
+    # Normalize percentages
+    total = sum(e['percentage'] for e in emotions.values())
+    for e in emotions:
+        emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100
 
 def update_emotion_history(emotion, percentage, intensity, context):
     entry = {
@@ -193,19 +169,37 @@ def feature_transformations():
     for feature in additional_features:
         additional_features[feature] += random.uniform(-1, 1)
 
-def generate_response(input_text):
-    inputs = response_tokenizer(input_text, return_tensors="pt", truncation=True, max_length=512)
+def generate_response(input_text, ai_emotion):
+    # Prepare a prompt based on the current emotion and input
+    prompt = f"You are an AI assistant currently feeling {ai_emotion}. Your response should reflect this emotion. Human: {input_text}\nAI:"
+    
+    # Add conversation history to the prompt
+    for entry in conversation_history[-5:]:  # Use last 5 entries for context
+        prompt = f"Human: {entry['user']}\nAI: {entry['response']}\n" + prompt
+    
+    inputs = response_tokenizer(prompt, return_tensors="pt", truncation=True, max_length=1024)
+    
+    # Adjust generation parameters based on emotion
+    temperature = 0.7
+    if ai_emotion == 'anger':
+        temperature = 0.9  # More randomness for angry responses
+    elif ai_emotion == 'joy':
+        temperature = 0.5  # More focused responses for joyful state
+
     with torch.no_grad():
         response_ids = response_model.generate(
             inputs.input_ids,
-            max_length=150,
+            max_length=1024,
             num_return_sequences=1,
             no_repeat_ngram_size=2,
             top_k=50,
             top_p=0.95,
-            temperature=0.7
+            temperature=temperature
         )
     response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True)
+    
+    # Extract only the AI's response
+    response = response.split("AI:")[-1].strip()
     return response
 
 def predict_emotion(context):
@@ -262,16 +256,33 @@ def interactive_interface(input_text):
         entities = extract_entities(input_text)
         text_complexity = analyze_text_complexity(input_text)
         
+        # Update AI's emotional state based on input
         update_emotion(predicted_emotion, random.uniform(5, 15), random.uniform(0, 10))
-        update_emotion_history(predicted_emotion, emotions[predicted_emotion]['percentage'], emotions[predicted_emotion]['intensity'], input_text)
-        feature_transformations()
         
-        response = generate_response(input_text)
+        # Determine AI's current dominant emotion
+        ai_emotion = max(emotions, key=lambda e: emotions[e]['percentage'])
+        
+        # Generate response based on AI's emotion
+        response = generate_response(input_text, ai_emotion)
+        
+        # Update conversation history
+        conversation_history.append({
+            'user': input_text,
+            'response': response
+        })
+        
+        # Trim conversation history if it exceeds the maximum length
+        if len(conversation_history) > max_history_length:
+            conversation_history = conversation_history[-max_history_length:]
+        
+        update_emotion_history(ai_emotion, emotions[ai_emotion]['percentage'], emotions[ai_emotion]['intensity'], input_text)
+        feature_transformations()
         
         emotion_visualization = visualize_emotions()
         
         analysis_result = {
-            'predicted_emotion': predicted_emotion,
+            'predicted_user_emotion': predicted_emotion,
+            'ai_emotion': ai_emotion,
             'sentiment_scores': sentiment_scores,
             'entities': entities,
             'text_complexity': text_complexity,
@@ -291,11 +302,12 @@ def gradio_interface(input_text):
         return response, None
     else:
         return (
-            f"Predicted Emotion: {response['predicted_emotion']}\n"
+            f"User Emotion: {response['predicted_user_emotion']}\n"
+            f"AI Emotion: {response['ai_emotion']}\n"
+            f"AI Response: {response['response']}\n\n"
             f"Sentiment: {response['sentiment_scores']}\n"
             f"Entities: {response['entities']}\n"
-            f"Text Complexity: {response['text_complexity']}\n"
-            f"Response: {response['response']}\n",
+            f"Text Complexity: {response['text_complexity']}\n",
             response['emotion_visualization']
         )
 
@@ -309,5 +321,4 @@ iface = gr.Interface(
 )
 
 if __name__ == "__main__":
-    iface.launch()
-
+    iface.launch()