Update app.py

app.py

@@ -52,7 +52,7 @@ def get_finetuned_lm_model():
     global _finetuned_lm_tokenizer, _finetuned_lm_model
     if _finetuned_lm_tokenizer is None or _finetuned_lm_model is None:
         model_name = "microsoft/DialoGPT-medium"
-        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(model_name)
+        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side='left')
         _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
@@ -119,7 +119,7 @@ def normalize_context(context):
 
 def evaluate(individual):
     emotion_values = individual[:len(emotions) - 1]
-    intensities = individual[-len(emotions):]
+    intensities = individual[len(emotions) - 1:-1]
     ideal_state = individual[-1]
     
     ideal_diff = abs(100 - ideal_state)
@@ -137,7 +137,7 @@ def evolve_emotions():
     toolbox.register("attr_intensity", random.uniform, 0, 10)
     toolbox.register("individual", tools.initCycle, creator.Individual,
                      (toolbox.attr_float,) * (len(emotions) - 1) +
-                     (toolbox.attr_intensity,) * len(emotions) +
+                     (toolbox.attr_intensity,) * (len(emotions) - 1) +
                      (lambda: 100,), n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
     toolbox.register("mate", tools.cxTwoPoint)
@@ -151,7 +151,7 @@ def evolve_emotions():
 
     best_individual = tools.selBest(population, k=1)[0]
     emotion_values = best_individual[:len(emotions) - 1]
-    intensities = best_individual[-len(emotions):]
+    intensities = best_individual[len(emotions) - 1:-1]
     ideal_state = best_individual[-1]
 
     for i, emotion in enumerate(emotions):
@@ -161,125 +161,57 @@ def evolve_emotions():
 
     emotions['ideal_state']['percentage'] = ideal_state
 
-def predict_emotion(context):
-    emotion_prediction_pipeline = pipeline('text-classification', model=emotion_prediction_model, tokenizer=emotion_prediction_tokenizer, top_k=None)
-    predictions = emotion_prediction_pipeline(context)
-    emotion_scores = {prediction['label']: prediction['score'] for prediction in predictions[0]}
-    predicted_emotion = max(emotion_scores, key=emotion_scores.get)
-    
-    # Map the predicted emotion to our emotion categories
-    emotion_mapping = {
-        'sadness': 'sadness',
-        'joy': 'joy',
-        'love': 'pleasure',
-        'anger': 'anger',
-        'fear': 'fear',
-        'surprise': 'surprise'
-    }
-    
-    return emotion_mapping.get(predicted_emotion, 'neutral')
-
-def generate_text(prompt, chat_history, emotion=None, max_length=150):
-    finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model()
-    
-    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[-7:]:  # 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.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()
-
-    output = finetuned_lm_model.generate(
-        input_ids,
-        max_length=len(input_ids[0]) + max_length,
-        num_return_sequences=1,
-        no_repeat_ngram_size=2,
-        do_sample=True,
-        temperature=0.8,  # Slightly increased for more creative responses
-        top_k=50,
-        top_p=0.95,
-        pad_token_id=finetuned_lm_tokenizer.eos_token_id
-    )
-
-    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):
-    global emotion_history
-    emotion_history.append({
+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)
+    if len(emotion_history) > 100:
+        emotion_history.pop(0)
     save_historical_data(emotion_history)
 
-def get_dominant_emotion():
-    return max(emotions, key=lambda x: emotions[x]['percentage'] if x != 'ideal_state' else 0)
-
-def get_emotion_summary():
-    summary = []
-    for emotion, data in emotions.items():
-        if emotion != 'ideal_state':
-            summary.append(f"{emotion.capitalize()}: {data['percentage']:.1f}% (Intensity: {data['intensity']:.1f})")
-    return "\n".join(summary)
-
-def reset_emotions():
-    global emotions
-    for emotion in emotions:
-        if emotion != 'ideal_state':
-            emotions[emotion]['percentage'] = 10
-            emotions[emotion]['intensity'] = 0
-    emotions['ideal_state']['percentage'] = 100
-    return get_emotion_summary()
-
-def respond_to_user(user_input, chat_history):
+def predict_emotion(context):
+    tokens = emotion_prediction_tokenizer(context, return_tensors='pt', padding=True, truncation=True)
+    outputs = emotion_prediction_model(**tokens)
+    logits = outputs.logits
+    predicted_class = torch.argmax(logits, dim=1)
+    predicted_emotion = emotion_classes[predicted_class]
+
+    # Get percentage and intensity based on context
+    percentage = np.random.uniform(5, 20)
+    intensity = np.random.uniform(1, 10)
+
+    update_emotion(predicted_emotion, percentage, intensity)
+    update_emotion_history(predicted_emotion, percentage, intensity, context)
+
+    return predicted_emotion
+
+def generate_response(context):
+    tokenizer, model = get_finetuned_lm_model()
+    inputs = tokenizer.encode(context, return_tensors='pt')
+    outputs = model.generate(inputs, max_length=500, num_return_sequences=1, pad_token_id=tokenizer.eos_token)
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def handle_conversation(user_input):
+    user_input = normalize_context(user_input)
     predicted_emotion = predict_emotion(user_input)
-    
-    if predicted_emotion not in emotions:
-        predicted_emotion = 'neutral'
-    
-    update_emotion(predicted_emotion, 5, random.uniform(0, 10))
-    
-    dominant_emotion = get_dominant_emotion()
-    
-    response = generate_text(user_input, chat_history, dominant_emotion)
-    
-    update_emotion_history(predicted_emotion, emotions[predicted_emotion]['intensity'])
-    
-    chat_history.append((user_input, response))
-    
-    if len(chat_history) % 5 == 0:
-        evolve_emotions()
-    
-    return response, chat_history, get_emotion_summary()
+    bot_response = generate_response(user_input)
+    return f"Emotion: {predicted_emotion}, Response: {bot_response}"
+
+def update_ui(user_input):
+    response = handle_conversation(user_input)
+    return response
 
-# Gradio interface
 with gr.Blocks() as demo:
-    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="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)
-        return "", updated_history, emotion_summary
-    
-    msg.submit(user, [msg, chatbot], [msg, chatbot, emotion_state])
-    clear.click(lambda: None, None, chatbot, queue=False)
-    reset_button.click(reset_emotions, None, emotion_state, queue=False)
+    user_input = gr.Textbox(label="User Input")
+    response = gr.Textbox(label="Bot Response")
+    submit = gr.Button("Submit")
+    submit.click(update_ui, user_input, response)
 
 if __name__ == "__main__":
     demo.launch()