examples/convolutional_digits_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "if 'has_changed_dir' not in globals():\n",
    "    repo_path = os.path.abspath(os.path.join('..'))\n",
    "    \n",
    "    if repo_path not in sys.path:\n",
    "        sys.path.append(repo_path)\n",
    "    \n",
    "    os.chdir(repo_path)\n",
    "    \n",
    "    globals()['has_changed_dir'] = True\n",
    "\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "import neunet as nnet\n",
    "import neunet.nn as nn\n",
    "from data_loader import load_mnist\n",
    "from neunet.optim import Adam\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_size = (1, 28, 28)\n",
    "\n",
    "training_dataset, test_dataset, training_targets, test_targets = load_mnist()\n",
    "training_dataset = (\n",
    "    training_dataset / 127.5 - 1\n",
    ")  # normalization: / 255 => [0; 1]  #/ 127.5-1 => [-1; 1]\n",
    "test_dataset = test_dataset / 127.5 - 1  # normalization: / 255 => [0; 1]  #/ 127.5-1 => [-1; 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = \"cuda\"\n",
    "\n",
    "class Conv2dClassifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Conv2dClassifier, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(1, 8, 3, 1, 1)\n",
    "        self.maxpool1 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.conv2 = nn.Conv2d(8, 16, 3, 1, 1)\n",
    "        self.maxpool2 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.bnorm = nn.BatchNorm2d(16)\n",
    "        self.leaky_relu = nn.LeakyReLU()\n",
    "\n",
    "        self.fc1 = nn.Linear(784, 10)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.leaky_relu(x)\n",
    "        x = self.maxpool1(x)\n",
    "\n",
    "        x = self.conv2(x)\n",
    "        x = self.leaky_relu(x)\n",
    "        x = self.maxpool2(x)\n",
    "\n",
    "        x = self.bnorm(x)\n",
    "\n",
    "        x = x.reshape(x.shape[0], -1)\n",
    "        x = self.fc1(x)\n",
    "        x = self.sigmoid(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "classifier = Conv2dClassifier().to(device)\n",
    "\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = Adam(classifier.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot_encode(labels):\n",
    "    one_hot_labels = np.zeros((labels.shape[0], 10))\n",
    "\n",
    "    for i in range(labels.shape[0]):\n",
    "        one_hot_labels[i, int(labels[i])] = 1\n",
    "\n",
    "    return one_hot_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "epochs = 3\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    tqdm_range = tqdm(range(0, len(training_dataset), batch_size), desc=\"epoch \" + str(epoch))\n",
    "    for i in tqdm_range:\n",
    "        batch = training_dataset[i : i + batch_size]\n",
    "\n",
    "        batch = batch.reshape(batch.shape[0], image_size[0], image_size[1], image_size[2])\n",
    "\n",
    "        batch = nnet.tensor(batch, device=device)\n",
    "\n",
    "        labels = nnet.tensor(one_hot_encode(training_targets[i : i + batch_size]), device=device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        outputs = classifier(batch)\n",
    "\n",
    "        loss = loss_fn(outputs, labels)\n",
    "\n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "\n",
    "        tqdm_range.set_description(f\"epoch: {epoch + 1}/{epochs}, loss: {loss.item():.7f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluate\n",
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "classifier.eval()\n",
    "\n",
    "for i in tqdm(range(len(test_dataset)), desc=\"evaluating\"):\n",
    "    img = test_dataset[i]\n",
    "    img = img.reshape(1, image_size[0], image_size[1], image_size[2])\n",
    "    img = nnet.tensor(img, requires_grad=False, device=device)\n",
    "    outputs = classifier(img)\n",
    "    predicted = np.argmax(outputs.detach().cpu().numpy())\n",
    "\n",
    "    total += 1\n",
    "    correct += predicted == test_targets[i]\n",
    "\n",
    "print(\"Accuracy of the network on the 10000 test images: %d %%\" % (100 * correct / total))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}