Update app.py

app.py

@@ -5,16 +5,18 @@ import os
 import json
 import random
 import gradio as gr
-from sklearn.ensemble import IsolationForest
-from sklearn.model_selection import train_test_split
+from sklearn.ensemble import IsolationForest, RandomForestClassifier, GradientBoostingClassifier
+from sklearn.model_selection import train_test_split, GridSearchCV
 from sklearn.preprocessing import OneHotEncoder
 from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import accuracy_score
 from deap import base, creator, tools, algorithms
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
 import torch
-import torch.multiprocessing as mp
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
 
-# Suppress specific warnings
 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
 
 # Initialize Example Emotions Dataset
@@ -42,41 +44,82 @@ contexts_encoded = encoder.fit_transform(df[['context']]).toarray()
 emotions_target = df['emotion'].astype('category').cat.codes
 emotion_classes = df['emotion'].astype('category').cat.categories
 
-# Train Neural Network
+# Advanced Neural Network with PyTorch
+class AdvancedNN(nn.Module):
+    def __init__(self, input_size, hidden_size, num_classes):
+        super(AdvancedNN, self).__init__()
+        self.layer1 = nn.Linear(input_size, hidden_size)
+        self.layer2 = nn.Linear(hidden_size, hidden_size)
+        self.layer3 = nn.Linear(hidden_size, num_classes)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.2)
+        
+    def forward(self, x):
+        x = self.relu(self.layer1(x))
+        x = self.dropout(x)
+        x = self.relu(self.layer2(x))
+        x = self.dropout(x)
+        x = self.layer3(x)
+        return x
+
+# Train Advanced Neural Network
 X_train, X_test, y_train, y_test = train_test_split(contexts_encoded, emotions_target, test_size=0.2, random_state=42)
-model = MLPClassifier(hidden_layer_sizes=(10, 10), max_iter=1000, random_state=42)
-model.fit(X_train, y_train)
+input_size = X_train.shape[1]
+hidden_size = 64
+num_classes = len(emotion_classes)
+
+model = AdvancedNN(input_size, hidden_size, num_classes)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+train_dataset = TensorDataset(torch.FloatTensor(X_train), torch.LongTensor(y_train))
+train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+
+num_epochs = 100
+for epoch in range(num_epochs):
+    for batch_X, batch_y in train_loader:
+        outputs = model(batch_X)
+        loss = criterion(outputs, batch_y)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+# Ensemble with Random Forest and Gradient Boosting
+rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
+gb_model = GradientBoostingClassifier(n_estimators=100, random_state=42)
+
+rf_model.fit(X_train, y_train)
+gb_model.fit(X_train, y_train)
 
 # Isolation Forest Anomaly Detection Model
-historical_data = np.array([model.predict(contexts_encoded)]).T
+historical_data = np.array([model(torch.FloatTensor(contexts_encoded)).argmax(1).numpy()]).T
 isolation_forest = IsolationForest(contamination=0.1, random_state=42)
 isolation_forest.fit(historical_data)
 
-# Emotional States with 20 emotions
+# Enhanced Emotional States
 emotions = {
-    'joy': {'percentage': 10, 'motivation': 'positive'},
-    'pleasure': {'percentage': 10, 'motivation': 'selfish'},
-    'sadness': {'percentage': 10, 'motivation': 'negative'},
-    'grief': {'percentage': 10, 'motivation': 'negative'},
-    'anger': {'percentage': 10, 'motivation': 'traumatic or strong'},
-    'calmness': {'percentage': 10, 'motivation': 'neutral'},
-    'determination': {'percentage': 10, 'motivation': 'positive'},
-    'resentment': {'percentage': 10, 'motivation': 'negative'},
-    'glory': {'percentage': 10, 'motivation': 'positive'},
-    'motivation': {'percentage': 10, 'motivation': 'positive'},
-    'ideal_state': {'percentage': 100, 'motivation': 'balanced'},
-    'fear': {'percentage': 10, 'motivation': 'defensive'},
-    'surprise': {'percentage': 10, 'motivation': 'unexpected'},
-    'anticipation': {'percentage': 10, 'motivation': 'predictive'},
-    'trust': {'percentage': 10, 'motivation': 'reliable'},
-    'disgust': {'percentage': 10, 'motivation': 'repulsive'},
-    'optimism': {'percentage': 10, 'motivation': 'hopeful'},
-    'pessimism': {'percentage': 10, 'motivation': 'doubtful'},
-    'boredom': {'percentage': 10, 'motivation': 'indifferent'},
-    'envy': {'percentage': 10, 'motivation': 'jealous'}
+    '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}
 }
 
-# Adjust all emotions to a total of 200%
 total_percentage = 200
 default_percentage = total_percentage / len(emotions)
 for emotion in emotions:
@@ -84,105 +127,152 @@ for emotion in emotions:
 
 emotion_history_file = 'emotion_history.json'
 
-# Load historical data from file if exists
 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 []
 
-# Save historical data to file
 def save_historical_data(historical_data, file_path=emotion_history_file):
     with open(file_path, 'w') as file:
         json.dump(historical_data, file)
 
-# Load previous emotional states
-emotion_history = load_historical_data()
-
-# Function to update emotions
-def update_emotion(emotion, percentage):
+emotion_history = load_historical_data
+def update_emotion(emotion, percentage, intensity):
     emotions['ideal_state']['percentage'] -= percentage
     emotions[emotion]['percentage'] += percentage
+    emotions[emotion]['intensity'] = intensity
 
-    # Ensure total percentage remains 200%
     total_current = sum(e['percentage'] for e in emotions.values())
     adjustment = total_percentage - total_current
     emotions['ideal_state']['percentage'] += adjustment
 
-# Function to normalize context
 def normalize_context(context):
     return context.lower().strip()
 
-# Function to evolve emotions using genetic algorithm
+# Advanced Genetic Algorithm for Emotion Evolution
 def evolve_emotions():
-    # Define the fitness function
     def evaluate(individual):
-        ideal_state = individual[-1]  # Last value is the ideal state percentage
-        other_emotions = individual[:-1]  # All other emotions
-        return abs(ideal_state - 100), sum(other_emotions)
+        ideal_state = individual[-1]
+        other_emotions = individual[:-1]
+        intensities = individual[-21:-1]
+        return (abs(ideal_state - 100), 
+                sum(other_emotions), 
+                max(intensities) - min(intensities))
 
-    # Register the genetic algorithm components
-    creator.create("FitnessMin", base.Fitness, weights=(-1.0, -1.0))
-    creator.create("Individual", list, fitness=creator.FitnessMin)
+    creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0))
+    creator.create("Individual", list, fitness=creator.FitnessMulti)
 
-    # Create individuals and population
     toolbox = base.Toolbox()
-    toolbox.register("attribute", lambda: random.uniform(0, 20))
-    toolbox.register("individual", tools.initCycle, creator.Individual, toolbox.attribute, n=(len(emotions) - 1))
-    toolbox.register("ideal_state", lambda: random.uniform(80, 120))
-    toolbox.register("complete_individual", tools.initConcat, creator.Individual, toolbox.individual, toolbox.ideal_state)
-    toolbox.register("population", tools.initRepeat, list, toolbox.complete_individual)
+    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: random.uniform(80, 120),),
+                     n=1)
+    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
 
-    # Register genetic operators
     toolbox.register("evaluate", evaluate)
-    toolbox.register("mate", tools.cxBlend, alpha=0.5)
-    toolbox.register("mutate", tools.mutGaussian, mu=10, sigma=5, indpb=0.3)
-    toolbox.register("select", tools.selTournament, tournsize=3)
-
-    # Initialize the population
-    population = toolbox.population(n=10)
+    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("select", tools.selNSGA2)
 
-    # Run genetic algorithm
-    population, log = algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=20, verbose=False)
+    population = toolbox.population(n=100)
+    
+    algorithms.eaMuPlusLambda(population, toolbox, mu=100, lambda_=100, 
+                              cxpb=0.7, mutpb=0.3, ngen=50, verbose=False)
 
-    # Update the emotions with the best individual
     best_individual = tools.selBest(population, k=1)[0]
+    
     for idx, emotion in enumerate(emotions.keys()):
-        emotions[emotion]['percentage'] = best_individual[idx]
+        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]
+
+# Initialize the pre-trained language model (BLOOM-1b7)
+model_name = 'bigscience/bloom-1b7'
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+lm_model = AutoModelForCausalLM.from_pretrained(model_name)
+
+def generate_text(prompt, max_length=150):
+    input_ids = tokenizer.encode(prompt, return_tensors='pt')
+    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
+
+sentiment_pipeline = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer)
+
+def get_sentiment(text):
+    result = sentiment_pipeline(text)[0]
+    return f"Sentiment: {result['label']}, Score: {result['score']:.4f}"
 
-# Function to get emotional response
 def get_emotional_response(context):
-    # Normalize context
     context = normalize_context(context)
-
-    # Encode the context and predict the emotion using the neural network
     context_encoded = encoder.transform([[context]]).toarray()
-    prediction = model.predict(context_encoded)
-    predicted_emotion = emotion_classes[prediction[0]]
+    
+    # Advanced NN prediction
+    nn_output = model(torch.FloatTensor(context_encoded))
+    nn_prediction = nn_output.argmax(1).item()
+    
+    # Ensemble predictions
+    rf_prediction = rf_model.predict(context_encoded)[0]
+    gb_prediction = gb_model.predict(context_encoded)[0]
+    
+    # Weighted ensemble
+    ensemble_prediction = (0.4 * nn_prediction + 0.3 * rf_prediction + 0.3 * gb_prediction)
+    predicted_emotion = emotion_classes[int(round(ensemble_prediction))]
+
+    # Anomaly detection
+    anomaly_score = isolation_forest.decision_function(np.array([[nn_prediction]]))
+    is_anomaly = anomaly_score < 0
 
-    # Update emotions based on predicted emotion
-    update_emotion(predicted_emotion, 20)
+    # Calculate emotion intensity based on model confidence
+    nn_proba = torch.softmax(nn_output, dim=1).max().item()
+    rf_proba = rf_model.predict_proba(context_encoded).max()
+    gb_proba = gb_model.predict_proba(context_encoded).max()
+    intensity = (nn_proba + rf_proba + gb_proba) / 3 * 10  # Scale to 0-10
 
-    # Evolve emotions
+    update_emotion(predicted_emotion, 20, intensity)
     evolve_emotions()
 
-    # Save the updated emotion history
     emotion_history.append(emotions.copy())
     save_historical_data(emotion_history)
 
-    return f"Emotion: {predicted_emotion}, Emotion Details: {emotions[predicted_emotion]}"
+    response = f"Predicted Emotion: {predicted_emotion}\n"
+    response += f"Emotion Details: {emotions[predicted_emotion]}\n"
+    response += f"Anomaly Detected: {'Yes' if is_anomaly else 'No'}\n"
+    response += f"Emotion Intensity: {intensity:.2f}/10\n"
+    response += f"Current Emotional State: {json.dumps(emotions, indent=2)}"
+
+    return response
 
-# Initialize the pre-trained language model (Phi 3 Mini)
-model_name = 'microsoft/phi3-mini'
-tokenizer = AutoTokenizer.from_pretrained(model_name, force_download=True)
-lm_model = AutoModelForCausalLM.from_pretrained(model_name, force_download=True)
+def process_input(input_text):
+    emotional_response = get_emotional_response(input_text)
+    sentiment = get_sentiment(input_text)
+    generated_text = generate_text(f"Based on the emotion analysis: {emotional_response}\nGenerate a response: {input_text}")
+    
+    return f"{emotional_response}\n\nSentiment Analysis: {sentiment}\n\nGenerated Response: {generated_text}"
 
-# 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')
+# Gradio Interface
+iface = gr.Interface(
+    fn=process_input,
+    inputs="text",
+    outputs="text",
+    title="Advanced Emotion Analysis and Text Generation with BLOOM-1b7",
+    description="Enter a sentence for comprehensive emotion analysis, sentiment analysis, and context-aware text generation using advanced AI models."
+)
 
-    # Example usage
-    context_input = "I am feeling very joyful today"
-    emotional_response = get_emotional_response(context_input)
-    print(emotional_response)
+if __name__ == "__main__":
+    iface.launch()