app.py

import warnings
import numpy as np
import pandas as pd
import os
import json
import random
import gradio as gr
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, IterableDataset
from sklearn.ensemble import IsolationForest, RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.neural_network import MLPClassifier
from deap import base, creator, tools, algorithms
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, AutoModelForSequenceClassification
import gc
import multiprocessing as mp
from joblib import Parallel, delayed

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
_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)
    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}
}
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

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

# Memory-efficient genetic algorithm for emotion evolution
def evolve_emotions():
    def evaluate(individual):
        ideal_state = individual[-1]
        other_emotions = individual[:-1]
        intensities = individual[-21:-1]
        return (abs(ideal_state - 100), 
                sum(other_emotions), 
                max(intensities) - min(intensities))

    creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0))
    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[-21:-1]
    ideal_state = best_individual[-1]

    for i, emotion in enumerate(emotions):
        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, return_all_scores=True)
    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):
    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)
    
    if torch.cuda.is_available():
        input_ids = input_ids.cuda()
        attention_mask = attention_mask.cuda()
        finetuned_lm_model = finetuned_lm_model.cuda()

    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)

    outputs = finetuned_lm_model.generate(
        input_ids=input_ids,
        attention_mask=attention_mask,
        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
    )

    return finetuned_lm_tokenizer.decode(outputs[0], skip_special_tokens=True)

def optimize_ai_model(emotion_history):
    if not emotion_history:
        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)

    if len(X) == 0 or len(y) == 0:
        return None, None

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    classifier = RandomForestClassifier(n_estimators=100, random_state=42)
    classifier.fit(X_train, y_train)

    score = classifier.score(X_test, y_test)
    return classifier, score

def respond(context, previous_responses, previous_emotions):
    normalized_context = normalize_context(context)
    emotion_pred = predict_emotion(normalized_context)

    emotion_history.append({
        'context': normalized_context,
        'emotion': emotion_pred
    })
    save_historical_data(emotion_history)

    emotion_model, score = optimize_ai_model(emotion_history)

    evolve_emotions()

    response_prompt = f"{normalized_context}\n\n{previous_responses}\n\n{emotion_pred}"
    generated_response = generate_text(response_prompt, emotion=emotion_pred)

    return generated_response, emotion_pred

# GUI with Gradio
with gr.Blocks() as demo:
    context_input = gr.Textbox(label="Context")
    response_output = gr.Textbox(label="Generated Response")
    emotion_output = gr.Textbox(label="Detected Emotion")
    
    conversation_history = gr.State([])
    emotion_history_state = gr.State([])
    
    def respond_wrapper(context, conversation_history, emotion_history_state):
        response, emotion = respond(context, conversation_history, emotion_history_state)
        conversation_history.append(response)
        emotion_history_state.append(emotion)
        return response, emotion, conversation_history, emotion_history_state

    submit_button = gr.Button("Submit")
    submit_button.click(respond_wrapper, [context_input, conversation_history, emotion_history_state], [response_output, emotion_output, conversation_history, emotion_history_state])

    demo.launch(share=True)