JNotebooks/garbage_classification_text.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from transformers import DistilBertModel, DistilBertTokenizer\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import re\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Extract text from file names as well as labels\n",
    "def read_text_files_with_labels(path):\n",
    "    texts = []\n",
    "    labels = []\n",
    "    class_folders = sorted(os.listdir(path))  # Assuming class folders are sorted\n",
    "    label_map = {class_name: idx for idx, class_name in enumerate(class_folders)}\n",
    "\n",
    "    for class_name in class_folders:\n",
    "        class_path = os.path.join(path, class_name)\n",
    "        if os.path.isdir(class_path):\n",
    "            file_names = os.listdir(class_path)\n",
    "            for file_name in file_names:\n",
    "                file_path = os.path.join(class_path, file_name)\n",
    "                if os.path.isfile(file_path):\n",
    "                    file_name_no_ext, _ = os.path.splitext(file_name)\n",
    "                    text = file_name_no_ext.replace('_', ' ')\n",
    "                    text_without_digits = re.sub(r'\\d+', '', text)\n",
    "                    texts.append(text_without_digits)\n",
    "                    labels.append(label_map[class_name])\n",
    "\n",
    "    return np.array(texts), np.array(labels)\n",
    "\n",
    "# Define your dataset class\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, texts, labels, tokenizer, max_len):\n",
    "        self.texts = texts\n",
    "        self.labels = labels\n",
    "        self.tokenizer = tokenizer\n",
    "        self.max_len = max_len\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        text = str(self.texts[idx])\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        encoding = self.tokenizer.encode_plus(\n",
    "            text,\n",
    "            add_special_tokens=True,\n",
    "            max_length=self.max_len,\n",
    "            return_token_type_ids=False,\n",
    "            padding='max_length',\n",
    "            truncation=True,\n",
    "            return_attention_mask=True,\n",
    "            return_tensors='pt'\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            'text': text,\n",
    "            'input_ids': encoding['input_ids'].flatten(),\n",
    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
    "            'label': torch.tensor(label, dtype=torch.long)\n",
    "        }\n",
    "\n",
    "# Define the model\n",
    "class DistilBERTClassifier(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super(DistilBERTClassifier, self).__init__()\n",
    "        self.distilbert = DistilBertModel.from_pretrained('distilbert-base-uncased')\n",
    "        self.drop = nn.Dropout(0.3)\n",
    "        self.out = nn.Linear(self.distilbert.config.hidden_size, num_classes)\n",
    "\n",
    "    def forward(self, input_ids, attention_mask):\n",
    "        pooled_output = self.distilbert(input_ids=input_ids, attention_mask=attention_mask)[0]\n",
    "        output = self.drop(pooled_output[:,0])\n",
    "        return self.out(output)\n",
    "\n",
    "# Define training function\n",
    "def train(model, iterator, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    for batch in iterator:\n",
    "        input_ids = batch['input_ids'].to(device)\n",
    "        attention_mask = batch['attention_mask'].to(device)\n",
    "        labels = batch['label'].to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        output = model(input_ids, attention_mask)\n",
    "        loss = criterion(output, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        total_loss += loss.item()\n",
    "\n",
    "    return total_loss / len(iterator)\n",
    "\n",
    "# Define evaluation function\n",
    "def evaluate(model, iterator, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss = 0\n",
    "    with torch.no_grad():\n",
    "        for batch in iterator:\n",
    "            input_ids = batch['input_ids'].to(device)\n",
    "            attention_mask = batch['attention_mask'].to(device)\n",
    "            labels = batch['label'].to(device)\n",
    "\n",
    "            output = model(input_ids, attention_mask)\n",
    "            loss = criterion(output, labels)\n",
    "\n",
    "            total_loss += loss.item()\n",
    "\n",
    "    return total_loss / len(iterator)\n",
    "\n",
    "def predict(model, dataloader, device):\n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "    predictions = []\n",
    "    with torch.no_grad():  # Disable gradient tracking\n",
    "        for batch in dataloader:\n",
    "            input_ids = batch['input_ids'].to(device)  # Assuming input_ids are in the batch\n",
    "            attention_mask = batch['attention_mask'].to(device)  # Assuming attention_mask is in the batch\n",
    "\n",
    "            # Forward pass\n",
    "            outputs = model(input_ids, attention_mask)\n",
    "\n",
    "            # Get predictions\n",
    "            _, preds = torch.max(outputs, dim=1)\n",
    "\n",
    "            # Convert predictions to CPU and append to the list\n",
    "            predictions.extend(preds.cpu().numpy())\n",
    "\n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8000,)\n",
      "(8000,)\n",
      "(2000,)\n",
      "(2000,)\n",
      "(2000,)\n",
      "(2000,)\n"
     ]
    }
   ],
   "source": [
    "TRAIN_PATH = r\"C:\\Users\\rober\\OneDrive - University of Calgary\\Projects\\Garbage-classification\\CVPR_2024_dataset\\CVPR_2024_dataset\\Train\"\n",
    "VAL_PATH = r\"C:\\Users\\rober\\OneDrive - University of Calgary\\Projects\\Garbage-classification\\CVPR_2024_dataset\\CVPR_2024_dataset\\Validation\"\n",
    "TEST_PATH = r\"C:\\Users\\rober\\OneDrive - University of Calgary\\Projects\\Garbage-classification\\CVPR_2024_dataset\\CVPR_2024_dataset\\Test\"\n",
    "\n",
    "text_train,labels_train = read_text_files_with_labels(TRAIN_PATH)\n",
    "text_val,labels_val = read_text_files_with_labels(VAL_PATH)\n",
    "text_test,labels_test = read_text_files_with_labels(TEST_PATH)\n",
    "\n",
    "print(text_train.shape)\n",
    "print(labels_train.shape)\n",
    "print(text_val.shape)\n",
    "print(labels_val.shape)\n",
    "print(text_test.shape)\n",
    "print(labels_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Train Loss: 0.4661\n",
      "Epoch: 1, Val Loss: 0.3410\n",
      "Epoch: 2, Train Loss: 0.2729\n",
      "Epoch: 2, Val Loss: 0.3218\n",
      "Epoch: 3, Train Loss: 0.2007\n",
      "Epoch: 3, Val Loss: 0.3284\n",
      "Epoch: 4, Train Loss: 0.1615\n",
      "Epoch: 4, Val Loss: 0.3347\n",
      "Epoch: 5, Train Loss: 0.1355\n",
      "Epoch: 5, Val Loss: 0.3811\n",
      "Epoch: 6, Train Loss: 0.1153\n",
      "Epoch: 6, Val Loss: 0.3882\n",
      "Epoch: 7, Train Loss: 0.1095\n",
      "Epoch: 7, Val Loss: 0.3985\n",
      "Epoch: 8, Train Loss: 0.0959\n",
      "Epoch: 8, Val Loss: 0.4029\n",
      "Epoch: 9, Train Loss: 0.0874\n",
      "Epoch: 9, Val Loss: 0.4183\n",
      "Epoch: 10, Train Loss: 0.0833\n",
      "Epoch: 10, Val Loss: 0.4646\n"
     ]
    }
   ],
   "source": [
    "# Tokenizer\n",
    "tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')\n",
    "\n",
    "# Tokenize data\n",
    "max_len = 128\n",
    "dataset_train = CustomDataset(text_train, labels_train, tokenizer, max_len)\n",
    "dataset_val = CustomDataset(text_val, labels_val, tokenizer, max_len)\n",
    "dataset_test = CustomDataset(text_test, labels_test, tokenizer, max_len)\n",
    "\n",
    "# Data loaders\n",
    "train_loader = DataLoader(dataset_train, batch_size=8, shuffle=True)\n",
    "val_loader = DataLoader(dataset_val, batch_size=8, shuffle=True)\n",
    "test_loader = DataLoader(dataset_test, batch_size=8, shuffle=False)\n",
    "\n",
    "best_loss = 1e+10 # best loss tracker\n",
    "EPOCHS = 10\n",
    "\n",
    "# Model\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = DistilBERTClassifier(num_classes=4).to(device)\n",
    "\n",
    "# Training parameters\n",
    "optimizer = optim.Adam(model.parameters(), lr=2e-5)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Training loop\n",
    "for epoch in range(EPOCHS):\n",
    "    train_loss = train(model, train_loader, optimizer, criterion, device)\n",
    "    print(f'Epoch: {epoch+1}, Train Loss: {train_loss:.4f}')\n",
    "    val_loss = evaluate(model, val_loader, criterion, device)\n",
    "    print(f'Epoch: {epoch+1}, Val Loss: {val_loss:.4f}')\n",
    "    if val_loss < best_loss:\n",
    "        torch.save(model.state_dict(), 'best_model.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.8990\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('best_model.pth'))\n",
    "# Evaluation\n",
    "test_predictions = predict(model, test_loader, device)\n",
    "print(f\"Accuracy:  {(test_predictions == labels_test).sum()/labels_test.size:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(labels_test, test_predictions)\n",
    "\n",
    "# Plot confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, cmap='Blues', fmt='g', cbar=False)\n",
    "\n",
    "plt.title('Confusion Matrix')\n",
    "plt.xlabel('Predicted Labels')\n",
    "plt.ylabel('True Labels')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch2023",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}