Spaces:
Sleeping
Sleeping
| import torch | |
| import torch.nn as nn | |
| import torch.optim as optim | |
| from torch.utils.data import Dataset, DataLoader | |
| from transformers import BertTokenizer, BertForSequenceClassification | |
| from datasets import load_dataset | |
| from tqdm import tqdm | |
| from sklearn.metrics import accuracy_score, precision_recall_fscore_support | |
| # Check for CUDA | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| print(device) | |
| # Load CLINC-OOS Dataset (Correct Config) | |
| dataset = load_dataset("clinc_oos", "plus") | |
| # Tokenizer | |
| tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") | |
| # Preprocess Dataset | |
| class IntentDataset(Dataset): | |
| def __init__(self, dataset_split): | |
| self.texts = dataset_split["text"] | |
| self.labels = dataset_split["intent"] | |
| self.label_map = {label: i for i, label in enumerate(set(self.labels))} # Create label mapping | |
| def __len__(self): | |
| return len(self.texts) | |
| def __getitem__(self, idx): | |
| inputs = tokenizer(self.texts[idx], padding="max_length", truncation=True, max_length=64, return_tensors="pt") | |
| label = self.labels[idx] | |
| if label not in self.label_map: | |
| raise ValueError(f"Unexpected label {label} found in dataset") # Debugging step | |
| return {key: val.squeeze(0) for key, val in inputs.items()}, torch.tensor(self.label_map[label]) | |
| # Create Dataloaders | |
| batch_size = 16 | |
| train_dataset = IntentDataset(dataset["train"]) | |
| test_dataset = IntentDataset(dataset["test"]) | |
| train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) | |
| test_loader = DataLoader(test_dataset, batch_size=batch_size) | |
| # Load Pretrained BERT Model | |
| num_labels = len(set(dataset["train"]["intent"])) | |
| model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels).to(device) | |
| # Loss & Optimizer | |
| criterion = nn.CrossEntropyLoss() | |
| optimizer = optim.AdamW(model.parameters(), lr=2e-5) | |
| # Training Loop | |
| num_epochs = 3 | |
| for epoch in range(num_epochs): | |
| model.train() | |
| total_loss = 0 | |
| correct = 0 | |
| total = 0 | |
| for batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs} Training"): | |
| inputs, labels = batch | |
| inputs = {key: val.to(device) for key, val in inputs.items()} | |
| labels = labels.to(device) | |
| optimizer.zero_grad() | |
| outputs = model(**inputs).logits | |
| loss = criterion(outputs, labels) | |
| loss.backward() | |
| optimizer.step() | |
| total_loss += loss.item() | |
| correct += (outputs.argmax(dim=1) == labels).sum().item() | |
| total += labels.size(0) | |
| train_accuracy = correct / total | |
| print(f"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss:.4f}, Train Accuracy: {train_accuracy:.4f}") | |
| # Evaluation on Test Set | |
| model.eval() | |
| all_preds, all_labels = [], [] | |
| with torch.no_grad(): | |
| for batch in tqdm(test_loader, desc="Testing"): | |
| inputs, labels = batch | |
| inputs = {key: val.to(device) for key, val in inputs.items()} | |
| labels = labels.to(device) | |
| outputs = model(**inputs).logits | |
| preds = outputs.argmax(dim=1) | |
| all_preds.extend(preds.cpu().numpy()) | |
| all_labels.extend(labels.cpu().numpy()) | |
| # Compute Metrics | |
| accuracy = accuracy_score(all_labels, all_preds) | |
| precision, recall, f1, _ = precision_recall_fscore_support(all_labels, all_preds, average="weighted") | |
| print(f"Test Accuracy: {accuracy:.4f}") | |
| print(f"Precision: {precision:.4f}, Recall: {recall:.4f}, F1-score: {f1:.4f}") | |
| # Save Model | |
| torch.save(model.state_dict(), "intent_classifier.pth") | |