Update app.py

app.py

@@ -5,7 +5,6 @@ import os
 import json
 import random
 import gradio as gr
-import gradio.components
 import torch
 import torch.nn as nn
 import torch.optim as optim
@@ -185,107 +184,64 @@ def evolve_emotions():
                      (lambda: random.uniform(80, 120),),
                      n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
-
-    toolbox.register("evaluate", evaluate)
-    toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=0, up=120, eta=20.0)
-    toolbox.register("mutate", tools.mutPolynomialBounded, low=0, up=120, eta=20.0, indpb=0.1)
+    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)
 
-    population = toolbox.population(n=50)
-    
-    for gen in range(25):
-        offspring = algorithms.varAnd(population, toolbox, cxpb=0.7, mutpb=0.3)
-        fits = toolbox.map(toolbox.evaluate, offspring)
-        for fit, ind in zip(fits, offspring):
-            ind.fitness.values = fit
-        population = toolbox.select(offspring + population, k=len(population))
-        
     best_individual = tools.selBest(population, k=1)[0]
-    
-    for idx, emotion in enumerate(emotions.keys()):
-        if idx < len(emotions) - 1:
-            emotions[emotion]['percentage'] = best_individual[idx]
-            emotions[emotion]['intensity'] = best_individual[idx + len(emotions) - 1]
-        else:
-            emotions[emotion]['percentage'] = best_individual[-1]
-
-# Lazy loading for the language model
-def get_language_model():
-    model_name = 'bigscience/bloom-1b7'
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    lm_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", low_cpu_mem_usage=True)
-    return tokenizer, lm_model
-
-def generate_text(prompt, max_length=100):
-    tokenizer, lm_model = get_language_model()
-    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(lm_model.device)
-    with torch.no_grad():
-        output = lm_model.generate(
-            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
-        )
-    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
-    return generated_text
-
-model_name = "distilbert-base-uncased-finetuned-sst-2-english"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForSequenceClassification.from_pretrained(model_name)
-sentiment_pipeline = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
-def get_sentiment(text):
-    result = sentiment_pipeline(text)[0]
-    return f"Sentiment: {result['label']}, Score: {result['score']:.4f}"
-
-def get_emotional_response(context):
-    context = normalize_context(context)
-    context_encoded = encoder.transform([[context]])
-    
-    # Neural network prediction
-    with torch.no_grad():
-        nn_output = model(torch.FloatTensor(context_encoded.toarray()).to(device))
-        nn_prediction = nn_output.argmax(1).item()
-    
-    # Random Forest prediction
-    rf_prediction = rf_model.predict(context_encoded)[0]
-    
-    # Weighted ensemble
-    ensemble_prediction = (0.6 * nn_prediction + 0.4 * rf_prediction)
-    predicted_emotion = emotion_classes[int(ensemble_prediction)]
-    
-    # Isolation Forest anomaly detection
-    anomaly_score = isolation_forest.decision_function(context_encoded.toarray())
-    is_anomaly = isolation_forest.predict(context_encoded.toarray())[0] == -1
-    
-    if is_anomaly:
-        return "Anomaly detected in the emotional response."
-    
-    return f"Predicted Emotion: {predicted_emotion}"
-
-# Gradio interface
-def process_input(input_text):
-    emotional_response = get_emotional_response(input_text)
-    sentiment_response = get_sentiment(input_text)
-    generated_text = generate_text(input_text)
-    return {
-        "Emotional Response": emotional_response,
-        "Sentiment Response": sentiment_response,
-        "Generated Text": generated_text
-    }
+    emotion_values = best_individual[:len(emotions)-1]
+    intensities = best_individual[-21:-1]
+    ideal_state = best_individual[-1]
+
+    for i, emotion in enumerate(emotions):
+        emotions[emotion]['percentage'] = emotion_values[i]
+        emotions[emotion]['intensity'] = intensities[i]
+
+    emotions['ideal_state']['percentage'] = ideal_state
+
+def process_input(text):
+    try:
+        normalized_text = normalize_context(text)
+        encoded_text = encoder.transform([[normalized_text]])
+        
+        rf_prediction = rf_model.predict(encoded_text)[0]
+        isolation_score = isolation_forest.decision_function(encoded_text)[0]
+        nn_prediction = model(torch.FloatTensor(encoded_text.toarray()).to(device)).argmax(dim=1).item()
+        
+        predicted_emotion = emotion_classes[rf_prediction]
+        sentiment_score = isolation_score
+        generated_text = emotion_classes[nn_prediction]
+
+        historical_data = load_historical_data()
+        historical_data.append({
+            'context': text,
+            'predicted_emotion': predicted_emotion,
+            'sentiment_score': sentiment_score,
+            'generated_text': generated_text
+        })
+        save_historical_data(historical_data)
+
+        return predicted_emotion, sentiment_score, generated_text
+
+    except Exception as e:
+        error_message = f"An error occurred: {str(e)}"
+        print(error_message)  # Logging the error
+        return error_message, error_message, error_message
 
 iface = gr.Interface(
     fn=process_input,
     inputs="text",
     outputs=[
-        gr.Textbox(label="Emotional Response", interactive=False),
-        gr.Textbox(label="Sentiment Response", interactive=False),
-        gr.Textbox(label="Generated Text", interactive=False)
+        gr.outputs.Textbox(label="Emotional Response"),
+        gr.outputs.Textbox(label="Sentiment Response"),
+        gr.outputs.Textbox(label="Generated Text")
     ],
-    allow_flagging="never"
+    live=True
 )
 
-iface.launch()
+iface.launch(share=True)