Update app.py

app.py

@@ -14,9 +14,10 @@ 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
+from torch.utils.data import DataLoader, TensorDataset, IterableDataset
 import multiprocessing as mp
 from joblib import Parallel, delayed
+import gc
 
 warnings.filterwarnings('ignore', category=FutureWarning, module='huggingface_hub.file_download')
 
@@ -37,61 +38,75 @@ data = {
 }
 df = pd.DataFrame(data)
 
-# Encoding the contexts using One-Hot Encoding
-encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
+# Encoding the contexts using One-Hot Encoding (memory-efficient)
+encoder = OneHotEncoder(handle_unknown='ignore', sparse=True)
 contexts_encoded = encoder.fit_transform(df[['context']])
 
 # Encoding emotions
-emotions_target = df['emotion'].astype('category').cat.codes.values
-emotion_classes = df['emotion'].astype('category').cat.categories.values
+emotions_target = pd.Categorical(df['emotion']).codes
+emotion_classes = pd.Categorical(df['emotion']).categories
 
-# Advanced Neural Network with PyTorch
-class AdvancedNN(nn.Module):
+# Memory-efficient Neural Network with PyTorch
+class MemoryEfficientNN(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)
+        super(MemoryEfficientNN, self).__init__()
+        self.layers = nn.Sequential(
+            nn.Linear(input_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(hidden_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(hidden_size, num_classes)
+        )
         
     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
+        return self.layers(x)
+
+# Memory-efficient dataset
+class MemoryEfficientDataset(IterableDataset):
+    def __init__(self, X, y, batch_size):
+        self.X = X
+        self.y = y
+        self.batch_size = batch_size
+
+    def __iter__(self):
+        for i in range(0, len(self.y), self.batch_size):
+            X_batch = self.X[i:i+self.batch_size].toarray()
+            y_batch = self.y[i:i+self.batch_size]
+            yield torch.FloatTensor(X_batch), torch.LongTensor(y_batch)
+
+# Train Memory-Efficient Neural Network
 X_train, X_test, y_train, y_test = train_test_split(contexts_encoded, emotions_target, test_size=0.2, random_state=42)
 input_size = X_train.shape[1]
 hidden_size = 64
 num_classes = len(emotion_classes)
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model = AdvancedNN(input_size, hidden_size, num_classes).to(device)
+model = MemoryEfficientNN(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).to(device), torch.LongTensor(y_train).to(device))
-train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+train_dataset = MemoryEfficientDataset(X_train, y_train, batch_size=32)
+train_loader = DataLoader(train_dataset, batch_size=None)
 
 num_epochs = 100
 for epoch in range(num_epochs):
     for batch_X, batch_y in train_loader:
+        batch_X, batch_y = batch_X.to(device), batch_y.to(device)
         outputs = model(batch_X)
         loss = criterion(outputs, batch_y)
         optimizer.zero_grad()
         loss.backward()
         optimizer.step()
+    gc.collect()  # Garbage collection after each epoch
 
-# Ensemble with Random Forest
-rf_model = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
+# Ensemble with Random Forest (memory-efficient)
+rf_model = RandomForestClassifier(n_estimators=50, random_state=42, n_jobs=-1)
 rf_model.fit(X_train, y_train)
 
-# Isolation Forest Anomaly Detection Model
-isolation_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1)
+# Isolation Forest Anomaly Detection Model (memory-efficient)
+isolation_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1, max_samples=100)
 isolation_forest.fit(X_train)
 
 # Enhanced Emotional States
@@ -149,16 +164,16 @@ def update_emotion(emotion, percentage, intensity):
 def normalize_context(context):
     return context.lower().strip()
 
-# 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))
-
+# Memory-efficient 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))
+
     creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, -1.0))
     creator.create("Individual", list, fitness=creator.FitnessMulti)
 
@@ -172,20 +187,20 @@ def evolve_emotions():
                      n=1)
     toolbox.register("population", tools.initRepeat, list, toolbox.individual)
 
-    pool = mp.Pool()
-    toolbox.register("map", pool.map)
-    toolbox.register("evaluate", parallel_evaluate)
+    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("select", tools.selNSGA2)
 
-    population = toolbox.population(n=100)
-    
-    algorithms.eaMuPlusLambda(population, toolbox, mu=100, lambda_=100, 
-                              cxpb=0.7, mutpb=0.3, ngen=50, verbose=False)
-
-    pool.close()
+    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()):
@@ -198,10 +213,10 @@ 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).to(device)
+lm_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", low_cpu_mem_usage=True)
 
-def generate_text(prompt, max_length=150):
-    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(device)
+def generate_text(prompt, max_length=100):
+    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(lm_model.device)
     with torch.no_grad():
         output = lm_model.generate(
             input_ids, 
@@ -216,7 +231,7 @@ def generate_text(prompt, max_length=150):
     generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
     return generated_text
 
-sentiment_pipeline = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer, device=0 if torch.cuda.is_available() else -1)
+sentiment_pipeline = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer, device_map="auto")
 
 def get_sentiment(text):
     result = sentiment_pipeline(text)[0]
@@ -228,7 +243,7 @@ def get_emotional_response(context):
     
     # Neural network prediction
     with torch.no_grad():
-        nn_output = model(torch.FloatTensor(context_encoded).to(device))
+        nn_output = model(torch.FloatTensor(context_encoded.toarray()).to(device))
         nn_prediction = nn_output.argmax(1).item()
     
     # Random Forest prediction
@@ -239,7 +254,7 @@ def get_emotional_response(context):
     predicted_emotion = emotion_classes[int(round(ensemble_prediction))]
 
     # Anomaly detection
-    anomaly_score = isolation_forest.decision_function(context_encoded)
+    anomaly_score = isolation_forest.decision_function(context_encoded.toarray())
     is_anomaly = anomaly_score < 0
 
     # Calculate emotion intensity based on model confidence