Update app.py

app.py

@@ -1,331 +1,185 @@
-import warnings 
-import numpy as np
-import pandas as pd
+import warnings
 import os
 import json
 import random
 import gradio as gr
 import torch
-from sklearn.preprocessing import OneHotEncoder
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM, pipeline
-from deap import base, creator, tools, algorithms
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
 import nltk
 from nltk.sentiment import SentimentIntensityAnalyzer
-from nltk.tokenize import word_tokenize
-from nltk.tag import pos_tag
-from nltk.chunk import ne_chunk
 from textblob import TextBlob
-import matplotlib.pyplot as plt
-import seaborn as sns
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM
+
+warnings.filterwarnings('ignore', category=FutureWarning)
 
-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)
-nltk.download('words', quiet=True)
-
-# Initialize Example Dataset (For Emotion Prediction)
-data = {
-    'context': [
-        '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',
-        'determination', 'resentment', 'glory', 'motivation', 'surprise', 'fear', 'trust',
-        'disgust', 'optimism', 'pessimism', 'boredom', 'envy'
-    ]
-}
-df = pd.DataFrame(data)
 
-# Encoding the contexts using One-Hot Encoding (memory-efficient)
+# ---------------------------
+# Backend Support for GGUF Models
+# ---------------------------
+# Attempt to import a llama_cpp binding if available.
+# Otherwise, fallback to the Hugging Face transformers interface.
 try:
-    encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=True)
-except TypeError:
-    encoder = OneHotEncoder(handle_unknown='ignore', sparse=True)
-contexts_encoded = encoder.fit_transform(df[['context']])
-
-# Encoding emotions
-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 = 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': 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 = 30
-
-def load_historical_data(file_path=emotion_history_file):
-    if os.path.exists(file_path):
-        with open(file_path, 'r') as file:
-            return json.load(file)
-    return []
-
-def save_historical_data(historical_data, file_path=emotion_history_file):
-    with open(file_path, 'w') as file:
-        json.dump(historical_data, file)
-
-emotion_history = load_historical_data()
-
-def update_emotion(emotion, percentage, intensity):
-    emotions[emotion]['percentage'] += percentage
-    emotions[emotion]['intensity'] = intensity
-
-    # Normalize percentages
-    total = sum(e['percentage'] for e in emotions.values())
-    for e in emotions:
-        emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100
-
-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)]
-    intensities = individual[len(emotions):]
-    
-    total_diff = abs(100 - sum(emotion_values))
-    intensity_range = max(intensities) - min(intensities)
-    emotion_balance = max(emotion_values) - min(emotion_values)
-    
-    return total_diff, intensity_range, emotion_balance
-
-def evolve_emotions():
-    toolbox = base.Toolbox()
-    toolbox.register("attr_float", random.uniform, 0, 100)
-    toolbox.register("attr_intensity", random.uniform, 0, 10)
-    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)
-    toolbox.register("mate", tools.cxTwoPoint)
-    toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
-    toolbox.register("select", tools.selNSGA2)
-    toolbox.register("evaluate", evaluate)
-
-    population = toolbox.population(n=100)
-    algorithms.eaMuPlusLambda(population, toolbox, mu=50, lambda_=100, cxpb=0.7, mutpb=0.2, ngen=50,
-                               stats=None, halloffame=None, verbose=False)
-
-    best_individual = tools.selBest(population, k=1)[0]
-    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
+    # Hypothetical llama_cpp Python binding for GGUF support
+    from llama_cpp import Llama
+    BACKEND = "llama_cpp"
+except ImportError:
+    BACKEND = "transformers"
+
+# ---------------------------
+# Emotional Analysis Module
+# ---------------------------
+class EmotionalAnalyzer:
+    def __init__(self):
+        # Load a pre-trained emotion classifier model and tokenizer
+        self.emotion_model = AutoModelForSequenceClassification.from_pretrained(
+            "bhadresh-savani/distilbert-base-uncased-emotion"
         )
-    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):
-    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
+        self.emotion_tokenizer = AutoTokenizer.from_pretrained(
+            "bhadresh-savani/distilbert-base-uncased-emotion"
+        )
+        # Define labels according to the model card
+        self.emotion_labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+        self.sia = SentimentIntensityAnalyzer()
+
+    def predict_emotion(self, text):
+        inputs = self.emotion_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+        with torch.no_grad():
+            outputs = self.emotion_model(**inputs)
+        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        predicted_idx = torch.argmax(probabilities, dim=-1).item()
+        return self.emotion_labels[predicted_idx]
+
+    def sentiment_analysis(self, text):
+        return self.sia.polarity_scores(text)
+
+    def detailed_emotional_analysis(self, text):
+        """Combine VADER and TextBlob analysis for richer emotional insight."""
+        vader_scores = self.sentiment_analysis(text)
+        blob = TextBlob(text)
+        textblob_analysis = {
+            'polarity': blob.sentiment.polarity,
+            'subjectivity': blob.sentiment.subjectivity,
+            'word_count': len(blob.words),
+            'sentence_count': len(blob.sentences)
+        }
+        predicted_emotion = self.predict_emotion(text)
+        return {
+            'predicted_emotion': predicted_emotion,
+            'vader': vader_scores,
+            'textblob': textblob_analysis
+        }
 
-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(self, emotions_dict):
+        """Plot a bar chart of the current emotional state."""
+        emotions_df = pd.DataFrame(list(emotions_dict.items()), columns=['Emotion', 'Percentage'])
+        plt.figure(figsize=(8, 4))
+        sns.barplot(x='Emotion', y='Percentage', data=emotions_df)
+        plt.title('Current Emotional State')
+        plt.tight_layout()
+        image_path = 'emotional_state.png'
+        plt.savefig(image_path)
+        plt.close()
+        return image_path
+
+# ---------------------------
+# LLM Response Generator Module
+# ---------------------------
+class LLMResponder:
+    def __init__(self, model_name="SicariusSicariiStuff/Impish_LLAMA_3B_GGUF"):
+        self.model_name = model_name
+        if BACKEND == "llama_cpp":
+            # Initialize using llama_cpp backend (adjust parameters as needed)
+            self.llm = Llama(model_path="path/to/gguf/file.gguf", n_ctx=1024)
+            self.backend = "llama_cpp"
+        else:
+            # Load using Hugging Face transformers interface
+            self.llm_tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.llm_model = AutoModelForCausalLM.from_pretrained(model_name)
+            self.backend = "transformers"
+
+    def generate_response(self, prompt):
+        if self.backend == "llama_cpp":
+            # Use llama_cpp inference (example API call, adjust as needed)
+            result = self.llm(prompt=prompt, max_tokens=256, temperature=0.95, top_p=0.95)
+            response = result.get("response", "")
+        else:
+            inputs = self.llm_tokenizer(prompt, return_tensors="pt", truncation=True, max_length=1024)
+            with torch.no_grad():
+                output_ids = self.llm_model.generate(
+                    inputs.input_ids,
+                    max_length=1024,
+                    do_sample=True,
+                    top_p=0.95,
+                    top_k=50,
+                    pad_token_id=self.llm_tokenizer.eos_token_id
+                )
+            response = self.llm_tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        return response
+
+# ---------------------------
+# Main Interactive Interface Function
+# ---------------------------
+def interactive_interface(input_text):
+    # Initialize modules
+    emotion_analyzer = EmotionalAnalyzer()
+    llm_responder = LLMResponder()
+
+    # Perform detailed emotional analysis
+    emotional_data = emotion_analyzer.detailed_emotional_analysis(input_text)
+    # For demonstration, we simulate a dynamic emotional state dictionary update.
+    # In a real-world scenario, this could be updated based on conversation history.
+    current_emotions = {
+        'joy': random.randint(10, 30),
+        'sadness': random.randint(5, 20),
+        'anger': random.randint(10, 25),
+        'fear': random.randint(5, 15),
+        'love': random.randint(10, 30),
+        'surprise': random.randint(5, 20)
     }
+    emotion_image = emotion_analyzer.visualize_emotions(current_emotions)
 
-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()
+    # Create a prompt that combines the input and the detected emotion
+    prompt = (f"Input: {input_text}\n"
+              f"Detected Emotion: {emotional_data['predicted_emotion']}\n"
+              f"VADER Scores: {emotional_data['vader']}\n"
+              "Provide a thoughtful, emotionally aware response that reflects the above data:")
 
-    return 'emotional_state.png'
+    llm_response = llm_responder.generate_response(prompt)
 
-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)
-        
-        # 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."
+    # Organize the result into a dictionary
+    result = {
+        'detailed_emotional_analysis': emotional_data,
+        'llm_response': llm_response,
+        'emotion_visualization': emotion_image
+    }
+    return result
 
 def gradio_interface(input_text):
-    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
+    result = interactive_interface(input_text)
+    output_text = (
+        f"Detailed Emotional Analysis:\n"
+        f" - Predicted Emotion: {result['detailed_emotional_analysis']['predicted_emotion']}\n"
+        f" - VADER: {result['detailed_emotional_analysis']['vader']}\n"
+        f" - TextBlob: {result['detailed_emotional_analysis']['textblob']}\n\n"
+        f"LLM Response:\n{result['llm_response']}"
+    )
+    return output_text, result['emotion_visualization']
+
+# ---------------------------
+# Create Gradio Interface
+# ---------------------------
 iface = gr.Interface(
     fn=gradio_interface,
     inputs="text",
     outputs=["text", gr.Image(type="filepath")],
-    title="Enhanced Emotional AI Interface",
-    description="Enter text to interact with the AI and analyze emotions."
+    title="Enhanced Emotional Analysis with GGUF LLM Support",
+    description="Enter text to perform detailed emotional analysis and generate an emotionally aware response using the Impish_LLAMA_3B_GGUF model."
 )
 
 if __name__ == "__main__":
     iface.launch(share=True)
+