app.py

import warnings
import numpy as np
import pandas as pd
import os
import json
import random
import gradio as gr
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, AutoModelForCausalLM, pipeline
from deap import base, creator, tools, algorithms
import gc

warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')

# Initialize Example Emotions Dataset
data = {
    'context': [
        'I am happy', 'I am sad', 'I am angry', 'I am excited', 'I am calm',
        'I am feeling joyful', 'I am grieving', 'I am feeling peaceful', 'I am frustrated',
        'I am determined', 'I feel resentment', 'I am feeling glorious', 'I am motivated',
        'I am surprised', 'I am fearful', 'I am trusting', 'I feel disgust', 'I am optimistic',
        'I am pessimistic', 'I feel bored', 'I am envious'
    ],
    'emotion': [
        'joy', 'sadness', 'anger', 'joy', 'calmness', 'joy', 'grief', 'calmness', 'anger',
        'determination', 'resentment', 'glory', 'motivation', 'surprise', 'fear', 'trust',
        'disgust', 'optimism', 'pessimism', 'boredom', 'envy'
    ]
}
df = pd.DataFrame(data)

# Encoding the contexts using One-Hot Encoding (memory-efficient)
encoder = OneHotEncoder(handle_unknown='ignore', sparse=True)
contexts_encoded = encoder.fit_transform(df[['context']])

# Encoding emotions
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")

# 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:
        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
emotions = {
    'joy': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
    'pleasure': {'percentage': 10, 'motivation': 'selfish', 'intensity': 0},
    '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},
    'determination': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
    'resentment': {'percentage': 10, 'motivation': 'negative', 'intensity': 0},
    'glory': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
    'motivation': {'percentage': 10, 'motivation': 'positive', 'intensity': 0},
    'ideal_state': {'percentage': 100, 'motivation': 'balanced', 'intensity': 0},
    'fear': {'percentage': 10, 'motivation': 'defensive', 'intensity': 0},
    'surprise': {'percentage': 10, 'motivation': 'unexpected', 'intensity': 0},
    'anticipation': {'percentage': 10, 'motivation': 'predictive', 'intensity': 0},
    'trust': {'percentage': 10, 'motivation': 'reliable', 'intensity': 0},
    'disgust': {'percentage': 10, 'motivation': 'repulsive', 'intensity': 0},
    'optimism': {'percentage': 10, 'motivation': 'hopeful', 'intensity': 0},
    '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},
    'wit': {'percentage': 15, 'motivation': 'clever', 'intensity': 0},
    'curiosity': {'percentage': 20, 'motivation': 'inquisitive', 'intensity': 0},
}

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):
    emotions['ideal_state']['percentage'] -= percentage
    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

def normalize_context(context):
    return context.lower().strip()

def evaluate(individual):
    emotion_values = individual[:len(emotions) - 1]
    intensities = individual[-len(emotions):]
    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

def evolve_emotions():
    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) +
                     (toolbox.attr_intensity,) * len(emotions) +
                     (lambda: 100,), n=1)
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
    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)

    population = toolbox.population(n=100)
    algorithms.eaMuPlusLambda(population, toolbox, mu=50, lambda_=100, cxpb=0.7, mutpb=0.2, ngen=100,
                               stats=None, halloffame=None, verbose=False)

    best_individual = tools.selBest(population, k=1)[0]
    emotion_values = best_individual[:len(emotions) - 1]
    intensities = best_individual[-len(emotions):]
    ideal_state = best_individual[-1]

    for i, emotion in enumerate(emotions):
        if emotion != 'ideal_state':
            emotions[emotion]['percentage'] = emotion_values[i]
            emotions[emotion]['intensity'] = intensities[i]

    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[-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.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({
        'emotion': emotion,
        'intensity': intensity,
        'timestamp': pd.Timestamp.now().isoformat()
    })
    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):
    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()

# 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)

if __name__ == "__main__":
    demo.launch()