Update app.py

app.py

@@ -9,276 +9,233 @@ 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 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')
 
-# 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", padding_side='left')
-
-# 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, padding_side='left')
-        _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) +
-                     (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)]
-    intensities = best_individual[len(emotions):-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 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)
+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__":
-    demo.launch()
+    assistant = EmotionalAIAssistant()
+    assistant.run_gradio_interface()