Update app.py

app.py

@@ -18,6 +18,14 @@ 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:
@@ -38,6 +46,13 @@ 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')
+
 # Initialize Example Dataset (For Emotion Prediction)
 data = {
     'context': [
@@ -144,6 +159,7 @@ 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,28 +192,50 @@ def sentiment_analysis(text):
     return sentiment_scores
 
 def extract_entities(text):
-    # Lazy load the necessary NLTK data
-    try:
-        nltk.data.find('tokenizers/punkt')
-    except LookupError:
-        nltk.download('punkt', quiet=True, raise_on_error=True)
-
-    try:
-        nltk.data.find('taggers/averaged_perceptron_tagger')
-    except LookupError:
-        nltk.download('averaged_perceptron_tagger', quiet=True, raise_on_error=True)
-
-    try:
-        nltk.data.find('chunkers/maxent_ne_chunker')
-    except LookupError:
-        nltk.download('maxent_ne_chunker', quiet=True, raise_on_error=True)
+    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
+    }
 
-    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_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
+    }
 
 def analyze_text_complexity(text):
     blob = TextBlob(text)
@@ -217,10 +255,8 @@ def get_ai_emotion(input_text):
     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
     emotion_visualization_path = 'emotional_state.png'
     try:
-        # Generate and save the emotion visualization
         plt.figure(figsize=(8, 6))
         emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()],
                                    columns=['emotion', 'percentage', 'intensity'])
@@ -236,20 +272,20 @@ def generate_emotion_visualization(ai_emotion, ai_emotion_percentage, ai_emotion
         emotion_visualization_path = None
     return emotion_visualization_path
 
-def generate_response(ai_emotion, input_text):
+def generate_response(ai_emotion, input_text, entities, context_analysis):
     load_models()
-    # Prepare a prompt based on the current emotion
-    prompt = f"As an AI assistant, I am currently feeling {ai_emotion}. My response will reflect this emotional state."
+    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}': "
     
-    # Generate the response
     inputs = response_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=8192)
     
-    # Adjust generation parameters based on emotion
     temperature = 0.7
     if ai_emotion == 'anger':
-        temperature = 0.9  # More randomness for angry responses
+        temperature = 0.9
     elif ai_emotion == 'joy':
-        temperature = 0.5  # More focused responses for joyful state
+        temperature = 0.5
 
     with torch.no_grad():
         response_ids = response_model.generate(
@@ -266,43 +302,57 @@ def generate_response(ai_emotion, input_text):
         )
     response = response_tokenizer.decode(response_ids[0], skip_special_tokens=True)
     
-    # Extract only the AI's response
     return response.strip()
 
 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(ai_emotion, input_text)
+    
+    entities = extract_entities(input_text)
+    context_analysis = analyze_context(input_text)
+    
+    response = generate_response(ai_emotion, input_text, entities, context_analysis)
 
-    # Update conversation history
     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
+    }
 
-    # Save conversation history to a file
-    save_historical_data(conversation_history)
-
-    # Return the expected outputs in the correct order
-    return (
-        gr.Textbox(value=predicted_emotion, label="Predicted Emotion"),
-        gr.Textbox(value=str(sentiment_scores), label="Sentiment Scores"),
-        gr.Textbox(value=str(entities), label="Extracted Entities"),
-        gr.Textbox(value=str(text_complexity), label="Text Complexity"),
-        gr.Textbox(value=response, label="AI Response"),
-        gr.Image(value=emotion_visualization, label="Emotion Visualization")
-    )
-
-# Create the Gradio interface
-iface = gr.Interface(fn=interactive_interface, inputs="text", outputs=[
-    "text", "text", "text", "text", "text", "image"
-], title="Emotion-Aware AI Assistant")
-
-# Launch the interface
-iface.launch()
-
-
+# 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']
+
+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."
+)
+
+if __name__ == "__main__":
+    iface.launch()