Update app.py

app.py

@@ -9,7 +9,7 @@ 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 BloomForCausalLM, BloomTokenizerFast
+from transformers import GPTJForCausalLM, GPT2TokenizerFast
 import torch
 import torch.multiprocessing as mp
 
@@ -195,87 +195,28 @@ def get_emotional_response(context):
             update_emotion('boredom', 20)
         elif predicted_emotion == 'envy':
             update_emotion('envy', 20)
-        else:
-            update_emotion('calmness', 20)
-
-    # Record the current emotional state in history
-    emotion_state = {emotion: data['percentage'] for emotion, data in emotions.items()}
-    emotion_history.append(emotion_state)
-
-    # Save the history to file
-    save_historical_data(emotion_history)
-
-    # Print the current emotional state
-    response = ""
-    for emotion, data in emotions.items():
-        response += f"{emotion.capitalize()}: {data['percentage']:.2f}% ({data['motivation']} motivation)\n"
     
-    return response
-
-# Function to handle idle state using genetic algorithm
-def handle_idle_state():
+    # Evolve emotions
     evolve_emotions()
-    response = "Emotions evolved\n"
-    for emotion, data in emotions.items():
-        response += f"{emotion.capitalize()}: {data['percentage']:.2f}% ({data['motivation']} motivation)\n"
-    return response
 
-# S.O.U.L. (Self-Organizing Universal Learning) Function
-class SOUL:
-    def __init__(self, model_name='bigscience/bloom-1b1'):
-        self.tokenizer = BloomTokenizerFast.from_pretrained(model_name)
-        self.model = BloomForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16)
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.model.to(self.device)
-
-    def generate_text(self, prompt, max_length=100):
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
-        
-        # Generate
-        with torch.no_grad():
-            generate_ids = self.model.generate(
-                inputs.input_ids, 
-                max_length=max_length, 
-                num_return_sequences=1, 
-                no_repeat_ngram_size=2,
-                do_sample=True,
-                top_k=50,
-                top_p=0.95,
-                temperature=0.7
-            )
-        
-        return self.tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
-
-    def bridge_ai(self, prompt):
-        # Generate the response using BLOOM
-        bloom_response = self.generate_text(prompt)
+    # Save the updated emotion history
+    emotion_history.append(emotions.copy())
+    save_historical_data(emotion_history)
 
-        # Get the emotional response
-        emotional_response = get_emotional_response(bloom_response)
-        
-        return bloom_response, emotional_response
+    return f"Emotion: {predicted_emotion}, Emotion Details: {emotions[predicted_emotion]}"
 
-# Example usage of S.O.U.L. function
-soul = SOUL()
+# Initialize the pre-trained language model
+model_name = 'EleutherAI/gpt-j-6B'
+tokenizer = GPT2TokenizerFast.from_pretrained(model_name)
+lm_model = GPTJForCausalLM.from_pretrained(model_name)
 
-def interact_with_soul(user_input):
-    bloom_response, emotional_response = soul.bridge_ai(user_input)
-    return bloom_response, emotional_response
+# Multiprocessing context setting (ensure it's set only once)
+if __name__ == '__main__':
+    if mp.get_start_method(allow_none=True) != 'spawn':
+        mp.set_start_method('spawn')
 
-# Function to handle Gradio interface using multiprocessing
-def launch_gradio():
-    iface = gr.Interface(
-        fn=interact_with_soul,
-        inputs="text",
-        outputs=["text", "text"],
-        title="S.O.U.L AI",
-        description="Enter a prompt to interact with the S.O.U.L AI, which will generate a response and provide an emotional analysis."
-    )
-    iface.launch()
+    # Example usage
+    context_input = "I am feeling very joyful today"
+    emotional_response = get_emotional_response(context_input)
+    print(emotional_response)
 
-# Use multiprocessing to utilize all CPU cores
-if __name__ == '__main__':
-    mp.set_start_method('spawn')
-    p = mp.Process(target=launch_gradio)
-    p.start()
-    p.join()