Update app.py

app.py

@@ -155,68 +155,94 @@ def evolve_emotions():
 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 = {emotion['label']: emotion['score'] for emotion in predictions}
-    emotion_pred = emotion_classes[np.argmax([emotion_scores.get(label, 0) for label in emotion_classes])]
+    emotion_scores = {prediction['label']: prediction['score'] for prediction in predictions}
+    emotion_pred = max(emotion_scores, key=emotion_scores.get)
     return emotion_pred
 
-def generate_text(prompt, model, tokenizer, max_length=50):
-    input_ids = tokenizer.encode(prompt, return_tensors='pt')
-    output = model.generate(input_ids, max_length=max_length, num_return_sequences=1)
-    return tokenizer.decode(output[0], skip_special_tokens=True)
+def generate_text(prompt, max_length=100, emotion=None):
+    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):
-    X = [normalize_context(e['context']) for e in emotion_history]
-    y = [e['emotion'] for e in emotion_history]
-    
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    if not emotion_history:
+        return None, None
 
-    rf = RandomForestClassifier(n_estimators=100, random_state=42)
-    rf.fit(X_train, y_train)
-    score = rf.score(X_test, y_test)
-    return rf, score
+    contexts = [entry['context'] for entry in emotion_history]
+    emotions = [entry['emotion'] for entry in emotion_history]
 
-def ai_response(input_text, emotion_model):
-    emotion_pred = predict_emotion(input_text)
-    context_emotion = {'context': input_text, 'emotion': emotion_pred}
-    emotion_history.append(context_emotion)
-    save_historical_data(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)
 
-    percentage_change = random.randint(1, 10)
-    intensity_change = random.randint(1, 10)
-    update_emotion(emotion_pred, percentage_change, intensity_change)
+    if len(X) == 0 or len(y) == 0:
+        return None, None
 
-    evolve_emotions()
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
     
-    finetuned_tokenizer, finetuned_model = get_finetuned_lm_model()
-    response_text = generate_text(input_text, finetuned_model, finetuned_tokenizer)
+    classifier = RandomForestClassifier(n_estimators=100, random_state=42)
+    classifier.fit(X_train, y_train)
 
-    return response_text
+    score = classifier.score(X_test, y_test)
+    return classifier, score
 
-def run_genetic_algorithm_parallel():
-    num_cores = mp.cpu_count()
-    results = Parallel(n_jobs=num_cores)(delayed(evolve_emotions)() for _ in range(3))
+def respond(context, previous_responses, previous_emotions):
+    normalized_context = normalize_context(context)
+    emotion_pred = predict_emotion(normalized_context)
 
-def clear_emotion_history():
-    global emotion_history
-    emotion_history = []
+    emotion_history.append({
+        'context': normalized_context,
+        'emotion': emotion_pred
+    })
     save_historical_data(emotion_history)
 
-# Gradio Interface
-def respond(input_text):
     emotion_model, score = optimize_ai_model(emotion_history)
-    response = ai_response(input_text, emotion_model)
-    return response, score
 
-with gr.Blocks() as app:
-    gr.Markdown("# Advanced AI Model")
-    input_text = gr.Textbox(label="Input Text")
-    response_text = gr.Textbox(label="Response Text", interactive=False)
-    model_score = gr.Number(label="Model Accuracy", interactive=False)
+    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
 
-    respond_button = gr.Button("Respond")
-    respond_button.click(fn=respond, inputs=[input_text], outputs=[response_text, model_score])
+# 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
 
-    clear_button = gr.Button("Clear Emotion History")
-    clear_button.click(fn=clear_emotion_history, inputs=[], outputs=[])
+    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])
 
-app.launch()
+    demo.launch(share=True)