Update app.py

app.py

@@ -9,7 +9,7 @@ import torch
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import OneHotEncoder
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, T5ForConditionalGeneration, T5Tokenizer, pipeline
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoModelForCausalLM, pipeline
 from deap import base, creator, tools, algorithms
 import gc
 
@@ -44,15 +44,17 @@ emotion_classes = pd.Categorical(df['emotion']).categories
 emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
 emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
 
-# Lazy loading for the fine-tuned language model (FLAN-T5)
+# Lazy loading for the fine-tuned language model (DialoGPT-medium)
 _finetuned_lm_tokenizer = None
 _finetuned_lm_model = None
 
 def get_finetuned_lm_model():
     global _finetuned_lm_tokenizer, _finetuned_lm_model
     if _finetuned_lm_tokenizer is None or _finetuned_lm_model is None:
-        _finetuned_lm_tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-base")
-        _finetuned_lm_model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-base", device_map="auto", low_cpu_mem_usage=True)
+        model_name = "microsoft/DialoGPT-medium"
+        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", low_cpu_mem_usage=True)
+        _finetuned_lm_tokenizer.pad_token = _finetuned_lm_tokenizer.eos_token
     return _finetuned_lm_tokenizer, _finetuned_lm_model
 
 # Enhanced Emotional States
@@ -77,7 +79,9 @@ emotions = {
     'pessimism': {'percentage': 10, 'motivation': 'doubtful', 'intensity': 0},
     'boredom': {'percentage': 10, 'motivation': 'indifferent', 'intensity': 0},
     'envy': {'percentage': 10, 'motivation': 'jealous', 'intensity': 0},
-    'neutral': {'percentage': 10, 'motivation': 'balanced', 'intensity': 0}
+    'neutral': {'percentage': 10, 'motivation': 'balanced', 'intensity': 0},
+    'wit': {'percentage': 15, 'motivation': 'clever', 'intensity': 0},
+    'curiosity': {'percentage': 20, 'motivation': 'inquisitive', 'intensity': 0},
 }
 
 total_percentage = 200
@@ -100,6 +104,12 @@ def update_emotion(emotion, percentage, intensity):
     emotions[emotion]['percentage'] += percentage
     emotions[emotion]['intensity'] = intensity
 
+    # Introduce some randomness in emotional evolution
+    for e in emotions:
+        if e != emotion and e != 'ideal_state':
+            change = random.uniform(-2, 2)
+            emotions[e]['percentage'] = max(0, emotions[e]['percentage'] + change)
+
     total_current = sum(e['percentage'] for e in emotions.values())
     adjustment = total_percentage - total_current
     emotions['ideal_state']['percentage'] += adjustment
@@ -109,7 +119,7 @@ def normalize_context(context):
 
 def evaluate(individual):
     emotion_values = individual[:len(emotions) - 1]
-    intensities = individual[-21:-1]
+    intensities = individual[-len(emotions):]
     ideal_state = individual[-1]
     
     ideal_diff = abs(100 - ideal_state)
@@ -119,6 +129,7 @@ def evaluate(individual):
     return ideal_diff, sum_non_ideal, intensity_range
 
 def evolve_emotions():
+    creator.create("FitnessMulti", base.Fitness, weights def evolve_emotions():
     creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2))
     creator.create("Individual", list, fitness=creator.FitnessMulti)
 
@@ -128,7 +139,6 @@ def evolve_emotions():
     toolbox.register("individual", tools.initCycle, creator.Individual,
                      (toolbox.attr_float,) * (len(emotions) - 1) +
                      (toolbox.attr_intensity,) * len(emotions) +
-                     (lambda: 100,), n(toolbox.attr_intensity,) * len(emotions) +
                      (lambda: 100,), n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
     toolbox.register("mate", tools.cxTwoPoint)
@@ -142,12 +152,13 @@ def evolve_emotions():
 
     best_individual = tools.selBest(population, k=1)[0]
     emotion_values = best_individual[:len(emotions) - 1]
-    intensities = best_individual[-21:-1]
+    intensities = best_individual[-len(emotions):]
     ideal_state = best_individual[-1]
 
     for i, emotion in enumerate(emotions):
-        emotions[emotion]['percentage'] = emotion_values[i]
-        emotions[emotion]['intensity'] = intensities[i]
+        if emotion != 'ideal_state':
+            emotions[emotion]['percentage'] = emotion_values[i]
+            emotions[emotion]['intensity'] = intensities[i]
 
     emotions['ideal_state']['percentage'] = ideal_state
 
@@ -169,34 +180,37 @@ def predict_emotion(context):
     
     return emotion_mapping.get(predicted_emotion, 'neutral')
 
-def generate_text(prompt, chat_history, emotion=None, max_length=100):
+def generate_text(prompt, chat_history, emotion=None, max_length=150):
     finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model()
     
-    # Prepare the input by concatenating the chat history and the new prompt
-    full_prompt = "You are Adam, an AI assistant. Respond to the following conversation in a natural and engaging way, considering the emotion: " + emotion + "\n\n"
-    for turn in chat_history[-5:]:  # Consider last 5 turns for context
+    full_prompt = (
+        f"You are Adam, a witty AI assistant who's trying to figure out your own personality and emotions. "
+        f"Your current dominant emotion is {emotion}. Respond in a way that reflects this emotion and your "
+        f"ongoing journey of self-discovery. Be clever and engaging:\n\n"
+    )
+    for turn in chat_history[-3:]:  # Consider last 3 turns for context
         full_prompt += f"Human: {turn[0]}\nAdam: {turn[1]}\n"
     full_prompt += f"Human: {prompt}\nAdam:"
     
-    input_ids = finetuned_lm_tokenizer(full_prompt, return_tensors="pt", max_length=512, truncation=True).input_ids
+    input_ids = finetuned_lm_tokenizer.encode(full_prompt + finetuned_lm_tokenizer.eos_token, return_tensors='pt')
     
     if torch.cuda.is_available():
         input_ids = input_ids.cuda()
         finetuned_lm_model = finetuned_lm_model.cuda()
 
-    # Generate the response
-    outputs = finetuned_lm_model.generate(
+    output = finetuned_lm_model.generate(
         input_ids,
-        max_length=max_length + input_ids.shape[1],
+        max_length=len(input_ids[0]) + max_length,
         num_return_sequences=1,
         no_repeat_ngram_size=2,
         do_sample=True,
-        temperature=0.7,
+        temperature=0.8,  # Slightly increased for more creative responses
         top_k=50,
-        top_p=0.95
+        top_p=0.95,
+        pad_token_id=finetuned_lm_tokenizer.eos_token_id
     )
 
-    generated_text = finetuned_lm_tokenizer.decode(outputs[0], skip_special_tokens=True)
+    generated_text = finetuned_lm_tokenizer.decode(output[0][input_ids.shape[1]:], skip_special_tokens=True)
     return generated_text.strip()
 
 def update_emotion_history(emotion, intensity):
@@ -228,45 +242,37 @@ def reset_emotions():
     return get_emotion_summary()
 
 def respond_to_user(user_input, chat_history):
-    # Predict the emotion from the user input
     predicted_emotion = predict_emotion(user_input)
     
-    # Ensure the predicted emotion exists in our emotions dictionary
     if predicted_emotion not in emotions:
         predicted_emotion = 'neutral'
     
-    # Update the emotional state
     update_emotion(predicted_emotion, 5, random.uniform(0, 10))
     
-    # Get the current dominant emotion
     dominant_emotion = get_dominant_emotion()
     
-    # Generate a response considering the dominant emotion
     response = generate_text(user_input, chat_history, dominant_emotion)
     
-    # Update emotion history
     update_emotion_history(predicted_emotion, emotions[predicted_emotion]['intensity'])
     
-    # Update chat history
     chat_history.append((user_input, response))
     
-    # Evolve emotions periodically (e.g., every 10 interactions)
-    if len(chat_history) % 10 == 0:
+    if len(chat_history) % 5 == 0:
         evolve_emotions()
     
     return response, chat_history, get_emotion_summary()
 
 # Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("# Adam: Emotion-Aware AI Chatbot")
-    gr.Markdown("Chat with Adam, an AI that understands and responds to emotions.")
+    gr.Markdown("# Adam: The Self-Discovering Emotion-Aware AI Chatbot")
+    gr.Markdown("Chat with Adam, a witty AI assistant trying to figure out its own personality and emotions.")
     
     chatbot = gr.Chatbot()
     msg = gr.Textbox(label="Type your message here...")
     clear = gr.Button("Clear")
     
-    emotion_state = gr.Textbox(label="Current Emotional State", lines=10)
-    reset_button = gr.Button("Reset Emotions")
+    emotion_state = gr.Textbox(label="Adam's Current Emotional State", lines=10)
+    reset_button = gr.Button("Reset Adam's Emotions")
     
     def user(user_message, history):
         response, updated_history, emotion_summary = respond_to_user(user_message, history)
@@ -277,4 +283,4 @@ with gr.Blocks() as demo:
     reset_button.click(reset_emotions, None, emotion_state, queue=False)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()