Update app.py

app.py

@@ -144,34 +144,60 @@ def evolve_emotions():
     intensities = best_individual[len(emotions):]
 
     for i, (emotion, data) in enumerate(emotions.items()):
-        data['percentage'] = emotion_values[i]
+      data['percentage'] = emotion_values[i]
         data['intensity'] = intensities[i]
 
-   # Normalize percentages
+    # 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 = {
-        'emotion': emotion,
-        'percentage': percentage,
-        'intensity': intensity,
-        'context': context,
-        'timestamp': pd.Timestamp.now().isoformat()
-    }
-    emotion_history.append(entry)
-    save_historical_data(emotion_history)
+def predict_emotion(context):
+    inputs = emotion_prediction_tokenizer(context, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        outputs = emotion_prediction_model(**inputs)
+    probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    predicted_class = torch.argmax(probabilities, dim=-1).item()
+    emotion_labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+    return emotion_labels[predicted_class]
 
-# Adding 443 features
-additional_features = {}
-for i in range(443):
-    additional_features[f'feature_{i+1}'] = 0
+def sentiment_analysis(text):
+    sia = SentimentIntensityAnalyzer()
+    sentiment_scores = sia.polarity_scores(text)
+    return sentiment_scores
 
-def feature_transformations():
-    global additional_features
-    for feature in additional_features:
-        additional_features[feature] += random.uniform(-1, 1)
+def extract_entities(text):
+    chunked = ne_chunk(pos_tag(word_tokenize(text)))
+    entities = []
+    for chunk in chunked:
+        if hasattr(chunk, 'label'):
+            entities.append(((' '.join(c[0] for c in chunk)), chunk.label()))
+    return entities
+
+def analyze_text_complexity(text):
+    blob = TextBlob(text)
+    return {
+        'word_count': len(blob.words),
+        'sentence_count': len(blob.sentences),
+        'average_sentence_length': len(blob.words) / len(blob.sentences) if len(blob.sentences) > 0 else 0,
+        'polarity': blob.sentiment.polarity,
+        'subjectivity': blob.sentiment.subjectivity
+    }
+
+def get_ai_emotion(input_text):
+    predicted_emotion = predict_emotion(input_text)
+    ai_emotion = predicted_emotion
+    ai_emotion_percentage = emotions[predicted_emotion]['percentage']
+    ai_emotion_intensity = emotions[predicted_emotion]['intensity']
+    return ai_emotion, ai_emotion_percentage, ai_emotion_intensity
+
+def generate_emotion_visualization(ai_emotion, ai_emotion_percentage, ai_emotion_intensity):
+    # Generate an emotion visualization based on the AI's emotional state
+    # This could involve creating an image or a visualization using Matplotlib/Seaborn
+    # The generated image should be saved and returned as the output
+    emotion_visualization_path = 'emotional_state.png'
+    # Generate and save the emotion visualization
+    return emotion_visualization_path
 
 def generate_response(input_text, ai_emotion, conversation_history):
     # Prepare a prompt based on the current emotion and input
@@ -209,118 +235,83 @@ def generate_response(input_text, ai_emotion, conversation_history):
     response = response.split("AI:")[-1].strip()
     return response
 
-def predict_emotion(context):
-    inputs = emotion_prediction_tokenizer(context, return_tensors="pt", truncation=True, max_length=512)
-    with torch.no_grad():
-        outputs = emotion_prediction_model(**inputs)
-    probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    predicted_class = torch.argmax(probabilities, dim=-1).item()
-    emotion_labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
-    return emotion_labels[predicted_class]
-
-def sentiment_analysis(text):
-    sia = SentimentIntensityAnalyzer()
-    sentiment_scores = sia.polarity_scores(text)
-    return sentiment_scores
-
-def extract_entities(text):
-    chunked = ne_chunk(pos_tag(word_tokenize(text)))
-    entities = []
-    for chunk in chunked:
-        if hasattr(chunk, 'label'):
-            entities.append(((' '.join(c[0] for c in chunk)), chunk.label()))
-    return entities
+def interactive_interface(input_text):
+    # Perform your processing logic here
+    predicted_emotion = predict_emotion(input_text)
+    sentiment_scores = sentiment_analysis(input_text)
+    entities = extract_entities(input_text)
+    text_complexity = analyze_text_complexity(input_text)
+    ai_emotion, ai_emotion_percentage, ai_emotion_intensity = get_ai_emotion(input_text)
+    emotion_visualization = generate_emotion_visualization(ai_emotion, ai_emotion_percentage, ai_emotion_intensity)
+    response = generate_response(input_text, ai_emotion, conversation_history)
+
+    # Update conversation history
+    conversation_history.append({'user': input_text, 'response': response})
+    if len(conversation_history) > max_history_length:
+        conversation_history.pop(0)
+
+    # Return the expected outputs in the correct order
+    return (
+        gr.Textbox(predicted_emotion),
+        gr.Textbox(str(sentiment_scores)),
+        gr.Textbox(str(entities)),
+        gr.Textbox(str(text_complexity)),
+        gr.Textbox(ai_emotion),
+        gr.Textbox(str(ai_emotion_percentage)),
+        gr.Textbox(str(ai_emotion_intensity)),
+        gr.Image(emotion_visualization),
+        gr.Textbox(response)
+    )
+
+# 443 additional features
+additional_features = {}
+for i in range(443):
+    additional_features[f'feature_{i+1}'] = 0
 
-def analyze_text_complexity(text):
-    blob = TextBlob(text)
-    return {
-        'word_count': len(blob.words),
-        'sentence_count': len(blob.sentences),
-        'average_sentence_length': len(blob.words) / len(blob.sentences) if len(blob.sentences) > 0 else 0,
-        'polarity': blob.sentiment.polarity,
-        'subjectivity': blob.sentiment.subjectivity
-    }
+def feature_transformations():
+    global additional_features
+    for feature in additional_features:
+        additional_features[feature] += random.uniform(-1, 1)
 
 def visualize_emotions():
     emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()],
-                               columns=['Emotion', 'Percentage', 'Intensity'])
-    
+                               columns=['emotion', 'percentage', 'intensity'])
+
     plt.figure(figsize=(12, 6))
-    sns.barplot(x='Emotion', y='Percentage', data=emotions_df)
-    plt.title('Current Emotional State of the AI')
-    plt.xticks(rotation=45, ha='right')
-    plt.tight_layout()
-    plt.savefig('emotional_state.png')
-    plt.close()
+    sns.barplot(x='emotion', y='percentage', data=emotions_df)
+    plt.title('Emotion Percentages')
+    plt.xlabel('Emotion')
+    plt.ylabel('Percentage')
+    plt.xticks(rotation=90)
+    plt.savefig('emotion_percentages.png')
 
-    return 'emotional_state.png'
+    plt.figure(figsize=(12, 6))
+    sns.barplot(x='emotion', y='intensity', data=emotions_df)
+    plt.title('Emotion Intensities')
+    plt.xlabel('Emotion')
+    plt.ylabel('Intensity')
+    plt.xticks(rotation=90)
+    plt.savefig('emotion_intensities.png')
 
-def interactive_interface(input_text):
-    global conversation_history
-    try:
-        evolve_emotions()
-        predicted_emotion = predict_emotion(input_text)
-        sentiment_scores = sentiment_analysis(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))
-        
-        # 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, conversation_history)
-        
-        # 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_user_emotion': predicted_emotion,
-            'sentiment_scores': sentiment_scores,
-            'entities': entities,
-            'text_complexity': text_complexity,
-            'ai_emotion': ai_emotion,
-            'ai_emotion_percentage': emotions[ai_emotion]['percentage'],
-            'ai_emotion_intensity': emotions[ai_emotion]['intensity'],
-            'emotion_visualization': emotion_visualization
-        }
-        
-        return analysis_result
-    except Exception as e:
-        print(f"Error: {e}")
-        return {'error': str(e)}
-
-# Define the Gradio interface
-demo = gr.Interface(
+    return 'emotion_percentages.png', 'emotion_intensities.png'
+
+# Create the Gradio interface
+iface = gr.Interface(
     fn=interactive_interface,
-    inputs=gr.Textbox(label="Enter your message"),
+    inputs=gr.Textbox(label="Input Text"),
     outputs=[
-        gr.Textbox(label="Predicted User Emotion"),
+        gr.Textbox(label="Predicted Emotion"),
         gr.Textbox(label="Sentiment Scores"),
         gr.Textbox(label="Extracted Entities"),
         gr.Textbox(label="Text Complexity"),
         gr.Textbox(label="AI Emotion"),
         gr.Textbox(label="AI Emotion Percentage"),
         gr.Textbox(label="AI Emotion Intensity"),
-        gr.Image(label="Emotional State Visualization")
+        gr.Image(label="Emotion Visualization"),
+        gr.Textbox(label="AI Response")
     ],
     title="Emotional AI Assistant",
-    description="Interact with an AI assistant that adapts its responses based on its emotional state."
+    description="An AI assistant that can analyze the emotional content of text and generate responses based on its emotional state.",
 )
 
-# Launch the Gradio interface
-demo.launch()
+iface.launch()