Update app.py

app.py

@@ -38,75 +38,23 @@ data = {
 }
 df = pd.DataFrame(data)
 
-# 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 = pd.Categorical(df['emotion']).codes
 emotion_classes = pd.Categorical(df['emotion']).categories
 
-# Memory-efficient Neural Network with PyTorch
-class MemoryEfficientNN(nn.Module):
-    def __init__(self, input_size, hidden_size, num_classes):
-        super(MemoryEfficientNN, self).__init__()
-        self.layers = nn.Sequential(
-            nn.Embedding(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):
-        return self.layers(x.long())
-
-# Memory-efficient dataset
-class MemoryEfficientDataset(IterableDataset):
-    def __init__(self, X, y, batch_size):
-        self.X = X
-        self.y = torch.LongTensor(y.unsqueeze(1))  # Convert labels to long tensors and add a new dimension
-        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), 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 = MemoryEfficientNN(input_size, hidden_size, num_classes).to(device)
-criterion = nn.CrossEntropyLoss()
-optimizer = optim.Adam(model.parameters(), lr=0.001)
+# Load pre-trained BERT model for emotion prediction
+emotion_prediction_model = AutoModelForSequenceClassification.from_pretrained("bhadresh-savani/distilbert-base-go-emotions-emotion")
 
-train_dataset = MemoryEfficientDataset(X_train, y_train, batch_size=32)
-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, non_blocking=True), batch_y.to(device, non_blocking=True)
-        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 (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 (memory-efficient)
-isolation_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1, max_samples='auto')
-isolation_forest.fit(X_train)  # Fit the model before using it
+# Lazy loading for the fine-tuned language model
+_finetuned_lm_tokenizer = None
+_finetuned_lm_model = None
+def get_finetuned_lm_model():
+    global _finetuned_lm_tokenizer, _finetuned_lm_model
+    if _finetuned_lm_tokenizer is None or _finetuned_lm_model is None:
+        finetuned_lm_model_name = "microsoft/DialoGPT-large"  # Replace with your fine-tuned language model name
+        _finetuned_lm_tokenizer = AutoTokenizer.from_pretrained(finetuned_lm_model_name)
+        _finetuned_lm_model = AutoModelForCausalLM.from_pretrained(finetuned_lm_model_name, device_map="auto", low_cpu_mem_usage=True)
+    return _finetuned_lm_tokenizer, _finetuned_lm_model
 
 # Enhanced Emotional States
 emotions = {
@@ -199,112 +147,54 @@ 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():
-    global _bloom_tokenizer, _bloom_lm_model
-    if _bloom_tokenizer is None or _bloom_lm_model is None:
-        bloom_model_name = 'bigscience/bloom-1b7'
-        _bloom_tokenizer = AutoTokenizer.from_pretrained(bloom_model_name)
-        _bloom_lm_model = AutoModelForCausalLM.from_pretrained(bloom_model_name, device_map="auto", low_cpu_mem_usage=True)
-    return _bloom_tokenizer, _bloom_lm_model
-
-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 = distilgpt3_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 = 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 = bloom_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 = bloom_tokenizer.decode(output[0], skip_special_tokens=True)
+def predict_emotion(context):
+    emotion_prediction_pipeline = pipeline('text-classification', model=emotion_prediction_model, return_all_scores=True)
+    predictions = emotion_prediction_pipeline(context)
+    emotion_scores = predictions[0]
+    emotion_pred = max(emotion_scores, key=emotion_scores.get)
+    return emotion_pred
+
+def generate_text(prompt, max_length=100, emotion=None):
+    finetuned_lm_tokenizer, finetuned_lm_model = get_finetuned_lm_model()
+    input_ids = finetuned_lm_tokenizer.encode(prompt, return_tensors='pt').to(finetuned_lm_model.device)
+
+    if emotion is not None:
+        emotion_intensity = emotions[emotion]['intensity']
+        top_p = 0.95 - (emotion_intensity / 10)  # Adjust top_p based on emotion intensity
+        temperature = 0.7 + (emotion_intensity / 5)  # Adjust temperature based on emotion intensity
     else:
-        raise ValueError("Invalid model type. Choose 'distilgpt3' or 'bloom'.")
-
+        top_p = 0.95
+        temperature = 0.7
+
+    with torch.no_grad():
+        output = finetuned_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=top_p,
+            temperature=temperature
+        )
+    generated_text = finetuned_lm_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 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_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')
-
-        historical_data = load_historical_data()
-        historical_data.append({
-            'context': text,
-            'predicted_emotion': predicted_emotion,
-            'sentiment_score': sentiment_score,
-            'distilgpt3_generated_text': distilgpt3_generated_text,
-            'bloom_generated_text': bloom_generated_text
-        })
-        save_historical_data(historical_data)
-
-        return predicted_emotion, sentiment_score, distilgpt3_generated_text, bloom_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, error_message
-
-iface = gr.Interface(
-    fn=process_input,
-    inputs="text",
-    outputs=[
-        gr.Textbox(label="Emotional Response"),
-        gr.Textbox(label="Sentiment Response"),
-        gr.Textbox(label="DistilGPT-3 Generated Text"),
-        gr.Textbox(label="BLOOM Generated Text")
-    ],
-    live=True
-)
+def generate_response(context, emotion=None):
+    prompt = context
+    generated_text = generate_text(prompt, emotion=emotion)
+    return generated_text
 
-iface.launch(share=True)
+with gr.Blocks() as demo:
+    gr.Markdown("# Emotion-Aware Language Model")
+    
+    context_input = gr.Textbox(label="Enter a context")
+    predict_btn = gr.Button("Predict Emotion and Generate Text")
+    
+    with gr.Row():
+        emotion_output = gr.Textbox(label="Predicted Emotion")
+        generated_text_output = gr.Textbox(label="Generated Text")
+    
+    predict_btn.click(fn=lambda context: (predict_emotion(context), generate_response(context, emotion=predict_emotion(context))), inputs=context_input, outputs=[emotion_output, generated_text_output])
+
+demo.launch()