From f493d9e4290a20a85d40371c8a44530015ca0103 Mon Sep 17 00:00:00 2001
From: Michelle Goeppinger <michelle290999@gmail.com>
Date: Tue, 11 Feb 2025 23:27:46 +0100
Subject: [PATCH] added CNN Reg

---
 cnn_1b.ipynb    | 373 -----------------------------
 cnn_class.ipynb | 539 +++++++++++++++++++++++++++++++++++++++++
 cnn_reg.ipynb   | 618 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1157 insertions(+), 373 deletions(-)
 delete mode 100644 cnn_1b.ipynb
 create mode 100644 cnn_class.ipynb
 create mode 100644 cnn_reg.ipynb

diff --git a/cnn_1b.ipynb b/cnn_1b.ipynb
deleted file mode 100644
index aca2ff1..0000000
--- a/cnn_1b.ipynb
+++ /dev/null
@@ -1,373 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## CNN 1b"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Load Packages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "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 matplotlib.pyplot as plt\n",
-    "import seaborn as sns"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Datensatz laden und DatenLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_32265/1764171208.py:5: 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",
-      "  train_dataset = torch.load(data_path + '/train.pt')\n",
-      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_32265/1764171208.py:6: 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",
-      "  test_dataset = torch.load(data_path + '/test.pt')\n",
-      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_32265/1764171208.py:7: 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",
-      "  val_dataset = torch.load(data_path + '/val.pt')\n"
-     ]
-    }
-   ],
-   "source": [
-    "data_path = 'data/embedded_padded'\n",
-    "\n",
-    "BATCH_SIZE = 32\n",
-    "\n",
-    "train_dataset = torch.load(data_path + '/train.pt')\n",
-    "test_dataset = torch.load(data_path + '/test.pt')\n",
-    "val_dataset = torch.load(data_path + '/val.pt')\n",
-    "\n",
-    "# DataLoader vorbereiten\n",
-    "\n",
-    "\n",
-    "def collate_fn(batch):\n",
-    "    input_ids = torch.stack([item[\"input_ids\"] for item in batch])  \n",
-    "    labels = torch.tensor([item[\"labels\"] for item in batch], dtype=torch.float32).unsqueeze(1)  \n",
-    "    return input_ids, labels\n",
-    "\n",
-    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)\n",
-    "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n",
-    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### CNN-Modell definieren\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class HumorCNN(nn.Module):\n",
-    "    def __init__(self, embedding_dim=100):\n",
-    "        super(HumorCNN, self).__init__()\n",
-    "\n",
-    "        self.conv1 = nn.Conv2d(1, 50, (3, embedding_dim))\n",
-    "        self.conv2 = nn.Conv2d(1, 50, (4, embedding_dim))\n",
-    "        self.conv3 = nn.Conv2d(1, 50, (5, embedding_dim))\n",
-    "\n",
-    "        self.bn1 = nn.BatchNorm1d(50)\n",
-    "        self.bn2 = nn.BatchNorm1d(50)\n",
-    "        self.bn3 = nn.BatchNorm1d(50)\n",
-    "\n",
-    "        self.fc = nn.Linear(150, 1)\n",
-    "\n",
-    "        self.dropout = nn.Dropout(0.5)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        x = x.unsqueeze(1)  \n",
-    "\n",
-    "        x1 = F.relu(self.bn1(self.conv1(x).squeeze(3)))\n",
-    "        x2 = F.relu(self.bn2(self.conv2(x).squeeze(3)))\n",
-    "        x3 = F.relu(self.bn3(self.conv3(x).squeeze(3)))\n",
-    "        \n",
-    "        x1 = F.max_pool1d(x1, x1.size(2)).squeeze(2)\n",
-    "        x2 = F.max_pool1d(x2, x2.size(2)).squeeze(2)\n",
-    "        x3 = F.max_pool1d(x3, x3.size(2)).squeeze(2)\n",
-    "\n",
-    "        x = torch.cat((x1, x2, x3), 1)\n",
-    "        \n",
-    "        x = self.dropout(x)\n",
-    "        x = self.fc(x)\n",
-    "        return torch.sigmoid(x)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "### Training des Modells\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "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",
-      "/Users/michellegoppinger/Documents/Dokumente – Laptop von Michelle/Uni/Master/ANLP/CA2/ANLP_WS24_CA2/HumorDataset.py:21: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/utils/tensor_new.cpp:281.)\n",
-      "  item = {'input_ids': torch.tensor(self.data[idx], dtype=torch.float)}\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/10, Train Loss: 1.0778, Val Loss: 0.6097, Test Acc: 0.6734, Test F1: 0.6567\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.6734279918864098\n",
-      "Epoch 2/10, Train Loss: 0.7699, Val Loss: 0.5868, Test Acc: 0.7069, Test F1: 0.7175\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.7068965517241379\n",
-      "Epoch 3/10, Train Loss: 0.6620, Val Loss: 0.5702, Test Acc: 0.7373, Test F1: 0.7566\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.7373225152129818\n",
-      "Epoch 4/10, Train Loss: 0.6219, Val Loss: 0.5475, Test Acc: 0.7556, Test F1: 0.7692\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.755578093306288\n",
-      "Epoch 5/10, Train Loss: 0.6035, Val Loss: 0.5171, Test Acc: 0.7769, Test F1: 0.7804\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.7768762677484787\n",
-      "Epoch 6/10, Train Loss: 0.5956, Val Loss: 0.5026, Test Acc: 0.7926, Test F1: 0.8111\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.7925963488843814\n",
-      "Epoch 7/10, Train Loss: 0.5601, Val Loss: 0.4781, Test Acc: 0.8119, Test F1: 0.7978\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.8118661257606491\n",
-      "Epoch 8/10, Train Loss: 0.5375, Val Loss: 0.4429, Test Acc: 0.8281, Test F1: 0.8433\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.8280933062880325\n",
-      "Epoch 9/10, Train Loss: 0.5281, Val Loss: 0.4177, Test Acc: 0.8773, Test F1: 0.8818\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.8772819472616633\n",
-      "Epoch 10/10, Train Loss: 0.5041, Val Loss: 0.3977, Test Acc: 0.8813, Test F1: 0.8741\n",
-      "🚀 Bestes Modell gespeichert mit Test-Accuracy: 0.8813387423935092\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Automatische Geräteauswahl (Apple MPS, CUDA, CPU)\n",
-    "if torch.backends.mps.is_available():\n",
-    "    device = torch.device(\"mps\")  \n",
-    "elif torch.cuda.is_available():\n",
-    "    device = torch.device(\"cuda\")  \n",
-    "else:\n",
-    "    device = torch.device(\"cpu\")  \n",
-    "\n",
-    "model = HumorCNN().to(device)\n",
-    "\n",
-    "criterion = nn.BCELoss()\n",
-    "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)  \n",
-    "\n",
-    "scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2, verbose=True)  \n",
-    "\n",
-    "epochs = 10  # Nur 10 Epochen\n",
-    "best_val_loss = float('inf')\n",
-    "best_test_accuracy = 0\n",
-    "patience = 3\n",
-    "counter = 0\n",
-    "\n",
-    "for epoch in range(epochs):\n",
-    "    model.train()\n",
-    "    total_loss = 0\n",
-    "\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",
-    "    \n",
-    "    avg_train_loss = total_loss / len(train_loader)\n",
-    "\n",
-    "    # ========================\n",
-    "    # Validierung\n",
-    "    # ========================\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",
-    "\n",
-    "    # ========================\n",
-    "    # Evaluierung mit Testdaten\n",
-    "    # ========================\n",
-    "    test_preds = []\n",
-    "    test_labels = []\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",
-    "            test_preds.extend(predictions.cpu().numpy())\n",
-    "            test_labels.extend(labels.cpu().numpy())\n",
-    "\n",
-    "    test_accuracy = accuracy_score(test_labels, test_preds)\n",
-    "    test_f1 = f1_score(test_labels, test_preds)\n",
-    "\n",
-    "    print(f'Epoch {epoch+1}/{epochs}, Train Loss: {avg_train_loss:.4f}, Val Loss: {avg_val_loss:.4f}, Test Acc: {test_accuracy:.4f}, Test F1: {test_f1:.4f}')\n",
-    "    \n",
-    "    # ========================\n",
-    "    # Lernraten-Anpassung\n",
-    "    # ========================\n",
-    "    scheduler.step(avg_val_loss)\n",
-    "\n",
-    "    # ========================\n",
-    "    # Bestes Modell speichern\n",
-    "    # ========================\n",
-    "    if test_accuracy > best_test_accuracy:\n",
-    "        best_test_accuracy = test_accuracy\n",
-    "        torch.save(model.state_dict(), \"best_model.pth\")\n",
-    "        print(\"🚀 Bestes Modell gespeichert mit Test-Accuracy:\", test_accuracy)\n",
-    "\n",
-    "    # ========================\n",
-    "    # Early Stopping\n",
-    "    # ========================\n",
-    "    if avg_val_loss < best_val_loss:\n",
-    "        best_val_loss = avg_val_loss\n",
-    "        counter = 0\n",
-    "    else:\n",
-    "        counter += 1\n",
-    "        if counter >= patience:\n",
-    "            print(\"Early Stopping ausgelöst!\")\n",
-    "            break\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### Finale Evaluierung & Confusion Matrix\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_32265/3375079771.py:1: 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.8813\n",
-      "🚀 Finale Test F1 Score: 0.8741\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "model.load_state_dict(torch.load(\"best_model.pth\"))  \n",
-    "model.eval()\n",
-    "\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",
-    "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}')\n",
-    "\n",
-    "# Confusion Matrix\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()"
-   ]
-  }
- ],
- "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
-}
diff --git a/cnn_class.ipynb b/cnn_class.ipynb
new file mode 100644
index 0000000..7b5f2e0
--- /dev/null
+++ b/cnn_class.ipynb
@@ -0,0 +1,539 @@
+{
+ "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
+}
diff --git a/cnn_reg.ipynb b/cnn_reg.ipynb
new file mode 100644
index 0000000..b2d4225
--- /dev/null
+++ b/cnn_reg.ipynb
@@ -0,0 +1,618 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CNN Regression"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.data import DataLoader\n",
+    "from tqdm import tqdm  # Fortschrittsbalken\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:6: 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",
+      "  train_dataset = torch.load(data_path + '/train.pt')\n",
+      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:7: 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",
+      "  test_dataset = torch.load(data_path + '/test.pt')\n",
+      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:8: 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",
+      "  val_dataset = torch.load(data_path + '/val.pt')\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Daten laden\n",
+    "\n",
+    "data_path = 'data/embedded_padded'\n",
+    "BATCH_SIZE = 32\n",
+    "\n",
+    "train_dataset = torch.load(data_path + '/train.pt')\n",
+    "test_dataset = torch.load(data_path + '/test.pt')\n",
+    "val_dataset = torch.load(data_path + '/val.pt')\n",
+    "\n",
+    "# DataLoader vorbereiten\n",
+    "def collate_fn(batch):\n",
+    "    input_ids = torch.stack([item[\"input_ids\"] for item in batch])  \n",
+    "    labels = torch.tensor([item[\"labels\"] for item in batch], dtype=torch.float32).unsqueeze(1)  \n",
+    "    return input_ids, labels\n",
+    "\n",
+    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)\n",
+    "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n",
+    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/michellegoppinger/Documents/Dokumente – Laptop von Michelle/Uni/Master/ANLP/ANLP_WS24_CA2/HumorDataset.py:56: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/utils/tensor_new.cpp:281.)\n",
+      "  item = {'input_ids': torch.tensor(self.data[idx], dtype=torch.float)}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Labels extrahieren und in eine Liste konvertieren\n",
+    "train_labels = [item[\"labels\"].item() for item in train_dataset]  \n",
+    "\n",
+    "# Verteilung der Labels visualisieren\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.histplot(train_labels, bins=20)\n",
+    "plt.xlabel(\"Humor Scores\")\n",
+    "plt.ylabel(\"Frequency\")\n",
+    "plt.title(\"Verteilung der Trainingslabels\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class WeightedMSELoss(nn.Module):\n",
+    "    def __init__(self, weights):\n",
+    "        super(WeightedMSELoss, self).__init__()\n",
+    "        self.weights = weights\n",
+    "\n",
+    "    def forward(self, inputs, targets):\n",
+    "        weights = self.weights[targets.long()]\n",
+    "        loss = weights * (inputs - targets) ** 2\n",
+    "        return loss.mean()\n",
+    "\n",
+    "# Gewichtung basierend auf Seltenheit der Zwischenwerte\n",
+    "weights = torch.tensor([2.0 if 0.2 <= x <= 0.8 else 1.0 for x in range(2)], dtype=torch.float32)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CNN_HumorRegressor(nn.Module):\n",
+    "    def __init__(self, embed_dim, filter_sizes, num_filters, dropout=0.5):\n",
+    "        super(CNN_HumorRegressor, self).__init__()\n",
+    "\n",
+    "        # Convolutional Layers mit verschiedenen Filtergrößen\n",
+    "        self.convs = nn.ModuleList([\n",
+    "            nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) \n",
+    "            for fs in filter_sizes\n",
+    "        ])\n",
+    "\n",
+    "        # Highway-Netzwerk für bessere Feature-Extraktion\n",
+    "        self.highway = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters)\n",
+    "\n",
+    "        # Dropout zur Vermeidung von Overfitting\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "\n",
+    "        # Fully Connected Layers\n",
+    "        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 256)\n",
+    "        self.fc2 = nn.Linear(256, 128)\n",
+    "        self.fc3 = nn.Linear(128, 1)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x.unsqueeze(1)  # [Batch Size, 1, Seq Length, Embed Dim]\n",
+    "\n",
+    "        # Convolution + ReLU activation\n",
+    "        conved = [F.relu(conv(x)).squeeze(3) for conv in self.convs]\n",
+    "\n",
+    "        # Max-Pooling über jede Feature-Map\n",
+    "        pooled = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in conved]\n",
+    "\n",
+    "        # Feature-Vektor kombinieren\n",
+    "        cat = torch.cat(pooled, dim=1)\n",
+    "\n",
+    "        # Highway-Netzwerk\n",
+    "        highway = F.relu(self.highway(cat))\n",
+    "        highway = self.dropout(highway + cat)\n",
+    "\n",
+    "        # Fully Connected Layers\n",
+    "        fc_out = F.relu(self.fc1(highway))\n",
+    "        fc_out = F.relu(self.fc2(fc_out))\n",
+    "        return torch.sigmoid(self.fc3(fc_out))  # Sigmoid für Wertebereich [0, 1]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EMBED_DIM = train_dataset[0][\"input_ids\"].shape[1]\n",
+    "FILTER_SIZES = [2, 3, 4, 5]\n",
+    "NUM_FILTERS = 300\n",
+    "DROPOUT = 0.5\n",
+    "LR = 0.001\n",
+    "EPOCHS = 10\n",
+    "\n",
+    "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# Modell initialisieren\n",
+    "model = CNN_HumorRegressor(EMBED_DIM, FILTER_SIZES, NUM_FILTERS, DROPOUT).to(device)\n",
+    "\n",
+    "# Gewichtete Verlustfunktion und Optimierer\n",
+    "criterion = WeightedMSELoss(weights.to(device))\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=LR)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train_model(model, train_loader, val_loader, criterion, optimizer, epochs, device):\n",
+    "    for epoch in range(epochs):\n",
+    "        model.train()\n",
+    "        total_loss = 0\n",
+    "\n",
+    "        # Fortschrittsbalken für das Training\n",
+    "        with tqdm(train_loader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n",
+    "            for inputs, labels in tepoch:\n",
+    "                inputs, labels = inputs.to(device), labels.to(device)\n",
+    "\n",
+    "                optimizer.zero_grad()\n",
+    "                outputs = model(inputs)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                loss.backward()\n",
+    "                optimizer.step()\n",
+    "\n",
+    "                total_loss += loss.item()\n",
+    "                tepoch.set_postfix(loss=loss.item())\n",
+    "\n",
+    "        val_loss = evaluate(model, val_loader, criterion, device)\n",
+    "        print(f\"Epoch {epoch+1}/{epochs} - Train Loss: {total_loss:.4f} - Val Loss: {val_loss:.4f}\")\n",
+    "\n",
+    "def evaluate(model, test_loader, criterion, device):\n",
+    "    model.eval()\n",
+    "    total_loss = 0\n",
+    "    with tqdm(test_loader, unit=\"batch\", desc=\"Evaluating\") as tepoch:\n",
+    "        with torch.no_grad():\n",
+    "            for inputs, labels in tepoch:\n",
+    "                inputs, labels = inputs.to(device), labels.to(device)\n",
+    "                outputs = model(inputs)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                total_loss += loss.item()\n",
+    "    return total_loss / len(test_loader)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10:   0%|          | 0/124 [00:00<?, ?batch/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10: 100%|██████████| 124/124 [00:41<00:00,  2.99batch/s, loss=0.249]\n",
+      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.09batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10 - Train Loss: 30.5479 - Val Loss: 0.2415\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/10: 100%|██████████| 124/124 [00:40<00:00,  3.08batch/s, loss=0.297]\n",
+      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.36batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/10 - Train Loss: 27.5358 - Val Loss: 0.2162\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/10: 100%|██████████| 124/124 [00:40<00:00,  3.03batch/s, loss=0.286]\n",
+      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.26batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/10 - Train Loss: 23.0742 - Val Loss: 0.2215\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/10: 100%|██████████| 124/124 [00:43<00:00,  2.83batch/s, loss=0.123] \n",
+      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.24batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/10 - Train Loss: 16.9821 - Val Loss: 0.2608\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/10: 100%|██████████| 124/124 [00:41<00:00,  3.01batch/s, loss=0.104] \n",
+      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.43batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/10 - Train Loss: 10.0560 - Val Loss: 0.2646\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/10: 100%|██████████| 124/124 [00:28<00:00,  4.34batch/s, loss=0.138]  \n",
+      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.23batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/10 - Train Loss: 9.3069 - Val Loss: 0.2535\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/10: 100%|██████████| 124/124 [00:28<00:00,  4.31batch/s, loss=0.00183]\n",
+      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.21batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/10 - Train Loss: 6.4416 - Val Loss: 0.2688\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/10: 100%|██████████| 124/124 [00:28<00:00,  4.37batch/s, loss=0.00722]\n",
+      "Evaluating: 100%|██████████| 16/16 [00:30<00:00,  1.92s/batch]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/10 - Train Loss: 4.9270 - Val Loss: 0.2915\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/10: 100%|██████████| 124/124 [00:29<00:00,  4.13batch/s, loss=0.0664]  \n",
+      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.17batch/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/10 - Train Loss: 2.8456 - Val Loss: 0.3152\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/10: 100%|██████████| 124/124 [00:27<00:00,  4.48batch/s, loss=0.0111]  \n",
+      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.12batch/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/10 - Train Loss: 2.2282 - Val Loss: 0.2945\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_model(model, train_loader, val_loader, criterion, optimizer, EPOCHS, device)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Evaluating: 100%|██████████| 16/16 [00:01<00:00,  9.59batch/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss (MSE): 0.3395\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_loss = evaluate(model, test_loader, criterion, device)\n",
+    "print(f\"Test Loss (MSE): {test_loss:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Evaluation Metrics on Test Data:\n",
+      "Mean Squared Error (MSE): 0.3358\n",
+      "Root Mean Squared Error (RMSE): 0.5795\n",
+      "Mean Absolute Error (MAE): 0.3900\n",
+      "R² Score: -0.3445\n"
+     ]
+    }
+   ],
+   "source": [
+    "def evaluate_metrics(model, test_loader, device):\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    actuals = []\n",
+    "    with torch.no_grad():\n",
+    "        for inputs, labels in test_loader:\n",
+    "            inputs, labels = inputs.to(device), labels.to(device)\n",
+    "            outputs = model(inputs)\n",
+    "            predictions.extend(outputs.cpu().numpy().flatten())\n",
+    "            actuals.extend(labels.cpu().numpy().flatten())\n",
+    "\n",
+    "    mse = mean_squared_error(actuals, predictions)\n",
+    "    rmse = np.sqrt(mse)\n",
+    "    mae = mean_absolute_error(actuals, predictions)\n",
+    "    r2 = r2_score(actuals, predictions)\n",
+    "\n",
+    "    return mse, rmse, mae, r2, actuals, predictions\n",
+    "\n",
+    "mse, rmse, mae, r2, actuals, predictions = evaluate_metrics(model, test_loader, device)\n",
+    "\n",
+    "print(\"Evaluation Metrics on Test Data:\")\n",
+    "print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n",
+    "print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n",
+    "print(f\"Mean Absolute Error (MAE): {mae:.4f}\")\n",
+    "print(f\"R² Score: {r2:.4f}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Definiere korrekte und falsche Vorhersagen basierend auf einem Schwellenwert\n",
+    "threshold = 0.5\n",
+    "predicted_labels = (np.array(predictions) > threshold).astype(int)\n",
+    "true_labels = (np.array(actuals) > threshold).astype(int)\n",
+    "\n",
+    "# Bool-Array für korrekte Vorhersagen\n",
+    "correct = predicted_labels == true_labels\n",
+    "\n",
+    "# Farben zuordnen: Grün für korrekt, Rot für falsch\n",
+    "colors = ['green' if is_correct else 'red' for is_correct in correct]\n",
+    "\n",
+    "# Scatter-Plot\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k')\n",
+    "\n",
+    "\n",
+    "# Legende anpassen\n",
+    "import matplotlib.patches as mpatches\n",
+    "green_patch = mpatches.Patch(color='green', label='Correct Predictions')\n",
+    "red_patch = mpatches.Patch(color='red', label='Incorrect Predictions')\n",
+    "plt.legend(handles=[green_patch, red_patch])\n",
+    "\n",
+    "# Achsen und Titel\n",
+    "plt.title('True vs. Predicted Humor Scores')\n",
+    "plt.xlabel('True Humor Score')\n",
+    "plt.ylabel('Predicted Humor Score')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "239\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Load the data from csv\n",
+    "df = pd.read_csv('data/hack.csv')\n",
+    "df_test = df.iloc[test_dataset.original_indices].copy()\n",
+    "df_test['prediction'] = predicted_labels\n",
+    "df_test['label'] = true_labels\n",
+    "df_test['pred_correct'] = (df_test['prediction'] == df_test['label'])\n",
+    "\n",
+    "df_test_sorted = df_test.sort_values(by='humor_rating').reset_index(drop=True)\n",
+    "\n",
+    "from matplotlib import patches as mpatches\n",
+    "\n",
+    "median_rating = df['humor_rating'].median()\n",
+    "# get first index where humor_rating is greater than median_rating\n",
+    "median_idx = df_test_sorted[df_test_sorted['humor_rating'] > median_rating].index[0]\n",
+    "print(median_idx)\n",
+    "# range idx for len df_test\n",
+    "range_idx = range(len(df_test))\n",
+    "colors = df_test_sorted['pred_correct'].map({True: 'g', False: 'r'})\n",
+    "# bar plot for each df_test humor_rating value \n",
+    "plt.bar(range_idx, df_test_sorted['humor_rating'], color=colors)\n",
+    "# vertical line for True/False cut off\n",
+    "plt.axvline(x=median_idx, color='black', linestyle='--')\n",
+    "# Create a legend handles\n",
+    "green_patch = mpatches.Patch(color='g', label='Correct Prediction')\n",
+    "red_patch = mpatches.Patch(color='r', label='Incorrect Prediction')\n",
+    "line_patch = mpatches.Patch(color='black', label='humor_rating cut off')\n",
+    "plt.title('Humor Rating vs Prediction for Test Set')\n",
+    "plt.xlabel('Index')\n",
+    "plt.ylabel('Humor Rating')\n",
+    "plt.legend(handles=[green_patch, red_patch, line_patch])\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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
+}