Update app.py

app.py

@@ -88,12 +88,12 @@ criterion = nn.CrossEntropyLoss()
 optimizer = optim.Adam(model.parameters(), lr=0.001)
 
 train_dataset = MemoryEfficientDataset(X_train, y_train, batch_size=32)
-train_loader = DataLoader(train_dataset, batch_size=None)
+train_loader = DataLoader(train_dataset, batch_size=None, num_workers=4, pin_memory=True)
 
 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)
+        batch_X, batch_y = batch_X.to(device, non_blocking=True), batch_y.to(device, non_blocking=True)
         outputs = model(batch_X)
         loss = criterion(outputs, batch_y)
         optimizer.zero_grad()
@@ -130,8 +130,11 @@ emotions = {
     '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},
-    emotion_history_file = 'emotion_history.json'
+    'envy': {'percentage': 10, 'motivation': 'jealous', 'intensity': 0}
+}
+total_percentage = 200
+default_percentage = total_percentage / len(emotions)
+for emotion in emotion_history_file = 'emotion_history.json'
 
 def load_historical_data(file_path=emotion_history_file):
     if os.path.exists(file_path):
@@ -199,6 +202,16 @@ def evolve_emotions():
     emotions['ideal_state']['percentage'] = ideal_state
 
 # Lazy loading for the language models
+_distilgpt3_tokenizer = None
+_distilgpt3_lm_model = None
+def get_distilgpt3_model():
+    global _distilgpt3_tokenizer, _distilgpt3_lm_model
+    if _distilgpt3_tokenizer is None or _distilgpt3_lm_model is None:
+        distilgpt3_model_name = 'distilgpt2'  # Replace with the fine-tuned DistilGPT-3 model name
+        _distilgpt3_tokenizer = AutoTokenizer.from_pretrained(distilgpt3_model_name)
+        _distilgpt3_lm_model = AutoModelForCausalLM.from_pretrained(distilgpt3_model_name, device_map="auto", low_cpu_mem_usage=True)
+    return _distilgpt3_tokenizer, _distilgpt3_lm_model
+
 _bloom_tokenizer = None
 _bloom_lm_model = None
 def get_bloom_model():
@@ -209,22 +222,12 @@ def get_bloom_model():
         _bloom_lm_model = AutoModelForCausalLM.from_pretrained(bloom_model_name, device_map="auto", low_cpu_mem_usage=True)
     return _bloom_tokenizer, _bloom_lm_model
 
-_gpt_tokenizer = None
-_gpt_lm_model = None
-def get_gpt_model():
-    global _gpt_tokenizer, _gpt_lm_model
-    if _gpt_tokenizer is None or _gpt_lm_model is None:
-        gpt_model_name = 'gpt2-medium'
-        _gpt_tokenizer = AutoTokenizer.from_pretrained(gpt_model_name)
-        _gpt_lm_model = AutoModelForCausalLM.from_pretrained(gpt_model_name, device_map="auto", low_cpu_mem_usage=True)
-    return _gpt_tokenizer, _gpt_lm_model
-
-def generate_text(prompt, max_length=100, model_type='bloom'):
-    if model_type == 'bloom':
-        bloom_tokenizer, bloom_lm_model = get_bloom_model()
-        input_ids = bloom_tokenizer.encode(prompt, return_tensors='pt').to(bloom_lm_model.device)
+def generate_text(prompt, max_length=100, model_type='distilgpt3'):
+    if model_type == 'distilgpt3':
+        distilgpt3_tokenizer, distilgpt3_lm_model = get_distilgpt3_model()
+        input_ids = distilgpt3_tokenizer.encode(prompt, return_tensors='pt').to(distilgpt3_lm_model.device)
         with torch.no_grad():
-            output = bloom_lm_model.generate(
+            output = distilgpt3_lm_model.generate(
                 input_ids,
                 max_length=max_length,
                 num_return_sequences=1,
@@ -234,12 +237,12 @@ def generate_text(prompt, max_length=100, model_type='bloom'):
                 top_p=0.95,
                 temperature=0.7
             )
-        generated_text = bloom_tokenizer.decode(output[0], skip_special_tokens=True)
-    elif model_type == 'gpt':
-        gpt_tokenizer, gpt_lm_model = get_gpt_model()
-        input_ids = gpt_tokenizer.encode(prompt, return_tensors='pt').to(gpt_lm_model.device)
+        generated_text = distilgpt3_tokenizer.decode(output[0], skip_special_tokens=True)
+    elif model_type == 'bloom':
+        bloom_tokenizer, bloom_lm_model = get_bloom_model()
+        input_ids = bloom_tokenizer.encode(prompt, return_tensors='pt').to(bloom_lm_model.device)
         with torch.no_grad():
-            output = gpt_lm_model.generate(
+            output = bloom_lm_model.generate(
                 input_ids,
                 max_length=max_length,
                 num_return_sequences=1,
@@ -249,9 +252,9 @@ def generate_text(prompt, max_length=100, model_type='bloom'):
                 top_p=0.95,
                 temperature=0.7
             )
-        generated_text = gpt_tokenizer.decode(output[0], skip_special_tokens=True)
+        generated_text = bloom_tokenizer.decode(output[0], skip_special_tokens=True)
     else:
-        raise ValueError("Invalid model type. Choose 'bloom' or 'gpt'.")
+        raise ValueError("Invalid model type. Choose 'distilgpt3' or 'bloom'.")
 
     return generated_text
 
@@ -270,25 +273,25 @@ def process_input(text):
         
         rf_prediction = rf_model.predict(encoded_text)[0]
         isolation_score = isolation_forest.decision_function(encoded_text)[0]
-        nn_output = model(torch.LongTensor(encoded_text.toarray()).to(device))
+        nn_output = model(torch.LongTensor(encoded_text.toarray()).to(device, non_blocking=True))
         nn_prediction = nn_output.argmax(dim=1).item()
         
         predicted_emotion = emotion_classes[rf_prediction]
         sentiment_score = isolation_score
+       distilgpt3_generated_text = generate_text(normalized_text, model_type='distilgpt3')
         bloom_generated_text = generate_text(normalized_text, model_type='bloom')
-        gpt_generated_text = generate_text(normalized_text, model_type='gpt')
 
         historical_data = load_historical_data()
         historical_data.append({
             'context': text,
             'predicted_emotion': predicted_emotion,
             'sentiment_score': sentiment_score,
-            'bloom_generated_text': bloom_generated_text,
-            'gpt_generated_text': gpt_generated_text
+            'distilgpt3_generated_text': distilgpt3_generated_text,
+            'bloom_generated_text': bloom_generated_text
         })
         save_historical_data(historical_data)
 
-        return predicted_emotion, sentiment_score, bloom_generated_text, gpt_generated_text
+        return predicted_emotion, sentiment_score, distilgpt3_generated_text, bloom_generated_text
 
     except Exception as e:
         error_message = f"An error occurred: {str(e)}"
@@ -301,8 +304,8 @@ iface = gr.Interface(
     outputs=[
         gr.Textbox(label="Emotional Response"),
         gr.Textbox(label="Sentiment Response"),
-        gr.Textbox(label="BLOOM Generated Text"),
-        gr.Textbox(label="GPT Generated Text")
+        gr.Textbox(label="DistilGPT-3 Generated Text"),
+        gr.Textbox(label="BLOOM Generated Text")
     ],
     live=True
 )