Update app.py

app.py

@@ -41,23 +41,20 @@ 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")
+emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
+emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
 
-# Lazy loading for the fine-tuned language model
+# Lazy loading for the fine-tuned language model (DialoGPT)
 _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_model_name = "microsoft/DialoGPT-large"  # Replace with your fine-tuned language model name
-        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(finetuned_lm_model_name)
-        _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(finetuned_lm_model_name, device_map="auto", low_cpu_mem_usage=True)
+        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+        _finetuned_lm_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium", device_map="auto", low_cpu_mem_usage=True)
     return _finetuned_lm_tokenizer, _finetuned_lm_model
 
-
 # Enhanced Emotional States
 emotions = {
     'joy': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
@@ -65,7 +62,7 @@ emotions = {
     'sadness': {'percentage': 10, 'motivation': 'negative', 'intensity': 0},
     'grief': {'percentage': 10, 'motivation': 'negative', 'intensity': 0},
     'anger': {'percentage': 10, 'motivation': 'traumatic or strong', 'intensity': 0},
-    'calmness': {'percentage': 10, 'motivation': 'neutral', 'intensity': 0},
+    'calmness': {'percentage': 10, 'motivation': 'neutral', 'intensity': 0},'calmness': {'percentage': 10, 'motivation': 'neutral', 'intensity': 0},
     'determination': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
     'resentment': {'percentage': 10, 'motivation': 'negative', 'intensity': 0},
     'glory': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
@@ -84,32 +81,19 @@ emotions = {
 total_percentage = 200
 emotion_history_file = 'emotion_history.json'
 
-
 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):
-    """
-    Updates the emotional state based on the provided emotion, percentage, and intensity.
-
-    Args:
-        emotion (str): Name of the emotion to update.
-        percentage (float): Percentage change to apply to the emotion.
-        intensity (float): Intensity value to update for the emotion.
-    """
-
     emotions['ideal_state']['percentage'] -= percentage
     emotions[emotion]['percentage'] += percentage
     emotions[emotion]['intensity'] = intensity
@@ -118,48 +102,32 @@ def update_emotion(emotion, percentage, intensity):
     adjustment = total_percentage - total_current
     emotions['ideal_state']['percentage'] += adjustment
 
-
 def normalize_context(context):
-    """
-    Normalizes the context text by converting it to lowercase and removing whitespace.
-
-    Args:
-        context (str): The context text to normalize.
-
-    Returns:
-        str: The normalized context text.
-    """
-
     return context.lower().strip()
 
+def evaluate(individual):
+    emotion_values = individual[:len(emotions) - 1]
+    intensities = individual[-21:-1]
+    ideal_state = individual[-1]
+    
+    ideal_diff = abs(100 - ideal_state)
+    sum_non_ideal = sum(emotion_values)
+    intensity_range = max(intensities) - min(intensities)
+    
+    return ideal_diff, sum_non_ideal, intensity_range
 
-# Improved Genetic Algorithm for Emotion Evolution with clear function definition
 def evolve_emotions():
-    """
-    Evolves the emotional states using a genetic algorithm to find an optimal balance.
-
-    This function utilizes the DEAP library to implement a genetic algorithm. It aims to
-    find a combination of emotional states that minimizes the following criteria:
-
-    1. Difference between the ideal state (100%) and its actual percentage.
-    2. Sum of all non-ideal emotional percentages.
-    3. Range of emotional intensities.
-
-    The weights for these criteria can be adjusted in the `creator.create("FitnessMulti", ...)` line.
-    """
-
-    creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2))  # Weights for evaluation criteria
+    creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -0.5, -0.2))
     creator.create("Individual", list, fitness=creator.FitnessMulti)
 
     toolbox = base.Toolbox()
     toolbox.register("attr_float", random.uniform, 0, 20)
     toolbox.register("attr_intensity", random.uniform, 0, 10)
     toolbox.register("individual", tools.initCycle, creator.Individual,
-                     (toolbox.attr_float,) * (len(emotions) - 1) +  # Individual emotions
-                     (toolbox.attr_intensity,) * len(emotions) +  # Intensities
+                     (toolbox.attr_float,) * (len(emotions) - 1) +
+                     (toolbox.attr_intensity,) * len(emotions) +
                      (lambda: 100,), n=1)
-    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
-    toolbox.register("mate", tools.cxTwoPoint)
+   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)
@@ -179,153 +147,73 @@ def evolve_emotions():
 
     emotions['ideal_state']['percentage'] = ideal_state
 
-
 def predict_emotion(context):
-    """
-    Predicts the emotion from the provided context using a pre-trained BERT model.
-
-    Args:
-        context (str): The context text for emotion prediction.
-
-    Returns:
-        str: The predicted emotion.
-    """
-
     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]}
     emotion_pred = max(emotion_scores, key=emotion_scores.get)
     return emotion_pred
 
-
 def generate_text(prompt, emotion=None, max_length=100):
-    """
-    Generates text using a fine-tuned language model, optionally incorporating the specified emotion.
-
-    Args:
-        prompt (str): The starting prompt for text generation.
-        emotion (str, optional): The emotion to consider during generation. Defaults to None.
-        max_length (int, optional): The maximum length of the generated text. Defaults to 100.
-
-    Returns:
-        str: The generated text.
-    """
-
     finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model()
-    input_ids = finetuned_lm_tokenizer.encode(prompt, return_tensors='pt')
-    attention_mask = torch.ones(input_ids.shape, dtype=torch.long)
-
+    input_ids = finetuned_lm_tokenizer.encode(prompt + finetuned_lm_tokenizer.eos_token, return_tensors='pt')
+    
     if torch.cuda.is_available():
         input_ids = input_ids.cuda()
-        attention_mask = attention_mask.cuda()
         finetuned_lm_model = finetuned_lm_model.cuda()
 
+    attention_mask = torch.ones(input_ids.shape, dtype=torch.long, device=input_ids.device)
+
+    # Set up the emotion-specific generation parameters
     if emotion:
-        emotion_token = emotion_prediction_tokenizer.encode(emotion, add_special_tokens=False)
-        input_ids = torch.cat((input_ids, torch.tensor(emotion_token).unsqueeze(0)), dim=1)
+        # You can adjust these parameters based on the emotion
+        temperature = 0.7
+        top_k = 50
+        top_p = 0.9
+    else:
+        temperature = 1.0
+        top_k = 0
+        top_p = 1.0
 
-    outputs = finetuned_lm_model.generate(
-        input_ids=input_ids,
-        attention_mask=attention_mask,
+    # Generate the response
+    output = finetuned_lm_model.generate(
+        input_ids,
         max_length=max_length,
-        pad_token_id=finetuned_lm_tokenizer.eos_token_id,
         num_return_sequences=1,
-        temperature=0.7,
-        top_p=0.9,
-        do_sample=True
+        no_repeat_ngram_size=2,
+        do_sample=True,
+        temperature=temperature,
+        top_k=top_k,
+        top_p=top_p,
+        attention_mask=attention_mask
     )
 
-    return finetuned_lm_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-
-def optimize_ai_model(emotion_history):
-    """
-    Trains a Random Forest classifier to predict emotions based on historical data.
-
-    This function is optional and can be used to improve the accuracy of emotion prediction
-    over time by learning from past interactions.
-
-    Args:
-        emotion_history (list): A list of dictionaries containing context and emotion information.
-
-    Returns:
-        tuple: A tuple containing the trained classifier and its accuracy score (or None if insufficient data).
-    """
-
-    if len(emotion_history) < 2:
-        return None, None
-
-    contexts = [entry['context'] for entry in emotion_history]
-    emotions = [entry['emotion'] for entry in emotion_history]
-
-    encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
-    X = encoder.fit_transform(np.array(contexts).reshape(-1, 1))
-    y = np.array(pd.Categorical(emotions).codes)
-    clf = RandomForestClassifier(n_estimators=100)
-    clf.fit(X, y)
-
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
-    accuracy = clf.score(X_test, y_test)
-
-    return clf, accuracy
-
-
-def get_dominant_emotion():
-    """
-    Returns the emotion with the highest percentage.
-
-    Returns:
-        str: The emotion with the highest percentage.
-    """
-
-    dominant_emotion = max(emotions, key=lambda e: emotions[e]['percentage'])
-    return dominant_emotion
-
-
-def respond_to_user(context):
-    """
-    Responds to the user based on the provided context.
-
-    This function predicts the user's emotion from the context, generates a response that
-    considers the user's emotional state, and updates the internal emotional states.
-
-    Args:
-        context (str): The user's input context.
-
-    Returns:
-        str: The AI's response to the user.
-    """
-
-    predicted_emotion = predict_emotion(context)
-    dominant_emotion = get_dominant_emotion()
-
-    response = f"You seem to be feeling {predicted_emotion}. "
-
-    if predicted_emotion == dominant_emotion:
-        response += f"I understand that you're feeling strongly about {predicted_emotion} right now. "
-    else:
-        response += f"Is there anything I can do to help you with {predicted_emotion}? "
-
-    if dominant_emotion != 'ideal_state':
-        adjustment_percentage = min(emotions[dominant_emotion]['percentage'] / 2, 10)
-        update_emotion(dominant_emotion, -adjustment_percentage, 0)
-
-    emotion_history.append({'context': context, 'emotion': predicted_emotion})
-    save_historical_data(emotion_history)
-
-    # Train the emotion prediction classifier if enough data is available
-    trained_clf, accuracy = optimize_ai_model(emotion_history)
-    if trained_clf:
-        print(f"Emotion prediction model accuracy: {accuracy:.2f}")
-
-    generated_text = generate_text(prompt=response, emotion=dominant_emotion)
+    generated_text = finetuned_lm_tokenizer.decode(output[0], skip_special_tokens=True)
     return generated_text
 
-
-interface = gr.Interface(respond_to_user, inputs="textbox", outputs="textbox", title="AI Assistant with Evolving Emotions", description="Talk to an AI that adapts to your emotions.")
-interface.launch()
-
-# Clean up memory usage
-del _finetuned_lm_tokenizer
-del _finetuned_lm_model
-gc.collect()
+def respond_to_user(user_input, chat_history):
+    # Predict the emotion from the user input
+    emotion = predict_emotion(user_input)
+    
+    # Update the emotional state
+    update_emotion(emotion, 5, random.uniform(0, 10))
+    
+    # Generate a response considering the emotion
+    response = generate_text(user_input, emotion)
+    
+    # Update chat history
+    chat_history.append((user_input, response))
+    
+    return response, chat_history
+
+# Gradio interface
+iface = gr.Interface(
+    fn=respond_to_user,
+    inputs=["text", "state"],
+    outputs=["text", "state"],
+    title="Emotion-Aware Chatbot",
+    description="Chat with an AI that understands and responds to emotions.",
+)
+
+if __name__ == "__main__":
+    iface.launch()