Update app.py

app.py

@@ -10,9 +10,22 @@ 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 nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+from textblob import TextBlob
+import spacy
+import matplotlib.pyplot as plt
+import seaborn as sns
 
 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
 
+# Download necessary NLTK data
+nltk.download('vader_lexicon', quiet=True)
+nltk.download('punkt', quiet=True)
+
+# Load spaCy model
+nlp = spacy.load("en_core_web_sm")
+
 # Initialize Example Dataset (For Emotion Prediction)
 data = {
     'context': [
@@ -110,6 +123,10 @@ def update_emotion(emotion, percentage, intensity):
 def normalize_context(context):
     return context.lower().strip()
 
+# Create FitnessMulti and Individual outside of evolve_emotions
+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]
@@ -120,11 +137,7 @@ def evaluate(individual):
     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)
@@ -147,10 +160,11 @@ def evolve_emotions():
     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]
+    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]
 
     emotions['ideal_state']['percentage'] = ideal_state
 
@@ -176,41 +190,116 @@ def feature_transformations():
         additional_features[feature] += random.uniform(-1, 1)
 
 def generate_response(input_text):
-    inputs = response_tokenizer(input_text, return_tensors="pt")
-    response_ids = response_model.generate(inputs.input_ids, max_length=int(inputs.input_ids.shape[1] * 2.289))
-    response = response_tokenizer.decode(response_ids[:, inputs.input_ids.shape[1]:][0], skip_special_tokens=True)
+    inputs = response_tokenizer(input_text, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        response_ids = response_model.generate(
+            inputs.input_ids,
+            max_length=150,
+            num_return_sequences=1,
+            no_repeat_ngram_size=2,
+            top_k=50,
+            top_p=0.95,
+            temperature=0.7
+        )
+    response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True)
     return response
 
 def predict_emotion(context):
-    inputs = emotion_prediction_tokenizer(context, return_tensors="pt")
-    outputs = emotion_prediction_model(**inputs)
-    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    predicted_class = torch.argmax(predictions, dim=-1).item()
-    predicted_emotion = emotion_classes[predicted_class]
-    return predicted_emotion
-
-def interactive_interface(context):
-    normalized_context = normalize_context(context)
-    predicted_emotion = predict_emotion(normalized_context)
-    update_emotion(predicted_emotion, random.uniform(5, 15), random.uniform(1, 10))
-    update_emotion_history(predicted_emotion, emotions[predicted_emotion]['percentage'], emotions[predicted_emotion]['intensity'], normalized_context)
-    evolve_emotions()
-    feature_transformations()
-    response = generate_response(normalized_context)
-    return response
+    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):
+    doc = nlp(text)
+    entities = [(ent.text, ent.label_) for ent in doc.ents]
+    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 visualize_emotions():
+    emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()],
+                               columns=['Emotion', 'Percentage', 'Intensity'])
+    
+    plt.figure(figsize=(12, 6))
+    sns.barplot(x='Emotion', y='Percentage', data=emotions_df)
+    plt.title('Current Emotional State')
+    plt.xticks(rotation=45, ha='right')
+    plt.tight_layout()
+    plt.savefig('emotional_state.png')
+    plt.close()
+
+    return 'emotional_state.png'
+
+def interactive_interface(input_text):
+    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_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)
+        
+        emotion_visualization = visualize_emotions()
+        
+        analysis_result = {
+            'predicted_emotion': predicted_emotion,
+            'sentiment_scores': sentiment_scores,
+            'entities': entities,
+            'text_complexity': text_complexity,
+            'current_emotional_state': emotions,
+            'response': response,
+            'emotion_visualization': emotion_visualization
+        }
+        
+        return analysis_result
+    except Exception as e:
+        print(f"An error occurred: {str(e)}")
+        return "I apologize, but I encountered an error while processing your input. Please try again."
 
-# Gradio Interface
 def gradio_interface(input_text):
     response = interactive_interface(input_text)
-    return response
+    if isinstance(response, str):
+        return response
+    else:
+        return (
+            f"Predicted Emotion: {response['predicted_emotion']}\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"Emotion Visualization: {response['emotion_visualization']}"
+        )
 
+# Create Gradio interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs="text",
-    outputs="text",
-    title="Emotion-aware AI with Enhanced Features",
-    description="An AI that predicts emotions from text and generates responses with 443 additional features."
+    outputs=["text", gr.Image(type="filepath")],
+    title="Enhanced Emotional AI Interface",
+    description="Enter text to interact with the AI and analyze emotions."
 )
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()