Update app.py

app.py

@@ -17,7 +17,6 @@ from nltk.chunk import ne_chunk
 from textblob import TextBlob
 import matplotlib.pyplot as plt
 import seaborn as sns
-from accelerate import init_empty_weights, load_checkpoint_and_dispatch
 
 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
 
@@ -63,8 +62,7 @@ emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/di
 # Load pre-trained large language model and tokenizer for response generation with increased context window
 response_model_name = "gpt2-xl"
 response_tokenizer = AutoTokenizer.from_pretrained(response_model_name)
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-response_model = load_checkpoint_and_dispatch(AutoModelForCausalLM, response_model_name, device_map="auto")
+response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
 
 # Set the pad token
 response_tokenizer.pad_token = response_tokenizer.eos_token
@@ -98,7 +96,6 @@ def save_historical_data(historical_data, file_path=emotion_history_file):
 
 emotion_history = load_historical_data()
 
-
 def update_emotion(emotion, percentage, intensity):
     emotions[emotion]['percentage'] += percentage
     emotions[emotion]['intensity'] = intensity
@@ -150,10 +147,10 @@ def evolve_emotions():
         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
+        emotions[e]['percentage'] = (emotions[e]['percentage'] / total) * 100
 
 def update_emotion_history(emotion, percentage, intensity, context):
     entry = {
@@ -178,114 +175,155 @@ def feature_transformations():
 
 def generate_response(input_text, ai_emotion, conversation_history):
     # Prepare a prompt based on the current emotion and input
-    prompt = f"You are an AI assistant created by Sephiroth Baptiste, and you are currently feeling {ai_emotion}. Your response should reflect this emotion. Human: {input_text}\nAI:"
+    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[-100:]:  # Use last 100 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=8192).to(device)
+    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 intense
-    elif (ai_emotion == 'calmness'):
-        temperature = 0.5  # more composed
-
-    outputs = response_model.generate(
-        inputs['input_ids'],
-        max_length=500,
-        num_return_sequences=1,
-        temperature=temperature,
-        pad_token_id=response_tokenizer.eos_token_id
-    )
-
-    response = response_tokenizer.decode(outputs[0], skip_special_tokens=True)
-    response = response.replace(prompt, "").strip()
-    conversation_history.append({'user': input_text, 'response': response})
-    return response
+    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
 
-def process_input(input_text):
-    # Predict emotion of the input text
-    inputs = emotion_prediction_tokenizer(input_text, return_tensors='pt', truncation=True, padding=True).to(device)
     with torch.no_grad():
-        logits = emotion_prediction_model(**inputs).logits
-
-    predicted_class_id = torch.argmax(logits, dim=1).item()
-    predicted_emotion = emotion_classes[predicted_class_id]
-
-    # Update emotion percentages and intensities based on predicted emotion
-    update_emotion(predicted_emotion, 5, 5)  # Example increment values
-    update_emotion_history(predicted_emotion, emotions[predicted_emotion]['percentage'], emotions[predicted_emotion]['intensity'], input_text)
-
-    # Evolve emotions
-    evolve_emotions()
-
-    # Generate response
-    response = generate_response(input_text, predicted_emotion, conversation_history)
+        response_ids = response_model.generate(
+            inputs.input_ids,
+            attention_mask=inputs.attention_mask,
+            max_length=8192,
+            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)
     
-    # Feature transformations
-    feature_transformations()
-
+    # Extract only the AI's response
+    response = response.split("AI:")[-1].strip()
     return response
 
-def plot_emotion_distribution():
-    emotion_labels = list(emotions.keys())
-    emotion_percentages = [emotions[emotion]['percentage'] for emotion in emotion_labels]
-    emotion_intensities = [emotions[emotion]['intensity'] for emotion in emotion_labels]
-
-    fig, ax1 = plt.subplots(figsize=(10, 6))
-
-    ax2 = ax1.twinx()
-    ax1.bar(emotion_labels, emotion_percentages, color='b', alpha=0.6)
-    ax2.plot(emotion_labels, emotion_intensities, color='r', marker='o', linestyle='dashed', linewidth=2)
+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 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
+    }
 
-    ax1.set_xlabel('Emotion')
-    ax1.set_ylabel('Percentage', color='b')
-    ax2.set_ylabel('Intensity', color='r')
+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()
 
-    plt.title('Emotion Distribution and Intensities')
-    plt.show()
+    return 'emotional_state.png'
 
-def clear_conversation_history():
+def interactive_interface(input_text):
     global conversation_history
-    conversation_history = []
-
-# Function to display the history of the 10 most recent conversations
-def display_recent_conversations():
-    num_conversations = min(len(conversation_history), 10)
-    recent_conversations = conversation_history[-num_conversations:]
-
-    conversation_text = ""
-    for i, conversation in enumerate(recent_conversations, start=1):
-        conversation_text += f"Conversation {i}:\n"
-        conversation_text += f"User: {conversation['user']}\n"
-        conversation_text += f"AI: {conversation['response']}\n\n"
-
-    return conversation_text.strip()
-
-with gr.Blocks() as chatbot:
-    gr.Markdown("# AI Chatbot with Enhanced Emotions")
-    
-    with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(label="Input Text")
-            response_text = gr.Textbox(label="Response", interactive=False)
-            send_button = gr.Button("Send")
-            clear_button = gr.Button("Clear Conversation History")
-    
-    with gr.Row():
-        recent_conversations = gr.Textbox(label="Recent Conversations", interactive=False)
-        update_button = gr.Button("Update Recent Conversations")
-    
-    with gr.Row():
-        emotion_plot = gr.Plot(label="Emotion Distribution and Intensities")
-        update_plot_button = gr.Button("Update Emotion Plot")
-    
-    send_button.click(fn=process_input, inputs=input_text, outputs=response_text)
-    clear_button.click(fn=clear_conversation_history)
-    update_button.click(fn=display_recent_conversations, outputs=recent_conversations)
-    update_plot_button.click(fn=plot_emotion_distribution, outputs=emotion_plot)
-
-chatbot.launch()
+    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,
+            'ai_emotion': ai_emotion,
+            'sentiment_scores': sentiment_scores,
+            'entities': entities,
+            'text_complexity': text_complexity,
+            'response': response,
+            'emotion_visualization': emotion_visualization
+        }
+        
+        return analysis_result
+    except Exception as e:
+        print(f"Error: {e}")
+        return {
+            'predicted_user_emotion': 'unknown',
+            'ai_emotion': 'neutral',
+            'sentiment_scores': {'compound': 0, 'neg': 0, 'neu': 1, 'pos': 0},
+            'entities': [],
+            'text_complexity': {'word_count': 0, 'sentence_count': 0, 'average_sentence_length': 0, 'polarity': 0, 'subjectivity': 0},
+            'response': "I'm sorry, but I encountered an error and was unable to generate a response.",
+            'emotion_visualization': 'emotional_state.png'
+        }
+
+# Create a Gradio interface
+gr.Interface(
+    fn=interactive_interface,
+    inputs=gr.Textbox(label="Your Message"),
+    outputs=[
+        gr.Textbox(label="Predicted User Emotion"),
+        gr.Textbox(label="AI Emotion"),
+        gr.Textbox(label="Sentiment Scores"),
+        gr.Textbox(label="Extracted Entities"),
+        gr.Textbox(label="Text Complexity"),
+        gr.Textbox(label="AI Response"),
+        gr.Image(label="Emotional State Visualization")
+    ],
+    title="Emotion-Aware AI Assistant",
+    description="Interact with an AI assistant that responds based on its emotional state.",
+).launch()