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, GPTNeoForCausalLM, GPTNeoTokenizer, pipeline from deap import base, creator, tools, algorithms import gc warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download') class EmotionalAIAssistant: def __init__(self): # Initialize Example Emotions Dataset self.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' ] } self.df = pd.DataFrame(self.data) # Encoding the contexts using One-Hot Encoding (memory-efficient) self.encoder = OneHotEncoder(handle_unknown='ignore', sparse=True) self.contexts_encoded = self.encoder.fit_transform(self.df[['context']]) # Encoding emotions self.emotions_target = pd.Categorical(self.df['emotion']).codes self.emotion_classes = pd.Categorical(self.df['emotion']).categories # Load pre-trained BERT model for emotion prediction self.emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion") self.emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion", padding_side='left') # Load pre-trained GPT-Neo-2.7B model for text generation self.gpt_neo_tokenizer = GPTNeoTokenizer.from_pretrained('EleutherAI/gpt-neo-2.7B') self.gpt_neo_model = GPTNeoForCausalLM.from_pretrained('EleutherAI/gpt-neo-2.7B', device_map='auto') # Enhanced Emotional States self.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}, } self.total_percentage = 200 self.emotion_history_file = 'emotion_history.json' self.emotion_history = self.load_historical_data() def load_historical_data(self, file_path=None): if file_path is None: file_path = self.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(self, historical_data, file_path=None): if file_path is None: file_path = self.emotion_history_file with open(file_path, 'w') as file: json.dump(historical_data, file) def update_emotion(self, emotion, percentage, intensity): self.emotions['ideal_state']['percentage'] -= percentage self.emotions[emotion]['percentage'] += percentage self.emotions[emotion]['intensity'] = intensity # Introduce some randomness in emotional evolution for e in self.emotions: if e != emotion and e != 'ideal_state': change = random.uniform(-2, 2) self.emotions[e]['percentage'] = max(0, self.emotions[e]['percentage'] + change) total_current = sum(e['percentage'] for e in self.emotions.values()) adjustment = self.total_percentage - total_current self.emotions['ideal_state']['percentage'] += adjustment def normalize_context(self, context): return context.lower().strip() def evaluate(self, individual): emotion_values = individual[:len(self.emotions) - 1] intensities = individual[-len(self.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(self): 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(self.emotions) + (toolbox.attr_intensity,) * len(self.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", self.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(self.emotions)] intensities = best_individual[len(self.emotions):-1] ideal_state = best_individual[-1] for i, emotion in enumerate(self.emotions): if emotion != 'ideal_state': self.emotions[emotion]['percentage'] = emotion_values[i] self.emotions[emotion]['intensity'] = intensities[i] self.emotions['ideal_state']['percentage'] = ideal_state def generate_text(self, prompt, chat_history, emotion=None, max_length=300): 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, engaging, and insightful:\n\n" ) for turn in chat_history[-20:]: # Consider last 20 turns for context full_prompt += f"Human: {turn[0]}\nAdam: {turn[1]}\n" full_prompt += f"Human: {prompt}\nAdam:" input_ids = self.gpt_neo_tokenizer.encode(full_prompt + self.gpt_neo_tokenizer.eos_token, return_tensors='pt') if torch.cuda.is_available(): input_ids = input_ids.cuda() self.gpt_neo_model = self.gpt_neo_model.cuda() output = self.gpt_neo_model.generate( input_ids, max_length=len(input_ids[0]) + max_length, num_return_sequences=1, no_repeat_ngram_size=3, do_sample=True, top_k=50, top_p=0.95, num_beams=2, early_stopping=True, ) generated_text = self.gpt_neo_tokenizer.decode(output[0], skip_special_tokens=True) return generated_text def predict_emotion(self, context): emotion_prediction_pipeline = pipeline('text-classification', model=self.emotion_prediction_model, tokenizer=self.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 respond_to_user(self, user_message, chat_history): predicted_emotion = self.predict_emotion(user_message) generated_text = self.generate_text(user_message, chat_history, emotion=predicted_emotion) updated_history = chat_history + [(user_message, generated_text)] emotion_summary = {emotion: data['percentage'] for emotion, data in self.emotions.items()} return generated_text, updated_history, emotion_summary def run_gradio_interface(self): def user(user_message, history): response, updated_history, emotion_summary = self.respond_to_user(user_message, history) self.evolve_emotions() return response, updated_history, emotion_summary iface = gr.Interface( fn=user, inputs=[ gr.Textbox(label="User Message"), gr.State(value=[], label="Chat History") ], outputs=[ gr.Textbox(label="AI Response"), gr.State(value=[], label="Updated Chat History"), gr.JSON(label="Emotion Summary") ], title="AdamZero", description="Chat with an AI assistant that responds based on its emotional state.", ) iface.launch() if __name__ == "__main__": assistant = EmotionalAIAssistant() assistant.run_gradio_interface()