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.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

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

# Initialize Example Dataset (For Emotion Prediction)
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")

# Load pre-trained LLM model and tokenizer for response generation
response_model_name = "microsoft/DialoGPT-medium"
response_tokenizer = AutoTokenizer.from_pretrained(response_model_name)
response_model = AutoModelForCausalLM.from_pretrained(response_model_name)

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

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) - 1) +
                     (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) - 1:-1]
    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 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 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).item()
    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')

    # Ensure pad_token_id is a tensor
    pad_token_id = torch.tensor(tokenizer.pad_token_id)

    outputs = model.generate(inputs, max_length=500, num_return_sequences=1, pad_token_id=pad_token_id.item(), eos_token_id=tokenizer.eos_token_id)
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)

    # Ensure the response does not repeat the input
    if context in response:
        response = response.replace(context, '').strip()
    
    return response

def handle_conversation(user_input):
    user_input = normalize_context(user_input)
    predicted_emotion = predict_emotion(user_input)
    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

with gr.Blocks() as demo:
    user_input = gr.Textbox(label="User Input")
    response = gr.Textbox(label="Bot Response")
    submit = gr.Button("Submit")
    submit.click(update_ui, inputs=[user_input], outputs=[response])

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