Update app.py

app.py

@@ -5,17 +5,18 @@ import os
 import json
 import random
 import gradio as gr
-from sklearn.ensemble import IsolationForest, RandomForestClassifier, GradientBoostingClassifier
-from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.ensemble import IsolationForest, RandomForestClassifier
+from sklearn.model_selection import train_test_split
 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, pipeline
 import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader, TensorDataset
+import multiprocessing as mp
+from joblib import Parallel, delayed
 
 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
 
@@ -37,12 +38,12 @@ data = {
 df = pd.DataFrame(data)
 
 # Encoding the contexts using One-Hot Encoding
-encoder = OneHotEncoder(handle_unknown='ignore')
-contexts_encoded = encoder.fit_transform(df[['context']]).toarray()
+encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
+contexts_encoded = encoder.fit_transform(df[['context']])
 
 # Encoding emotions
-emotions_target = df['emotion'].astype('category').cat.codes
-emotion_classes = df['emotion'].astype('category').cat.categories
+emotions_target = df['emotion'].astype('category').cat.codes.values
+emotion_classes = df['emotion'].astype('category').cat.categories.values
 
 # Advanced Neural Network with PyTorch
 class AdvancedNN(nn.Module):
@@ -64,44 +65,34 @@ class AdvancedNN(nn.Module):
 
 # 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)
-
-# Convert to dense array if it's a sparse matrix, otherwise leave as is
-X_train = X_train.toarray() if hasattr(X_train, 'toarray') else X_train
-X_test = X_test.toarray() if hasattr(X_test, 'toarray') else X_test
-
-# Ensure y_train and y_test are numpy arrays
-y_train = y_train.to_numpy() if hasattr(y_train, 'to_numpy') else np.array(y_train)
-y_test = y_test.to_numpy() if hasattr(y_test, 'to_numpy') else np.array(y_test)
-
 input_size = X_train.shape[1]
 hidden_size = 64
 num_classes = len(emotion_classes)
 
-model = AdvancedNN(input_size, hidden_size, num_classes)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = AdvancedNN(input_size, hidden_size, num_classes).to(device)
 criterion = nn.CrossEntropyLoss()
 optimizer = optim.Adam(model.parameters(), lr=0.001)
 
-train_dataset = TensorDataset(torch.FloatTensor(X_train), torch.LongTensor(y_train))
+train_dataset = TensorDataset(torch.FloatTensor(X_train).to(device), torch.LongTensor(y_train).to(device))
 train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
 
-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)
-
-# 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)
-
+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
+rf_model = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
 rf_model.fit(X_train, y_train)
-gb_model.fit(X_train, y_train)
 
 # Isolation Forest Anomaly Detection Model
-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)
+isolation_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1)
+isolation_forest.fit(X_train)
 
 # Enhanced Emotional States
 emotions = {
@@ -144,7 +135,8 @@ def save_historical_data(historical_data, file_path=emotion_history_file):
     with open(file_path, 'w') as file:
         json.dump(historical_data, file)
 
-emotion_history = load_historical_data
+emotion_history = load_historical_data()
+
 def update_emotion(emotion, percentage, intensity):
     emotions['ideal_state']['percentage'] -= percentage
     emotions[emotion]['percentage'] += percentage
@@ -157,16 +149,16 @@ def update_emotion(emotion, percentage, intensity):
 def normalize_context(context):
     return context.lower().strip()
 
-# Advanced Genetic Algorithm for Emotion Evolution
-def evolve_emotions():
-    def evaluate(individual):
-        ideal_state = individual[-1]
-        other_emotions = individual[:-1]
-        intensities = individual[-21:-1]
-        return (abs(ideal_state - 100), 
-                sum(other_emotions), 
-                max(intensities) - min(intensities))
+# Parallel genetic algorithm for emotion evolution
+def parallel_evaluate(individual):
+    ideal_state = individual[-1]
+    other_emotions = individual[:-1]
+    intensities = individual[-21:-1]
+    return (abs(ideal_state - 100), 
+            sum(other_emotions), 
+            max(intensities) - min(intensities))
 
+def evolve_emotions():
     creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0))
     creator.create("Individual", list, fitness=creator.FitnessMulti)
 
@@ -180,7 +172,9 @@ def evolve_emotions():
                      n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
 
-    toolbox.register("evaluate", evaluate)
+    pool = mp.Pool()
+    toolbox.register("map", pool.map)
+    toolbox.register("evaluate", parallel_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("select", tools.selNSGA2)
@@ -190,6 +184,8 @@ def evolve_emotions():
     algorithms.eaMuPlusLambda(population, toolbox, mu=100, lambda_=100, 
                               cxpb=0.7, mutpb=0.3, ngen=50, verbose=False)
 
+    pool.close()
+    
     best_individual = tools.selBest(population, k=1)[0]
     
     for idx, emotion in enumerate(emotions.keys()):
@@ -202,24 +198,25 @@ def evolve_emotions():
 # 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)
+lm_model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
 
 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
-    )
+    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(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
 
-sentiment_pipeline = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer)
+sentiment_pipeline = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer, device=0 if torch.cuda.is_available() else -1)
 
 def get_sentiment(text):
     result = sentiment_pipeline(text)[0]
@@ -227,29 +224,28 @@ def get_sentiment(text):
 
 def get_emotional_response(context):
     context = normalize_context(context)
-    context_encoded = encoder.transform([[context]]).toarray()
+    context_encoded = encoder.transform([[context]])
     
-    # Advanced NN prediction
-    nn_output = model(torch.FloatTensor(context_encoded))
-    nn_prediction = nn_output.argmax(1).item()
+    # Neural network prediction
+    with torch.no_grad():
+        nn_output = model(torch.FloatTensor(context_encoded).to(device))
+        nn_prediction = nn_output.argmax(1).item()
     
-    # Ensemble predictions
+    # Random Forest prediction
     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)
+    ensemble_prediction = (0.6 * nn_prediction + 0.4 * rf_prediction)
     predicted_emotion = emotion_classes[int(round(ensemble_prediction))]
 
     # Anomaly detection
-    anomaly_score = isolation_forest.decision_function(np.array([[nn_prediction]]))
+    anomaly_score = isolation_forest.decision_function(context_encoded)
     is_anomaly = anomaly_score < 0
 
     # 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
+    intensity = (nn_proba + rf_proba) / 2 * 10  # Scale to 0-10
 
     update_emotion(predicted_emotion, 20, intensity)
     evolve_emotions()