Update app.py

app.py

@@ -76,8 +76,10 @@ emotions = {
     '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}
+    'envy': {'percentage': 10, 'motivation': 'jealous', 'intensity': 0},
+    'neutral': {'percentage': 10, 'motivation': 'balanced', 'intensity': 0}
 }
+
 total_percentage = 200
 emotion_history_file = 'emotion_history.json'
 
@@ -127,6 +129,7 @@ def evolve_emotions():
                      (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)
@@ -151,8 +154,19 @@ 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 = {prediction['label']: prediction['score'] for prediction in predictions[0]}
-    emotion_pred = max(emotion_scores, key=emotion_scores.get)
-    return emotion_pred
+    predicted_label = max(emotion_scores, key=emotion_scores.get)
+    
+    # Map the predicted label to our emotion categories
+    emotion_mapping = {
+        'LABEL_0': 'joy',
+        'LABEL_1': 'sadness',
+        'LABEL_2': 'anger',
+        'LABEL_3': 'fear',
+        'LABEL_4': 'surprise',
+        'LABEL_5': 'disgust'
+    }
+    
+    return emotion_mapping.get(predicted_label, 'neutral')
 
 def generate_text(prompt, emotion=None, max_length=100):
     finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model()
@@ -191,28 +205,91 @@ def generate_text(prompt, emotion=None, max_length=100):
     generated_text = finetuned_lm_tokenizer.decode(output[0], skip_special_tokens=True)
     return generated_text
 
+def update_emotion_history(emotion, intensity):
+    global emotion_history
+    emotion_history.append({
+        'emotion': emotion,
+        'intensity': intensity,
+        'timestamp': pd.Timestamp.now().isoformat()
+    })
+    save_historical_data(emotion_history)
+
+def get_dominant_emotion():
+    return max(emotions, key=lambda x: emotions[x]['percentage'] if x != 'ideal_state' else 0)
+
+def get_emotion_summary():
+    summary = []
+    for emotion, data in emotions.items():
+        if emotion != 'ideal_state':
+            summary.append(f"{emotion.capitalize()}: {data['percentage']:.1f}% (Intensity: {data['intensity']:.1f})")
+    return "\n".join(summary)
+
+def reset_emotions():
+    global emotions
+    for emotion in emotions:
+        if emotion != 'ideal_state':
+            emotions[emotion]['percentage'] = 10
+            emotions[emotion]['intensity'] = 0
+    emotions['ideal_state']['percentage'] = 100
+
 def respond_to_user(user_input, chat_history):
     # Predict the emotion from the user input
-    emotion = predict_emotion(user_input)
+    predicted_emotion = predict_emotion(user_input)
+    
+    # Ensure the predicted emotion exists in our emotions dictionary
+    if predicted_emotion not in emotions:
+        predicted_emotion = 'neutral'
     
     # Update the emotional state
-    update_emotion(emotion, 5, random.uniform(0, 10))
+    update_emotion(predicted_emotion, 5, random.uniform(0, 10))
     
-    # Generate a response considering the emotion
-    response = generate_text(user_input, emotion)
+    # Get the current dominant emotion
+    dominant_emotion = get_dominant_emotion()
+    
+    # Generate a response considering the dominant emotion
+    response = generate_text(user_input, dominant_emotion)
+    
+    # Update emotion history
+    update_emotion_history(predicted_emotion, emotions[predicted_emotion]['intensity'])
     
     # Update chat history
     chat_history.append((user_input, response))
     
-    return response, chat_history
+    # Evolve emotions periodically (e.g., every 10 interactions)
+    if len(chat_history) % 10 == 0:
+        evolve_emotions()
+    
+    return response, chat_history, get_emotion_summary()
+
+def chat_interface(user_input, history):
+    response, updated_history, emotion_summary = respond_to_user(user_input, history)
+    return response, updated_history, emotion_summary
 
 # Gradio interface
 iface = gr.Interface(
-    fn=respond_to_user,
-    inputs=["text", "state"],
-    outputs=["text", "state"],
-    title="Emotion-Aware Chatbot",
+    fn=chat_interface,
+    inputs=[
+        gr.Textbox(lines=2, placeholder="Type your message here..."),
+        gr.State([])
+    ],
+    outputs=[
+        gr.Textbox(label="AI Response"),
+        gr.State(),
+        gr.Textbox(label="Current Emotional State", lines=10)
+    ],
+    title="Emotion-Aware AI Chatbot",
     description="Chat with an AI that understands and responds to emotions.",
+    allow_flagging="never",
+    theme="default"
+)
+
+# Add a button to reset emotions
+reset_button = gr.Button("Reset Emotions")
+reset_button.click(
+    fn=reset_emotions,
+    inputs=None,
+    outputs=gr.Textbox(label="Current Emotional State", lines=10),
+    api_name="reset_emotions"
 )
 
 if __name__ == "__main__":