Update app.py

app.py

@@ -9,234 +9,277 @@ 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, MegatronLMHeadModel, MegatronTokenizer, pipeline
+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')
 
-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 Megatron-LM model for text generation
-        self.megatron_tokenizer = MegatronTokenizer.from_pretrained('nvidia/megatron-lm-330m')
-        self.megatron_model = MegatronLMHeadModel.from_pretrained('nvidia/megatron-lm-330m', 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.megatron_tokenizer.encode(full_prompt + self.megatron_tokenizer.eos_token, return_tensors='pt')
-
-        if torch.cuda.is_available():
-            input_ids = input_ids.cuda()
-            self.megatron_model = self.megatron_model.cuda()
-
-        output = self.megatron_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.megatron_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()
-
+# 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__":
-    assistant = EmotionalAIAssistant()
-    assistant.run_gradio_interface()
+    demo.launch()