Update app.py

app.py

@@ -63,9 +63,13 @@ 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")
+
 with init_empty_weights():
     response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
     response_model.tie_weights()
+response_model.to(device)
+
 # Set the pad token
 response_tokenizer.pad_token = response_tokenizer.eos_token
 
@@ -183,149 +187,108 @@ def generate_response(input_text, ai_emotion, conversation_history):
     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)
+    inputs = response_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=8192).to(device)
     
     # 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(), torch.cuda.amp.autocast():
-        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)
-    
-    # Extract only the AI's response
-    response = response.split("AI:")[-1].strip()
+    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
 
-def predict_emotion(context):
-    inputs = emotion_prediction_tokenizer(context, return_tensors="pt", truncation=True, max_length=512)
+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():
-        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
-    }
+        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)
 
-def visualize_emotions():
-    emotions_df = pd.DataFrame([(e, d['percentage'], d['intensity']) for e, d in emotions.items()],
-                               columns=['Emotion', 'Percentage', 'Intensity'])
+    # Evolve emotions
+    evolve_emotions()
+
+    # Generate response
+    response = generate_response(input_text, predicted_emotion, conversation_history)
     
-    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()
+    # Feature transformations
+    feature_transformations()
+
+    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)
 
-    return 'emotional_state.png'
+    ax1.set_xlabel('Emotion')
+    ax1.set_ylabel('Percentage', color='b')
+    ax2.set_ylabel('Intensity', color='r')
 
-def interactive_interface(input_text):
+    plt.title('Emotion Distribution and Intensities')
+    plt.show()
+
+def clear_conversation_history():
     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, 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 by Sephfox",
-    description="Interact with an AI assistant created by Sephfox that responds based on its emotional state.",
-).launch()
+    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()