Update app.py

app.py

@@ -1,9 +1,3 @@
-import warnings
-import numpy as np
-import pandas as pd
-import os
-import json
-import random
 import gradio as gr
 import torch
 from sklearn.preprocessing import OneHotEncoder
@@ -17,51 +11,24 @@ from nltk.chunk import ne_chunk
 from textblob import TextBlob
 import matplotlib.pyplot as plt
 import seaborn as sns
-import ssl
-import spacy
-from spacy import displacy
-from collections import Counter
-import en_core_web_sm
-from gensim import corpora
-from gensim.models import LdaModel
-from gensim.utils import simple_preprocess
-from neuralcoref import NeuralCoref
-
-# NLTK data download
-try:
-    _create_unverified_https_context = ssl._create_unverified_context
-except AttributeError:
-    pass
-else:
-    ssl._create_default_https_context = _create_unverified_https_context
 
-nltk.download('words', quiet=True)
+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)
 nltk.download('averaged_perceptron_tagger', quiet=True)
 nltk.download('maxent_ne_chunker', quiet=True)
-
-# Set NLTK data path
-nltk.data.path.append('/home/user/nltk_data')
-
-warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
-
-# Load spaCy model
-nlp = en_core_web_sm.load()
-
-# Add NeuralCoref to spaCy pipeline
-coref = NeuralCoref(nlp.vocab)
-nlp.add_pipe(coref, name='neuralcoref')
+nltk.download('words', quiet=True)
 
 # Initialize Example Dataset (For Emotion Prediction)
 data = {
     'context': [
-        'I am overjoyed', 'I am deeply saddened', 'I am seething with rage', 'I am exhilarated', 'I am tranquil',
-        'I am brimming with joy', 'I am grieving profoundly', 'I am at peace', 'I am frustrated beyond measure',
-        'I am determined to succeed', 'I feel resentment burning within me', 'I am feeling glorious and triumphant',
-        'I am motivated and inspired', 'I am utterly surprised', 'I am gripped by fear', 'I am trusting and open',
-        'I feel a sense of disgust', 'I am optimistic and hopeful', 'I am pessimistic and gloomy', 'I feel bored and listless',
-        'I am envious and jealous'
+        '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',
@@ -83,39 +50,33 @@ 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 = None
-emotion_prediction_tokenizer = None
-
-# Load pre-trained large language model and tokenizer for response generation
-response_model = None
-response_tokenizer = None
-
-def load_models():
-    global emotion_prediction_model, emotion_prediction_tokenizer, response_model, response_tokenizer
-    if emotion_prediction_model is None or response_model is None:
-        emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
-        emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
-        response_model_name = "gpt2-xl"
-        response_tokenizer = AutoTokenizer.from_pretrained(response_model_name)
-        response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
-        response_tokenizer.pad_token = response_tokenizer.eos_token
+emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
+emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
+
+# Load pre-trained LLM model and tokenizer for response generation with increased context window
+response_model_name = "microsoft/DialoGPT-medium"
+response_tokenizer = AutoTokenizer.from_pretrained(response_model_name)
+response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
+
+# Set the pad token
+response_tokenizer.pad_token = response_tokenizer.eos_token
 
 # Enhanced Emotional States
 emotions = {
-    'joy': {'percentage': 20, 'motivation': 'positive and uplifting', 'intensity': 8},
-    'sadness': {'percentage': 15, 'motivation': 'reflective and introspective', 'intensity': 6},
-    'anger': {'percentage': 15, 'motivation': 'passionate and driven', 'intensity': 7},
-    'fear': {'percentage': 10, 'motivation': 'cautious and protective', 'intensity': 5},
-    'love': {'percentage': 15, 'motivation': 'affectionate and caring', 'intensity': 7},
-    'surprise': {'percentage': 10, 'motivation': 'curious and intrigued', 'intensity': 6},
-    'neutral': {'percentage': 15, 'motivation': 'balanced and composed', 'intensity': 4},
+    'joy': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
+    'sadness': {'percentage': 10, 'motivation': 'negative', 'intensity': 0},
+    'anger': {'percentage': 10, 'motivation': 'traumatic or strong', 'intensity': 0},
+    'fear': {'percentage': 10, 'motivation': 'defensive', 'intensity': 0},
+    'love': {'percentage': 10, 'motivation': 'affectionate', 'intensity': 0},
+    'surprise': {'percentage': 10, 'motivation': 'unexpected', 'intensity': 0},
+    'neutral': {'percentage': 40, 'motivation': 'balanced', 'intensity': 0},
 }
 
 total_percentage = 100
 emotion_history_file = 'emotion_history.json'
 global conversation_history
 conversation_history = []
-max_history_length = 1000  # Increase the maximum history length
+max_history_length = 30
 
 def load_historical_data(file_path=emotion_history_file):
     if os.path.exists(file_path):
@@ -141,6 +102,7 @@ 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)
 
@@ -159,7 +121,6 @@ def evolve_emotions():
     toolbox.register("attr_float", random.uniform, 0, 100)
     toolbox.register("attr_intensity", random.uniform, 0, 10)
     toolbox.register("individual", tools.initCycle, creator.Individual,
-                    toolbox.register("individual", tools.initCycle, creator.Individual,
                      (toolbox.attr_float,) * len(emotions) +
                      (toolbox.attr_intensity,) * len(emotions), n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
@@ -176,8 +137,73 @@ def evolve_emotions():
     emotion_values = best_individual[:len(emotions)]
     intensities = best_individual[len(emotions):]
 
+    for i, (emotion, data) in enumerate(emotions.items()):
+        data['percentage'] = emotion_values[i]
+        data['intensity'] = intensities[i]
+
+    # 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)
+
+# Adding 443 features
+additional_features = {}
+for i in range(443):
+    additional_features[f'feature_{i+1}'] = 0
+
+def feature_transformations():
+    global additional_features
+    for feature in additional_features:
+        additional_features[feature] += random.uniform(-1, 1)
+
+def generate_response(input_text, ai_emotion):
+    global conversation_history
+    # 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", padding=True, 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,
+            attention_mask=inputs.attention_mask,
+            max_length=1024,
+            num_return_sequences=1,
+            no_repeat_ngram_size=2,
+            do_sample=True,
+            top_k=50,
+            top_p=0.95,
+            temperature=temperature,
+            pad_token_id=response_tokenizer.eos_token_id
+        )
+    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):
-    load_models()
     inputs = emotion_prediction_tokenizer(context, return_tensors="pt", truncation=True, max_length=512)
     with torch.no_grad():
         outputs = emotion_prediction_model(**inputs)
@@ -192,50 +218,12 @@ def sentiment_analysis(text):
     return sentiment_scores
 
 def extract_entities(text):
-    doc = nlp(text)
-    
-    # Named Entity Recognition
-    named_entities = [(ent.text, ent.label_) for ent in doc.ents]
-    
-    # Noun Phrases
-    noun_phrases = [chunk.text for chunk in doc.noun_chunks]
-    
-    # Key Phrases (using textrank algorithm)
-    from textacy.extract import keyterms as kt
-    keyterms = kt.textrank(doc, normalize="lemma", topn=5)
-    
-    # Dependency Parsing
-    dependencies = [(token.text, token.dep_, token.head.text) for token in doc]
-    
-    # Part-of-Speech Tagging
-    pos_tags = [(token.text, token.pos_) for token in doc]
-    
-    return {
-        "named_entities": named_entities,
-        "noun_phrases": noun_phrases,
-        "key_phrases": keyterms,
-        "dependencies": dependencies,
-        "pos_tags": pos_tags
-    }
-
-def analyze_context(text):
-    doc = nlp(text)
-    
-    # Coreference resolution
-    resolved_text = doc._.coref_resolved
-    
-    # Topic modeling
-    processed_text = simple_preprocess(resolved_text)
-    dictionary = corpora.Dictionary([processed_text])
-    corpus = [dictionary.doc2bow(processed_text)]
-    
-    lda_model = LdaModel(corpus=corpus, id2word=dictionary, num_topics=3, random_state=42)
-    topics = lda_model.print_topics()
-    
-    return {
-        "resolved_text": resolved_text,
-        "topics": topics
-    }
+    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)
@@ -247,112 +235,92 @@ def analyze_text_complexity(text):
         '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):
-    emotion_visualization_path = 'emotional_state.png'
-    try:
-        plt.figure(figsize=(8, 6))
-        emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()],
-                                   columns=['emotion', 'percentage', 'intensity'])
-        sns.barplot(x='emotion', y='percentage', data=emotions_df)
-        plt.title(f'Current Emotional State: {ai_emotion.capitalize()} ({ai_emotion_percentage:.2f}%)')
-        plt.xlabel('Emotion')
-        plt.ylabel('Percentage')
-        plt.xticks(rotation=90)
-        plt.savefig(emotion_visualization_path)
-        plt.close()
-    except Exception as e:
-        print(f"Error generating emotion visualization: {e}")
-        emotion_visualization_path = None
-    return emotion_visualization_path
-
-def generate_response(ai_emotion, input_text, entities, context_analysis):
-    load_models()
-    prompt = f"As an AI assistant, I am currently feeling {ai_emotion}. My response will reflect this emotional state. "
-    prompt += f"The input text contains the following entities: {entities['named_entities']}. "
-    prompt += f"The main topics are: {context_analysis['topics']}. "
-    prompt += f"Considering this context, here's my response to '{input_text}': "
-    
-    inputs = response_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=8192)
-    
-    temperature = 0.7
-    if ai_emotion == 'anger':
-        temperature = 0.9
-    elif ai_emotion == 'joy':
-        temperature = 0.5
+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()
 
-    with torch.no_grad():
-        response_ids = response_model.generate(
-            inputs.input_ids,
-            attention_mask=inputs.attention_mask,
-            max_length=400,
-            num_return_sequences=1,
-            no_repeat_ngram_size=2,
-            do_sample=True,
-            top_k=50,
-            top_p=0.95,
-            temperature=temperature,
-            pad_token_id=response_tokenizer.eos_token_id
-        )
-    response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True)
-    
-    return response.strip()
+    return 'emotional_state.png'
 
 def interactive_interface(input_text):
-    predicted_emotion = predict_emotion(input_text)
-    sentiment_scores = sentiment_analysis(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)
-    
-    entities = extract_entities(input_text)
-    context_analysis = analyze_context(input_text)
-    
-    response = generate_response(ai_emotion, input_text, entities, context_analysis)
-
-    conversation_history.append({'user': input_text, 'response': response})
-    if len(conversation_history) > max_history_length:
-        conversation_history.pop(0)
- return {
-        "emotion": predicted_emotion,
-        "sentiment": sentiment_scores,
-        "entities": entities,
-        "context_analysis": context_analysis,
-        "text_complexity": text_complexity,
-        "ai_emotion": ai_emotion,
-        "ai_emotion_percentage": ai_emotion_percentage,
-        "ai_emotion_intensity": ai_emotion_intensity,
-        "emotion_visualization": emotion_visualization,
-        "response": response
-    }
+    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)
+        
+        # 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,
+            'ai_emotion': ai_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):
-    result = interactive_interface(input_text)
-    
-    output = f"Predicted Emotion: {result['emotion']}\n"
-    output += f"Sentiment: {result['sentiment']}\n"
-    output += f"AI Emotion: {result['ai_emotion']} ({result['ai_emotion_percentage']:.2f}%, Intensity: {result['ai_emotion_intensity']:.2f})\n"
-    output += f"Entities: {result['entities']}\n"
-    output += f"Context Analysis: {result['context_analysis']}\n"
-    output += f"Text Complexity: {result['text_complexity']}\n"
-    output += f"AI Response: {result['response']}"
-    
-    return output, result['emotion_visualization']
+    response = interactive_interface(input_text)
+    if isinstance(response, str):
+        return response, None
+    else:
+        return (
+            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",
+            response['emotion_visualization']
+        )
 
+# Create Gradio interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs="text",
     outputs=["text", gr.Image(type="filepath")],
-    title="Enhanced AI Assistant",
-    description="Enter your text to interact with the AI assistant."
+    title="Enhanced Emotional AI Interface",
+    description="Enter text to interact with the AI and analyze emotions."
 )
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch(share=True)