handson.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-24T15:35:32.579378913Z",
     "start_time": "2024-04-24T15:35:31.267013722Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-24T15:35:32.626950699Z",
     "start_time": "2024-04-24T15:35:32.625812263Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading from ./data/mnist_train.pkl\n",
      "Loading from ./data/mnist_test.pkl\n"
     ]
    }
   ],
   "source": [
    "# Transformations applied on each image => converting them to tensor and normalizing\n",
    "transform = transforms.Compose([transforms.ToTensor(), \n",
    "                                transforms.Normalize((0.1307,), (0.3081,))])\n",
    "\n",
    "def load_dataset(train=True):\n",
    "    filename = './data/mnist_train.pkl' if train else './data/mnist_test.pkl'\n",
    "\n",
    "    # Check if the dataset is already saved in pickle file\n",
    "    if os.path.exists(filename):\n",
    "        print(f\"Loading from {filename}\")\n",
    "        with open(filename, 'rb') as f:\n",
    "            dataset = pickle.load(f)\n",
    "    else:\n",
    "        print(f\"Downloading and saving to {filename}\")\n",
    "        dataset = datasets.MNIST(root='./data', train=train, transform=transform, download=True)\n",
    "        os.makedirs(os.path.dirname(filename), exist_ok=True)\n",
    "        with open(filename, 'wb') as f:\n",
    "            pickle.dump(dataset, f)\n",
    "\n",
    "    return dataset\n",
    "\n",
    "# Loading datasets\n",
    "train_dataset = load_dataset(train=True)\n",
    "train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)\n",
    "\n",
    "test_dataset = load_dataset(train=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-24T15:35:32.787918830Z",
     "start_time": "2024-04-24T15:35:32.626566869Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1000x400 with 6 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "examples = enumerate(test_loader)\n",
    "batch_idx, (example_data, example_targets) = next(examples)\n",
    "\n",
    "fig = plt.figure(figsize=(10, 4))\n",
    "for i in range(6):\n",
    "    plt.subplot(2, 3, i + 1)\n",
    "    plt.tight_layout()\n",
    "    plt.imshow(example_data[i][0], cmap='gray', interpolation='none')\n",
    "    plt.title(f\"Ground Truth: {example_targets[i]}\")\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-24T15:35:32.800326974Z",
     "start_time": "2024-04-24T15:35:32.787298510Z"
    }
   },
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(28*28, 200) ## Input Image: 28*28; Neuronen: 200\n",
    "        self.fc2 = nn.Linear(200, 10) ## Neuronen: 200; Output Klassen: 10\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28*28) ## Mache aus 28*28 Bild einen 1-dim Vektor\n",
    "        x = torch.relu(self.fc1(x)) ## Stecke 1-dim Vektor in Neuronenlayer\n",
    "        x = self.fc2(x) ## Stecke Output von ersten Neuronenlayer in zweiten Neuronenlayer\n",
    "        return x\n",
    "\n",
    "model = Net()\n",
    "kostenfunktion = nn.CrossEntropyLoss() ## Kostenfunktion (Y-Ŷ)\n",
    "verarbeitungsschritt = optim.Adam(model.parameters(), lr=0.001) ## Bieger der Funktion für bessere Resultate bei Kostenfunktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-24T15:35:32.800598206Z",
     "start_time": "2024-04-24T15:35:32.793419523Z"
    }
   },
   "outputs": [],
   "source": [
    "def train(epoch):\n",
    "    model.train()\n",
    "    trainings_kosten = 0\n",
    "    correct = 0\n",
    "    for bild, wahrheitswert in train_loader: # Wir gehen über alle Daten Bild für Bild\n",
    "        verarbeitungsschritt.zero_grad()\n",
    "        output = model(bild) ## Gebe Bild hinein\n",
    "        loss = kostenfunktion(output, wahrheitswert) ## Ŷ - Y\n",
    "\n",
    "        trainings_kosten += loss.item()\n",
    "        pred = output.argmax(dim=1, keepdim=True)\n",
    "        correct += pred.eq(wahrheitswert.view_as(pred)).sum().item()\n",
    "\n",
    "        loss.backward()\n",
    "        verarbeitungsschritt.step() ## Update die Parameter des Models\n",
    "    trainings_kosten /= len(train_loader.dataset)\n",
    "    train_accuracy = 100. * correct / len(train_loader.dataset)\n",
    "    print(f'Train Epoch: {epoch} \\tLoss: {trainings_kosten:.6f} \\tAccuracy: {train_accuracy:.2f}%')\n",
    "    return trainings_kosten, train_accuracy\n",
    "\n",
    "def test():\n",
    "    model.eval()\n",
    "    test_kosten = 0\n",
    "    correct = 0\n",
    "    with torch.no_grad():\n",
    "        for data, target in test_loader:\n",
    "            output = model(data)\n",
    "            test_kosten += kostenfunktion(output, target).item()\n",
    "            pred = output.argmax(dim=1, keepdim=True)\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "    test_kosten /= len(test_loader.dataset)\n",
    "    test_accuracy = 100. * correct / len(test_loader.dataset)\n",
    "    print(f'\\nTest set: Average loss: {test_kosten:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({test_accuracy:.0f}%)\\n')\n",
    "    return test_kosten, test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "is_executing": true,
    "ExecuteTime": {
     "start_time": "2024-04-24T15:35:32.795540291Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/berni/Desktop/ai-nleuchtend-handson/venv/lib/python3.11/site-packages/torch/autograd/__init__.py:251: UserWarning: CUDA initialization: The NVIDIA driver on your system is too old (found version 11040). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver. (Triggered internally at ../c10/cuda/CUDAFunctions.cpp:108.)\n",
      "  Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1 \tLoss: 0.012537 \tAccuracy: 93.87%\n",
      "\n",
      "Test set: Average loss: 0.0065, Accuracy: 9700/10000 (97%)\n",
      "Train Epoch: 2 \tLoss: 0.005990 \tAccuracy: 97.02%\n",
      "\n",
      "Test set: Average loss: 0.0055, Accuracy: 9707/10000 (97%)\n",
      "Train Epoch: 3 \tLoss: 0.004518 \tAccuracy: 97.73%\n",
      "\n",
      "Test set: Average loss: 0.0058, Accuracy: 9723/10000 (97%)\n",
      "Train Epoch: 4 \tLoss: 0.003720 \tAccuracy: 98.13%\n",
      "\n",
      "Test set: Average loss: 0.0056, Accuracy: 9733/10000 (97%)\n",
      "Train Epoch: 5 \tLoss: 0.002973 \tAccuracy: 98.44%\n",
      "\n",
      "Test set: Average loss: 0.0061, Accuracy: 9732/10000 (97%)\n",
      "Train Epoch: 6 \tLoss: 0.002555 \tAccuracy: 98.67%\n",
      "\n",
      "Test set: Average loss: 0.0055, Accuracy: 9772/10000 (98%)\n",
      "Train Epoch: 7 \tLoss: 0.002174 \tAccuracy: 98.86%\n",
      "\n",
      "Test set: Average loss: 0.0093, Accuracy: 9638/10000 (96%)\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\n",
    "train_losses, train_accuracies = [], []\n",
    "test_losses, test_accuracies = [], []\n",
    "\n",
    "for epoch in range(1, epochs + 1):\n",
    "    train_loss, train_accuracy = train(epoch)\n",
    "    test_loss, test_accuracy = test()\n",
    "    train_losses.append(train_loss)\n",
    "    train_accuracies.append(train_accuracy)\n",
    "    test_losses.append(test_loss)\n",
    "    test_accuracies.append(test_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,4))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(range(1, epochs + 1), train_losses, label='Train Loss')\n",
    "plt.plot(range(1, epochs + 1), test_losses, label='Test Loss')\n",
    "plt.title('Loss over Epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(range(1, epochs + 1), train_accuracies, label='Train Accuracy')\n",
    "plt.plot(range(1, epochs + 1), test_accuracies, label='Test Accuracy')\n",
    "plt.title('Accuracy over Epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy (%)')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    batch_idx, (example_data, example_targets) = next(examples)\n",
    "    output = model(example_data)\n",
    "    predicted = output.argmax(dim=1, keepdim=True)\n",
    "\n",
    "fig = plt.figure(figsize=(10, 4))\n",
    "for i in range(6):\n",
    "    plt.subplot(2, 3, i + 1)\n",
    "    plt.tight_layout()\n",
    "    plt.imshow(example_data[i][0], cmap='gray', interpolation='none')\n",
    "    plt.title(f\"Truth: {example_targets[i]}\\nPredicted: {predicted[i].item()}\")\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "def plot_incorrect_predictions(model, loader, num_images=6):\n",
    "    model.eval()\n",
    "    incorrect_examples = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for data, target in loader:\n",
    "            output = model(data)\n",
    "            pred = output.argmax(dim=1, keepdim=True)\n",
    "            idxs_mask = ((pred == target.view_as(pred)) == False).view(-1)\n",
    "            incorrect_preds = pred[idxs_mask].view(-1)\n",
    "            actual_labels = target.view_as(pred)[idxs_mask].view(-1)\n",
    "            data = data[idxs_mask]\n",
    "            for i in range(data.shape[0]):\n",
    "                if len(incorrect_examples) < num_images:\n",
    "                    incorrect_examples.append((data[i], incorrect_preds[i], actual_labels[i]))\n",
    "                else:\n",
    "                    break\n",
    "            if len(incorrect_examples) == num_images:\n",
    "                break\n",
    "\n",
    "    fig = plt.figure(figsize=(10, 4))\n",
    "    for i, (img, pred, actual) in enumerate(incorrect_examples):\n",
    "        img = img.view(28, 28)\n",
    "        plt.subplot(1, num_images, i + 1)\n",
    "        plt.tight_layout()\n",
    "        plt.imshow(img, cmap='gray', interpolation='none')\n",
    "        plt.title(f\"Pred: {pred.item()}\\nActual: {actual.item()}\")\n",
    "        plt.xticks([])\n",
    "        plt.yticks([])\n",
    "    plt.show()\n",
    "\n",
    "# Usage\n",
    "plot_incorrect_predictions(model, test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "is_executing": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}