Update app.py

app.py

@@ -1,28 +1,37 @@
-from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
-from datasets import Dataset
 import torch
-from sklearn.model_selection import train_test_split
 import pandas as pd
+from sklearn.model_selection import train_test_split
+from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
+from datasets import Dataset
+import numpy as np
 
-# Load data (use your own dataset CSV here)
+# Load your CSV file into a pandas DataFrame
 df = pd.read_csv("dishTV_customer_service_with_address_and_rules_accurate_v2.csv")
-df = df.dropna(subset=['Agent Utterance', 'Customer Utterance', 'Category', 'Rule Followed', 'Question Asked', 'Question Answered'])
+
+# Print column names and first few rows to ensure data structure
+print(df.columns)
+print(df.head())
+
+# Create a conversation column by merging the agent's and customer's utterances
 df['Conversation'] = df['Agent Utterance'] + " " + df['Customer Utterance']
-df['Category'] = df['Category'].map({
-    'Greeting': 0,
-    'Addressing Issue': 1,
-    'Feedback': 2,
-    'Resolution': 3,
-    'Address': 4
-})
 
-# Split data
-train_texts, val_texts, train_labels, val_labels = train_test_split(df['Conversation'].tolist(), df['Compliant'].tolist(), test_size=0.2)
+# Map labels for classification (Rule Followed, Question Asked, Question Answered)
+df['Rule Followed'] = df['Rule Followed'].map({'Yes': 1, 'No': 0})
+df['Question Asked'] = df['Question Asked'].map({'Yes': 1, 'No': 0})
+df['Question Answered'] = df['Question Answered'].map({'Yes': 1, 'No': 0})
 
-# Tokenizer
+# Split data into training and validation sets
+train_texts, val_texts, train_labels, val_labels = train_test_split(
+    df['Conversation'].tolist(), 
+    df[['Rule Followed', 'Question Asked', 'Question Answered']].values, 
+    test_size=0.2
+)
+
+
+# Initialize BERT tokenizer
 tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
 
-# Tokenize the inputs
+# Tokenize the conversations
 train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=512)
 val_encodings = tokenizer(val_texts, truncation=True, padding=True, max_length=512)
 
@@ -30,75 +39,77 @@ val_encodings = tokenizer(val_texts, truncation=True, padding=True, max_length=5
 train_dataset = Dataset.from_dict({
     'input_ids': train_encodings['input_ids'],
     'attention_mask': train_encodings['attention_mask'],
-    'labels': train_labels
+    'labels': torch.tensor(train_labels, dtype=torch.float32)
 })
 
 val_dataset = Dataset.from_dict({
     'input_ids': val_encodings['input_ids'],
     'attention_mask': val_encodings['attention_mask'],
-    'labels': val_labels
+    'labels': torch.tensor(val_labels, dtype=torch.float32)
 })
 
-# Check dataset sizes
-print(f"Training dataset size: {len(train_dataset)}")
-print(f"Validation dataset size: {len(val_dataset)}")
 
-# Model
-model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
+# Initialize the BERT model for multi-label classification (3 labels)
+model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=3)
 
-# Calculate steps per epoch
-steps_per_epoch = len(train_dataset) // 8  # Assuming batch size = 8
-num_train_epochs = 3  # Desired number of epochs
-max_steps = steps_per_epoch * num_train_epochs
 
-# Define training arguments
+# Define the training arguments
 training_args = TrainingArguments(
-    output_dir='results',
-    eval_strategy='epoch',  # Evaluate at the end of each epoch
+    output_dir='./results',
+    evaluation_strategy='epoch',  # Evaluate after each epoch
     learning_rate=2e-5,
-    per_device_train_batch_size=8,  # You can adjust batch size here
+    per_device_train_batch_size=8,
     per_device_eval_batch_size=8,
-    num_train_epochs=num_train_epochs,  # Setting epochs to 3
+    num_train_epochs=3,
     weight_decay=0.01,
-    logging_dir='logs',
+    logging_dir='./logs',
     logging_steps=500,
     save_steps=1000,
     load_best_model_at_end=True,
     metric_for_best_model="accuracy",
-    max_steps=max_steps,  # Limit the total steps
+    do_train=True,
+    do_eval=True
 )
 
+
+# Trainer setup
 trainer = Trainer(
     model=model,
     args=training_args,
     train_dataset=train_dataset,
     eval_dataset=val_dataset,
-    compute_metrics=lambda p: {'accuracy': (p.predictions.argmax(axis=-1) == p.label_ids).mean()}
+    compute_metrics=lambda p: {
+        'accuracy': np.mean(np.all(p.predictions.argmax(axis=-1) == p.label_ids, axis=1))
+    }
 )
 
 # Start training
-print(f"Starting training for {num_train_epochs} epochs...")
 trainer.train()
 
+
 # Evaluate the model
-print("Evaluating model...")
 eval_results = trainer.evaluate()
 print(f"Evaluation results: {eval_results}")
 
 
-# Save the trained model
-model.save_pretrained('dishTV_bert_model')
-tokenizer.save_pretrained('dishTV_bert_model')
 
-# Testing the model with an example
-def predict(text):
-    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
-    outputs = model(**inputs)
-    prediction = torch.argmax(outputs.logits, dim=-1)
-    return prediction.item()
+# Define a new conversation for testing
+new_conversation = ["Hello! How can I assist you today? I just wanted to check the status of my account."]
+
+# Tokenize the new conversation
+test_encodings = tokenizer(new_conversation, truncation=True, padding=True, max_length=512, return_tensors='pt')
+
+# Make predictions
+with torch.no_grad():
+    model.eval()
+    outputs = model(**test_encodings)
+    predictions = torch.sigmoid(outputs.logits).cpu().numpy()  # Sigmoid for multi-label classification
+
+# Display predictions
+print(f"Predictions (Rule Followed, Question Asked, Question Answered): {predictions}")
+
+
+# Round predictions (since we are doing binary classification for each label)
+predictions_rounded = np.round(predictions)
 
-# Example test
-test_text = "Hello! I need help with my DishTV subscription."
-prediction = predict(test_text)
-predicted_compliance = "Compliant" if prediction == 1 else "Non-Compliant"
-print(f"Predicted Compliance: {predicted_compliance}")
+print(f"Predictions (rounded): {predictions_rounded}")