mlp_lesson2/mnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([60000, 1, 28, 28])\n",
      "torch.Size([60000])\n"
     ]
    }
   ],
   "source": [
    "def load_training_dataset():\n",
    "    transform = transforms.Compose(\n",
    "        [transforms.ToTensor(), transforms.Normalize((0.5), (0.5))]\n",
    "    )\n",
    "\n",
    "    trainset = torchvision.datasets.MNIST(\n",
    "        root=\"data\", train=True, download=True, transform=transform\n",
    "    )\n",
    "\n",
    "    trainloader = torch.utils.data.DataLoader(\n",
    "        trainset, batch_size=len(trainset), shuffle=True, num_workers=2\n",
    "    )\n",
    "\n",
    "    dataset_training_images, dataset_training_labels = next(iter(trainloader))\n",
    "\n",
    "    return dataset_training_images, dataset_training_labels\n",
    "\n",
    "\n",
    "dataset_training_images, dataset_training_labels = load_training_dataset()\n",
    "\n",
    "print(dataset_training_images.size())\n",
    "print(dataset_training_labels.size())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MNISTClassifier(\n",
      "  (input): Linear(in_features=784, out_features=64, bias=True)\n",
      "  (hidden): Linear(in_features=64, out_features=64, bias=True)\n",
      "  (output): Linear(in_features=64, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class MNISTClassifier(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.input = torch.nn.Linear(in_features=28 * 28, out_features=64)\n",
    "        self.hidden = torch.nn.Linear(in_features=64, out_features=64)\n",
    "        self.output = torch.nn.Linear(in_features=64, out_features=10)\n",
    "\n",
    "    def forward(self, tensor_images):\n",
    "        layer_input = tensor_images.view(-1, 1 * 28 * 28)\n",
    "\n",
    "        layer_input = torch.relu(self.input(layer_input))\n",
    "        layer_input = torch.relu(self.hidden(layer_input))\n",
    "        \n",
    "        return self.output(layer_input)\n",
    "\n",
    "\n",
    "mnist_classifier = MNISTClassifier()\n",
    "print(MNISTClassifier())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = torch.nn.CrossEntropyLoss()\n",
    "optimiser = torch.optim.Adam(mnist_classifier.parameters())\n",
    "training_steps = 20\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide_in_batches_32(tensor_dataset):\n",
    "    number_samples = tensor_dataset.size()[0]\n",
    "\n",
    "    step = 32\n",
    "\n",
    "    list_batches_dataset = []\n",
    "    for index in range(0, number_samples, step):\n",
    "        new_batch = tensor_dataset[index : index + step]\n",
    "        list_batches_dataset.append(new_batch)\n",
    "\n",
    "    return list_batches_dataset\n",
    "\n",
    "\n",
    "list_batches_images = divide_in_batches_32(dataset_training_images)\n",
    "list_batches_labels = divide_in_batches_32(dataset_training_labels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running loss: 0.3721207421153784\n",
      "running loss: 0.18768107621769112\n",
      "running loss: 0.1447690345466137\n",
      "running loss: 0.12002007986195386\n",
      "running loss: 0.10544551107548178\n",
      "running loss: 0.09261269581522792\n",
      "running loss: 0.08417433995548636\n",
      "running loss: 0.07941650625485927\n",
      "running loss: 0.0717719434825393\n",
      "running loss: 0.06743311271382652\n",
      "running loss: 0.06157788112061098\n",
      "running loss: 0.05899152673821276\n",
      "running loss: 0.05393540739576177\n",
      "running loss: 0.05420743654293086\n",
      "running loss: 0.04910440432143708\n",
      "running loss: 0.045843940859489764\n",
      "running loss: 0.04462584466006568\n",
      "running loss: 0.041397535623369425\n",
      "running loss: 0.04207585004148229\n",
      "running loss: 0.039324569922172425\n"
     ]
    }
   ],
   "source": [
    "def train_classifier_batches(mnist_classifier, loss, optimiser, list_batches_images, list_batch_labels, number_training_steps):\n",
    "    for _ in range(number_training_steps):\n",
    "\n",
    "        running_loss = 0.0\n",
    "\n",
    "        for batch_image, batch_label in zip(list_batches_images, list_batch_labels):\n",
    "            optimiser.zero_grad()\n",
    "\n",
    "            # Compute Loss\n",
    "            estimator_predictions = mnist_classifier(batch_image)\n",
    "            value_loss = loss.forward(input=estimator_predictions,\n",
    "                                    target=batch_label)\n",
    "\n",
    "            value_loss.backward()\n",
    "            optimiser.step()\n",
    "\n",
    "            running_loss += value_loss.item()\n",
    "\n",
    "        running_loss = running_loss / len(list_batches_images)\n",
    "        print(\"running loss:\", running_loss)\n",
    "\n",
    "train_classifier_batches(\n",
    "    mnist_classifier,\n",
    "    loss,\n",
    "    optimiser,\n",
    "    list_batches_images,\n",
    "    list_batches_labels,\n",
    "    training_steps,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prediction: tensor([[-13.8465,  -4.5318,  21.3872,   5.0450, -26.0116,  -8.9086, -21.4646,\n",
      "          12.7147,  -2.8321, -23.7281]], grad_fn=<AddmmBackward0>)\n",
      "label: 2\n",
      "argmax_prediction: 2\n"
     ]
    }
   ],
   "source": [
    "index_image_dataset = 0\n",
    "\n",
    "image = dataset_training_images[index_image_dataset].view(1, 1, 28, 28)\n",
    "label = dataset_training_labels[index_image_dataset]\n",
    "\n",
    "prediction = mnist_classifier(image)\n",
    "print(\"prediction:\", prediction)\n",
    "print(\"label:\", label.item())\n",
    "\n",
    "argmax_prediction = torch.argmax(prediction).item()\n",
    "print(\"argmax_prediction:\", argmax_prediction)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}