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": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "#lokal imports\n",
    "from dataset_generator import create_embedding_matrix, split_data, load_preprocess_data\n",
    "from HumorDataset import TextDataset\n",
    "from BalancedCELoss import BalancedCELoss\n",
    "import ml_helper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datensatz laden und DatenLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "\n",
    "best_model_filename = 'best_cnn_class_model.pt'\n",
    "#device = ml_helper.get_device(verbose=True)\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### CNN-Modell definieren\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameter und Konfigurationen\n",
    "params = {\n",
    "    \"embedding_dim\": 100,\n",
    "    \"filter_sizes\": [2, 3, 4, 5],\n",
    "    \"num_filters\": 150,\n",
    "    \"batch_size\": 32,\n",
    "    \"learning_rate\": 0.001,\n",
    "    \"epochs\": 25,\n",
    "    \"glove_path\": 'data/glove.6B.100d.txt',\n",
    "    \"max_len\": 280,\n",
    "    \"test_size\": 0.1,\n",
    "    \"val_size\": 0.1,\n",
    "    \"patience\": 5,\n",
    "    \"data_path\": 'data/hack.csv',\n",
    "    \"dropout\": 0.6,\n",
    "    \"weight_decay\": 5e-4,\n",
    "    \"alpha\": 0.1,  # Alpha für die Balance in der Loss-Funktion\n",
    "    # patience for early stopping\n",
    "    'early_stopping_patience': 5 # 5 (3 to 10)\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNNBinaryClassifier(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, filter_sizes, num_filters, embedding_matrix, dropout):\n",
    "        super(CNNBinaryClassifier, self).__init__()\n",
    "        self.embedding = nn.Embedding.from_pretrained(embedding_matrix, freeze=False)\n",
    "        self.convs = nn.ModuleList([\n",
    "            nn.Sequential(\n",
    "                nn.Conv2d(1, num_filters, (fs, embedding_dim)),\n",
    "                nn.BatchNorm2d(num_filters),\n",
    "                nn.ReLU(),\n",
    "                nn.MaxPool2d((params[\"max_len\"] - fs + 1, 1)),\n",
    "                nn.Dropout(dropout)\n",
    "            )\n",
    "            for fs in filter_sizes\n",
    "        ])\n",
    "        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 128)\n",
    "        self.fc2 = nn.Linear(128, 2)  # 2 Klassen, daher 2 Outputs für CrossEntropyLoss\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.embedding(x).unsqueeze(1)\n",
    "        conv_outputs = [conv(x).squeeze(3).squeeze(2) for conv in self.convs]\n",
    "        x = torch.cat(conv_outputs, 1)\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        return self.fc2(x)  # 2 Outputs, CrossEntropyLoss übernimmt die Softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400002\n",
      "vocab_size: 400002, d_model: 100\n"
     ]
    }
   ],
   "source": [
    "# Daten laden\n",
    "embedding_matrix, word_index, vocab_size, d_model = create_embedding_matrix(\n",
    "    gloVe_path=params[\"glove_path\"], emb_len=params[\"embedding_dim\"]\n",
    ")\n",
    "X, y = load_preprocess_data(path_data=params[\"data_path\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 3945 3945\n",
      "test 494 494\n",
      "val 493 493\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Daten splitten\n",
    "data_split = split_data(X, y, test_size=params[\"test_size\"], val_size=params[\"val_size\"])\n",
    "train_dataset = TextDataset(data_split['train']['X'], data_split['train']['y'], word_index, max_len=params[\"max_len\"])\n",
    "val_dataset = TextDataset(data_split['val']['X'], data_split['val']['y'], word_index, max_len=params[\"max_len\"])\n",
    "test_dataset = TextDataset(data_split['test']['X'], data_split['test']['y'], word_index, max_len=params[\"max_len\"])\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=params[\"batch_size\"], shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=params[\"batch_size\"], shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=params[\"batch_size\"], shuffle=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "import EarlyStopping as EarlyStopping\n",
    "# Modell initialisieren\n",
    "model = CNNBinaryClassifier(\n",
    "    vocab_size=vocab_size,\n",
    "    embedding_dim=params[\"embedding_dim\"],\n",
    "    filter_sizes=params[\"filter_sizes\"],\n",
    "    num_filters=params[\"num_filters\"],\n",
    "    embedding_matrix=embedding_matrix,\n",
    "    dropout=params[\"dropout\"]\n",
    ")\n",
    "model = model.to(device)\n",
    "\n",
    "# BalancedCELoss verwenden\n",
    "criterion = BalancedCELoss(alpha=params[\"alpha\"])\n",
    "optimizer = optim.Adam(model.parameters(), lr=params[\"learning_rate\"], weight_decay=params[\"weight_decay\"])\n",
    "early_stopping = EarlyStopping.EarlyStopping(patience=params['early_stopping_patience'], verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/25: 100%|██████████| 124/124 [00:38<00:00,  3.26it/s, Train Loss=0.734]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 1, Train Loss: 105.9015, Val Loss: 12.5712\n",
      "Train Accuracy: 0.4958, Val Accuracy: 0.5314\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/25: 100%|██████████| 124/124 [00:36<00:00,  3.39it/s, Train Loss=0.79] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 2, Train Loss: 91.0446, Val Loss: 12.5252\n",
      "Train Accuracy: 0.5141, Val Accuracy: 0.5274\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/25: 100%|██████████| 124/124 [00:36<00:00,  3.39it/s, Train Loss=0.826]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 3, Train Loss: 93.3248, Val Loss: 12.5840\n",
      "Train Accuracy: 0.5039, Val Accuracy: 0.5254\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/25: 100%|██████████| 124/124 [00:36<00:00,  3.40it/s, Train Loss=0.7]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 4, Train Loss: 92.2199, Val Loss: 12.5006\n",
      "Train Accuracy: 0.4984, Val Accuracy: 0.5517\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/25: 100%|██████████| 124/124 [00:37<00:00,  3.29it/s, Train Loss=0.768]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 5, Train Loss: 91.2856, Val Loss: 11.9061\n",
      "Train Accuracy: 0.5290, Val Accuracy: 0.5862\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/25: 100%|██████████| 124/124 [00:40<00:00,  3.09it/s, Train Loss=0.694]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 6, Train Loss: 90.5596, Val Loss: 11.3011\n",
      "Train Accuracy: 0.5430, Val Accuracy: 0.6126\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/25: 100%|██████████| 124/124 [00:39<00:00,  3.18it/s, Train Loss=0.771]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 7, Train Loss: 89.5808, Val Loss: 11.5313\n",
      "Train Accuracy: 0.5582, Val Accuracy: 0.6207\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/25: 100%|██████████| 124/124 [00:36<00:00,  3.38it/s, Train Loss=0.697]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 8, Train Loss: 88.8963, Val Loss: 11.0529\n",
      "Train Accuracy: 0.5648, Val Accuracy: 0.6308\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9/25: 100%|██████████| 124/124 [00:37<00:00,  3.34it/s, Train Loss=0.846]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 9, Train Loss: 88.4877, Val Loss: 11.0292\n",
      "Train Accuracy: 0.5706, Val Accuracy: 0.6207\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10/25: 100%|██████████| 124/124 [00:36<00:00,  3.41it/s, Train Loss=0.756]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 10, Train Loss: 88.5556, Val Loss: 11.0032\n",
      "Train Accuracy: 0.5833, Val Accuracy: 0.6308\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11/25: 100%|██████████| 124/124 [00:36<00:00,  3.41it/s, Train Loss=0.664]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 11, Train Loss: 88.3764, Val Loss: 10.7751\n",
      "Train Accuracy: 0.5706, Val Accuracy: 0.6389\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12/25: 100%|██████████| 124/124 [00:38<00:00,  3.26it/s, Train Loss=0.866]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 12, Train Loss: 88.9168, Val Loss: 11.1027\n",
      "Train Accuracy: 0.5721, Val Accuracy: 0.6085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13/25: 100%|██████████| 124/124 [00:39<00:00,  3.13it/s, Train Loss=0.711]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 13, Train Loss: 88.4298, Val Loss: 11.0765\n",
      "Train Accuracy: 0.5888, Val Accuracy: 0.6288\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14/25: 100%|██████████| 124/124 [00:39<00:00,  3.11it/s, Train Loss=0.728]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 14, Train Loss: 88.7229, Val Loss: 11.1684\n",
      "Train Accuracy: 0.5823, Val Accuracy: 0.6349\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15/25: 100%|██████████| 124/124 [00:37<00:00,  3.28it/s, Train Loss=0.774]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 15, Train Loss: 89.3287, Val Loss: 11.4475\n",
      "Train Accuracy: 0.5830, Val Accuracy: 0.6146\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16/25: 100%|██████████| 124/124 [00:35<00:00,  3.48it/s, Train Loss=0.797]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 16, Train Loss: 85.6701, Val Loss: 10.7575\n",
      "Train Accuracy: 0.6175, Val Accuracy: 0.6329\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17/25: 100%|██████████| 124/124 [00:38<00:00,  3.23it/s, Train Loss=0.649]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 17, Train Loss: 83.7000, Val Loss: 10.7996\n",
      "Train Accuracy: 0.6294, Val Accuracy: 0.6166\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18/25: 100%|██████████| 124/124 [00:37<00:00,  3.31it/s, Train Loss=0.703]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 18, Train Loss: 80.2727, Val Loss: 10.7781\n",
      "Train Accuracy: 0.6679, Val Accuracy: 0.6450\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19/25: 100%|██████████| 124/124 [00:38<00:00,  3.24it/s, Train Loss=0.519]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 19, Train Loss: 73.5981, Val Loss: 11.1218\n",
      "Train Accuracy: 0.7113, Val Accuracy: 0.6247\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20/25: 100%|██████████| 124/124 [00:36<00:00,  3.41it/s, Train Loss=1.05] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 20, Train Loss: 66.4704, Val Loss: 11.3424\n",
      "Train Accuracy: 0.7592, Val Accuracy: 0.6227\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21/25: 100%|██████████| 124/124 [00:25<00:00,  4.90it/s, Train Loss=0.794]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 21, Train Loss: 59.3716, Val Loss: 12.2167\n",
      "Train Accuracy: 0.8043, Val Accuracy: 0.6024\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22/25: 100%|██████████| 124/124 [00:25<00:00,  4.79it/s, Train Loss=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 22, Train Loss: 48.0339, Val Loss: 13.4658\n",
      "Train Accuracy: 0.8525, Val Accuracy: 0.6085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23/25: 100%|██████████| 124/124 [00:23<00:00,  5.23it/s, Train Loss=0.218]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 23, Train Loss: 36.6165, Val Loss: 15.3780\n",
      "Train Accuracy: 0.8966, Val Accuracy: 0.5963\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24/25: 100%|██████████| 124/124 [00:23<00:00,  5.29it/s, Train Loss=0.166] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 24, Train Loss: 29.4375, Val Loss: 21.4867\n",
      "Train Accuracy: 0.9202, Val Accuracy: 0.5822\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25/25: 100%|██████████| 124/124 [00:22<00:00,  5.40it/s, Train Loss=0.209] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 25, Train Loss: 21.5571, Val Loss: 31.7498\n",
      "Train Accuracy: 0.9437, Val Accuracy: 0.5578\n"
     ]
    }
   ],
   "source": [
    "# Training\n",
    "history = {\n",
    "    \"train_loss\": [],\n",
    "    \"val_loss\": [],\n",
    "    \"train_acc\": [],\n",
    "    \"val_acc\": [],\n",
    "}\n",
    "\n",
    "for epoch in range(params[\"epochs\"]):\n",
    "    model.train()\n",
    "    train_loss, correct, total = 0.0, 0, 0\n",
    "\n",
    "    with tqdm(train_loader, desc=f\"Epoch {epoch + 1}/{params['epochs']}\") as pbar:\n",
    "        for X_batch, y_batch in pbar:\n",
    "            X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(X_batch)\n",
    "            loss = criterion(outputs, y_batch)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            train_loss += loss.item()\n",
    "            predicted = torch.argmax(outputs, dim=1)\n",
    "            correct += (predicted == y_batch).sum().item()\n",
    "            total += y_batch.size(0)\n",
    "\n",
    "            pbar.set_postfix({\"Train Loss\": loss.item()})\n",
    "\n",
    "    train_acc = correct / total\n",
    "    history[\"train_loss\"].append(train_loss / len(train_loader))\n",
    "    history[\"train_acc\"].append(train_acc)\n",
    "\n",
    "    # Validation\n",
    "    model.eval()\n",
    "    val_loss, correct, total = 0.0, 0, 0\n",
    "    with torch.no_grad():\n",
    "        for X_batch, y_batch in val_loader:\n",
    "            X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "            outputs = model(X_batch)\n",
    "            loss = criterion(outputs, y_batch)\n",
    "            val_loss += loss.item()\n",
    "            predicted = torch.argmax(outputs, dim=1)\n",
    "            correct += (predicted == y_batch).sum().item()\n",
    "            total += y_batch.size(0)\n",
    "\n",
    "    val_acc = correct / total\n",
    "    history[\"val_loss\"].append(val_loss / len(val_loader))\n",
    "    history[\"val_acc\"].append(val_acc)\n",
    "\n",
    "    print(f\"\\nEpoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n",
    "    print(f\"Train Accuracy: {train_acc:.4f}, Val Accuracy: {val_acc:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 0.6235\n"
     ]
    }
   ],
   "source": [
    "# Testen und Visualisieren\n",
    "model.eval()\n",
    "test_correct, test_total = 0, 0\n",
    "all_labels, all_preds = [], []\n",
    "\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in test_loader:\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "        outputs = model(X_batch)\n",
    "        predicted = torch.argmax(outputs, dim=1)\n",
    "        all_labels.extend(y_batch.cpu().numpy())\n",
    "        all_preds.extend(predicted.cpu().numpy())\n",
    "        test_correct += (predicted == y_batch).sum().item()\n",
    "        test_total += y_batch.size(0)\n",
    "\n",
    "test_accuracy = test_correct / test_total\n",
    "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🚀 Finale Test Accuracy: 0.6235\n",
      "🚀 Finale Test F1 Score: 0.6189\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ml_evaluation as ml_eval\n",
    "\n",
    "print(f'🚀 Finale Test Accuracy: {ml_eval.get_accuracy(all_preds, all_labels):.4f}')\n",
    "print(f'🚀 Finale Test F1 Score: {ml_eval.get_f1_score(all_preds, all_labels):.4f}')\n",
    "\n",
    "# Confusion matrix\n",
    "con_plt = ml_eval.plot_confusion_matrix(all_preds, all_labels, ['0', '1'])\n",
    "con_plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class 0: 0.44\n",
      "Class 1: 0.56\n"
     ]
    }
   ],
   "source": [
    "ml_eval.get_label_distribution(all_labels, all_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ml_evaluation as ml_eval\n",
    "ml_eval.plot_rating_preds(all_preds, all_labels, test_dataset).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_distribution(true_values, predicted_values):\n",
    "    plt.figure(figsize=(10, 6))\n",
    "\n",
    "    # Häufigkeiten der Klassen berechnen\n",
    "    true_counts = np.bincount(true_values, minlength=2)\n",
    "    predicted_counts = np.bincount(predicted_values, minlength=2)\n",
    "\n",
    "    # Barplot erstellen\n",
    "    labels = ['No Humor', 'Humor']\n",
    "    x = np.arange(len(labels))\n",
    "\n",
    "    plt.bar(x - 0.2, true_counts, width=0.4, color='skyblue', label='Wahre Werte', edgecolor='black')\n",
    "    plt.bar(x + 0.2, predicted_counts, width=0.4, color='salmon', label='Vorhergesagte Werte', edgecolor='black')\n",
    "\n",
    "    plt.title('Verteilung der wahren Werte und Vorhersagen')\n",
    "    plt.xticks(x, labels)\n",
    "    plt.ylabel('Häufigkeit')\n",
    "    plt.xlabel('Klassen')\n",
    "    plt.legend()\n",
    "    plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualisierung der Verteilung (Barplot)\n",
    "visualize_distribution(all_labels, all_preds)"
   ]
  }
 ],
 "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
}