ANLP_WS24_CA2/cnn_class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN 1b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datensatz laden und DatenLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definiere die Dataset-Klasse\n",
    "class HumorDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        input_ids = torch.tensor(np.array(self.data[index][\"input_ids\"]), dtype=torch.float32)  # (seq_len, embedding_dim)\n",
    "        label = torch.tensor([self.data[index][\"labels\"]], dtype=torch.float32)  # (1,)\n",
    "        return input_ids, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "# Lade die vorbereiteten Daten\n",
    "train_data = torch.load(data_path + '/train.pt', weights_only=False)\n",
    "val_data = torch.load(data_path + '/val.pt', weights_only=False)\n",
    "test_data = torch.load(data_path + '/test.pt', weights_only=False)\n",
    "\n",
    "train_dataset = HumorDataset(train_data)\n",
    "val_dataset = HumorDataset(val_data)\n",
    "test_dataset = HumorDataset(test_data)\n",
    "\n",
    "# DataLoader erstellen\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)\n",
    "\n",
    "# Ableitung der Dimensionen aus den Daten\n",
    "sample_input, _ = train_dataset[0]  # Extrahiere input_ids\n",
    "seq_len, embedding_dim = sample_input.shape\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### CNN-Modell definieren\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single-Kernel CNN-Modell\n",
    "class SingleKernelCNN(nn.Module):\n",
    "    def __init__(self, embedding_dim, num_classes=1, kernel_size=5, num_filters=100, dropout=0.5, use_highway=True):\n",
    "        super(SingleKernelCNN, self).__init__()\n",
    "        # Convolutional Layer mit Kernel \n",
    "        self.conv = nn.Conv2d(1, num_filters, (kernel_size, embedding_dim))\n",
    "        \n",
    "        # Optional Highway Layer\n",
    "        self.use_highway = use_highway\n",
    "        if self.use_highway:\n",
    "            self.highway = nn.Linear(num_filters, num_filters)\n",
    "        \n",
    "        # Fully Connected Layer\n",
    "        self.fc = nn.Linear(num_filters, num_classes)\n",
    "        \n",
    "        # Dropout zur Regularisierung\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Eingabe x-Form: (batch_size, seq_len, embedding_dim)\n",
    "        x = x.unsqueeze(1)  # Füge Kanaldimension hinzu: (batch_size, 1, seq_len, embedding_dim)\n",
    "        \n",
    "        # Convolution + ReLU\n",
    "        x = F.relu(self.conv(x).squeeze(3))  # Entferne die letzte Dimension nach der Convolution\n",
    "        \n",
    "        # Max Pooling über die Sequenzlänge\n",
    "        x = F.max_pool1d(x, x.size(2)).squeeze(2)  # Reduziere auf (batch_size, num_filters)\n",
    "        \n",
    "        # Optionaler Highway-Mechanismus\n",
    "        if self.use_highway:\n",
    "            highway_gate = torch.sigmoid(self.highway(x))\n",
    "            x = highway_gate * F.relu(self.highway(x)) + (1 - highway_gate) * x\n",
    "        \n",
    "        # Dropout zur Regularisierung\n",
    "        x = self.dropout(x)\n",
    "        \n",
    "        # Fully Connected Layer für die Ausgabe\n",
    "        logits = self.fc(x)\n",
    "        return torch.sigmoid(logits)  # Binäre Klassifikation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Training des Modells\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/michellegoppinger/.pyenv/versions/3.12.3/lib/python3.12/site-packages/torch/optim/lr_scheduler.py:62: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/30: 100%|██████████| 124/124 [00:23<00:00,  5.22batch/s, loss=0.705]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Train Loss: 0.6845, Val Loss: 0.6565\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/30: 100%|██████████| 124/124 [00:23<00:00,  5.30batch/s, loss=0.728]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2, Train Loss: 0.6486, Val Loss: 0.6301\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/30: 100%|██████████| 124/124 [00:23<00:00,  5.24batch/s, loss=0.513]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3, Train Loss: 0.6193, Val Loss: 0.6441\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/30: 100%|██████████| 124/124 [00:23<00:00,  5.29batch/s, loss=0.53] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4, Train Loss: 0.5953, Val Loss: 0.6143\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/30: 100%|██████████| 124/124 [00:24<00:00,  5.11batch/s, loss=0.391]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5, Train Loss: 0.5613, Val Loss: 0.6189\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/30: 100%|██████████| 124/124 [00:23<00:00,  5.25batch/s, loss=0.435]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6, Train Loss: 0.5350, Val Loss: 0.6127\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/30: 100%|██████████| 124/124 [00:23<00:00,  5.29batch/s, loss=0.595]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7, Train Loss: 0.5055, Val Loss: 0.6162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/30: 100%|██████████| 124/124 [00:23<00:00,  5.27batch/s, loss=0.313]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8, Train Loss: 0.4654, Val Loss: 0.6668\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9/30: 100%|██████████| 124/124 [00:23<00:00,  5.26batch/s, loss=0.438]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9, Train Loss: 0.4299, Val Loss: 0.6240\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10/30: 100%|██████████| 124/124 [00:23<00:00,  5.23batch/s, loss=0.561]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10, Train Loss: 0.3863, Val Loss: 0.6328\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11/30: 100%|██████████| 124/124 [00:23<00:00,  5.28batch/s, loss=0.321]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11, Train Loss: 0.3553, Val Loss: 0.6676\n",
      "Early Stopping ausgelöst!\n"
     ]
    }
   ],
   "source": [
    "# Geräteauswahl: MPS (für macOS), CUDA (GPU), oder CPU\n",
    "if torch.backends.mps.is_available():\n",
    "    device = torch.device(\"mps\")  # Apple MPS für macOS\n",
    "elif torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")  # NVIDIA CUDA\n",
    "else:\n",
    "    device = torch.device(\"cpu\")  # Fallback auf CPU\n",
    "\n",
    "# Initialisiere das Modell\n",
    "model = SingleKernelCNN(embedding_dim=embedding_dim, num_classes=1, kernel_size=5, num_filters=100, dropout=0.5, use_highway=False).to(device)\n",
    "\n",
    "# Verlustfunktion und Optimierer\n",
    "criterion = nn.BCELoss()  # Binary Cross Entropy Loss\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)  \n",
    "\n",
    "# Lernraten-Scheduler\n",
    "scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2, verbose=True)\n",
    "\n",
    "# Trainingseinstellungen\n",
    "epochs = 30  # Maximalanzahl an Epochen\n",
    "best_val_loss = float('inf')\n",
    "patience = 5  # Geduld für Early Stopping\n",
    "counter = 0\n",
    "\n",
    "\n",
    "# Liste zum Speichern der Trainingsverluste\n",
    "train_losses = []\n",
    "\n",
    "# Training und Validierung\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    with tqdm(train_loader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n",
    "        for texts, labels in train_loader:\n",
    "            texts, labels = texts.to(device), labels.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(texts)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            total_loss += loss.item()\n",
    "            tepoch.update(1)\n",
    "            tepoch.set_postfix(loss=loss.item())\n",
    "    \n",
    "    avg_train_loss = total_loss / len(train_loader)\n",
    "    train_losses.append(avg_train_loss)  # Speichere den Trainingsverlust\n",
    "    \n",
    "    # Validierung\n",
    "    model.eval()\n",
    "    val_loss = 0\n",
    "    with torch.no_grad():\n",
    "        for texts, labels in val_loader:\n",
    "            texts, labels = texts.to(device), labels.to(device)\n",
    "            outputs = model(texts)\n",
    "            loss = criterion(outputs, labels)\n",
    "            val_loss += loss.item()\n",
    "    \n",
    "    avg_val_loss = val_loss / len(val_loader)\n",
    "    scheduler.step(avg_val_loss)\n",
    "\n",
    "    print(f\"Epoch {epoch+1}, Train Loss: {avg_train_loss:.4f}, Val Loss: {avg_val_loss:.4f}\")\n",
    "\n",
    "    # Early Stopping\n",
    "    if avg_val_loss < best_val_loss:\n",
    "        best_val_loss = avg_val_loss\n",
    "        counter = 0\n",
    "        torch.save(model.state_dict(), \"best_model.pth\")\n",
    "    else:\n",
    "        counter += 1\n",
    "        if counter >= patience:\n",
    "            print(\"Early Stopping ausgelöst!\")\n",
    "            break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trainingsverlust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot: Trainingsverlust über die Epochen\n",
    "plt.figure(figsize=(8, 5))\n",
    "plt.plot(range(1, len(train_losses) + 1), train_losses, label=\"Trainingsverlust\", marker='o')\n",
    "plt.xlabel(\"Epochen\")\n",
    "plt.ylabel(\"Verlust\")\n",
    "plt.title(\"Trainingsverlust über die Epochen\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Finale Evaluierung & Confusion Matrix\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_5620/1822405546.py:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"best_model.pth\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🚀 Finale Test Accuracy: 0.6518\n",
      "🚀 Finale Test F1 Score: 0.6993\n"
     ]
    }
   ],
   "source": [
    "# Testen des Modells\n",
    "model.load_state_dict(torch.load(\"best_model.pth\"))\n",
    "model.eval()\n",
    "all_preds = []\n",
    "all_labels = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    for texts, labels in test_loader:\n",
    "        texts, labels = texts.to(device), labels.to(device)\n",
    "        outputs = model(texts)\n",
    "        predictions = (outputs > 0.5).float()\n",
    "        all_preds.extend(predictions.cpu().numpy())\n",
    "        all_labels.extend(labels.cpu().numpy())\n",
    "\n",
    "all_preds = [int(p[0]) for p in all_preds]\n",
    "all_labels = [int(l[0]) for l in all_labels]\n",
    "\n",
    "# Test-Accuracy und F1-Score berechnen\n",
    "accuracy = accuracy_score(all_labels, all_preds)\n",
    "f1 = f1_score(all_labels, all_preds)\n",
    "\n",
    "print(f'🚀 Finale Test Accuracy: {accuracy:.4f}')\n",
    "print(f'🚀 Finale Test F1 Score: {f1:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konfusionsmatrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Konfusionsmatrix visualisieren\n",
    "conf_matrix = confusion_matrix(all_labels, all_preds)\n",
    "\n",
    "plt.figure(figsize=(6,5))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap=\"Blues\", xticklabels=['No Humor', 'Humor'], yticklabels=['No Humor', 'Humor'])\n",
    "plt.xlabel(\"Predicted Label\")\n",
    "plt.ylabel(\"True Label\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}