Update app.py

app.py

@@ -42,7 +42,7 @@ emotion_classes = pd.Categorical(df['emotion']).categories
 emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
 emotion_prediction_tokenizer = AutoTokenizer.from_pretrained("bhadresh-savani/distilbert-base-uncased-emotion")
 
-# Load pre-trained LLM model and tokenizer for response generation
+# Load pre-trained LLM model and tokenizer for response generation with increased context window
 response_model_name = "microsoft/DialoGPT-medium"
 response_tokenizer = AutoTokenizer.from_pretrained(response_model_name)
 response_model = AutoModelForCausalLM.from_pretrained(response_model_name)
@@ -163,57 +163,54 @@ def update_emotion_history(emotion, percentage, intensity, context):
         'timestamp': pd.Timestamp.now().isoformat()
     }
     emotion_history.append(entry)
-    if len(emotion_history) > 100:
-        emotion_history.pop(0)
     save_historical_data(emotion_history)
 
-def predict_emotion(context):
-    tokens = emotion_prediction_tokenizer(context, return_tensors='pt', padding=True, truncation=True)
-    outputs = emotion_prediction_model(**tokens)
-    logits = outputs.logits
-    predicted_class = torch.argmax(logits, dim=1).item()
-    predicted_emotion = emotion_classes[predicted_class]
+# Adding 443 features
+additional_features = {}
+for i in range(443):
+    additional_features[f'feature_{i+1}'] = 0
 
-    # Get percentage and intensity based on context
-    percentage = np.random.uniform(5, 20)
-    intensity = np.random.uniform(1, 10)
+def feature_transformations():
+    global additional_features
+    for feature in additional_features:
+        additional_features[feature] += random.uniform(-1, 1)
 
-    update_emotion(predicted_emotion, percentage, intensity)
-    update_emotion_history(predicted_emotion, percentage, intensity, context)
+def generate_response(input_text):
+    inputs = response_tokenizer(input_text, return_tensors="pt")
+    response_ids = response_model.generate(inputs.input_ids, max_length=int(inputs.input_ids.shape[1] * 2.289))
+    response = response_tokenizer.decode(response_ids[:, inputs.input_ids.shape[1]:][0], skip_special_tokens=True)
+    return response
 
+def predict_emotion(context):
+    inputs = emotion_prediction_tokenizer(context, return_tensors="pt")
+    outputs = emotion_prediction_model(**inputs)
+    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    predicted_class = torch.argmax(predictions, dim=-1).item()
+    predicted_emotion = emotion_classes[predicted_class]
     return predicted_emotion
 
-def generate_response(context):
-    tokenizer, model = get_finetuned_lm_model()
-    inputs = tokenizer.encode(context, return_tensors='pt')
-
-    # Ensure pad_token_id is a tensor
-    pad_token_id = torch.tensor(tokenizer.pad_token_id)
-
-    outputs = model.generate(inputs, max_length=500, num_return_sequences=1, pad_token_id=pad_token_id.item(), eos_token_id=tokenizer.eos_token_id)
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-    # Ensure the response does not repeat the input
-    if context in response:
-        response = response.replace(context, '').strip()
-    
+def interactive_interface(context):
+    normalized_context = normalize_context(context)
+    predicted_emotion = predict_emotion(normalized_context)
+    update_emotion(predicted_emotion, random.uniform(5, 15), random.uniform(1, 10))
+    update_emotion_history(predicted_emotion, emotions[predicted_emotion]['percentage'], emotions[predicted_emotion]['intensity'], normalized_context)
+    evolve_emotions()
+    feature_transformations()
+    response = generate_response(normalized_context)
     return response
 
-def handle_conversation(user_input):
-    user_input = normalize_context(user_input)
-    predicted_emotion = predict_emotion(user_input)
-    bot_response = generate_response(user_input)
-    return f"Emotion: {predicted_emotion}, Response: {bot_response}"
-
-def update_ui(user_input):
-    response = handle_conversation(user_input)
+# Gradio Interface
+def gradio_interface(input_text):
+    response = interactive_interface(input_text)
     return response
 
-with gr.Blocks() as demo:
-    user_input = gr.Textbox(label="User Input")
-    response = gr.Textbox(label="Bot Response")
-    submit = gr.Button("Submit")
-    submit.click(update_ui, inputs=[user_input], outputs=[response])
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs="text",
+    outputs="text",
+    title="Emotion-aware AI with Enhanced Features",
+    description="An AI that predicts emotions from text and generates responses with 443 additional features."
+)
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    iface.launch()