{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# unit 4.1 - Convolutional neural network example\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/culurciello/deep-learning-course-source/blob/main/source/lectures/41-conv-size-your-data.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 32, 32])\n",
      "torch.Size([1, 6, 28, 28])\n",
      "torch.Size([1, 6, 14, 14])\n",
      "torch.Size([1, 16, 10, 10])\n",
      "torch.Size([1, 16, 5, 5])\n",
      "torch.Size([1, 400])\n",
      "torch.Size([1, 10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0432,  0.0925,  0.0928, -0.1063,  0.0224,  0.0446,  0.0849,  0.0019,\n",
       "         -0.0039, -0.0315]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Size a neural network to your own data\n",
    "# an exercise\n",
    "# here image are 32 x 32, 10 categories \n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        print(x.shape)\n",
    "        x = self.conv1(x)\n",
    "        print(x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(x.shape)\n",
    "        x = self.conv2(x)\n",
    "        print(x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(x.shape)\n",
    "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
    "        print(x.shape)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        print(x.shape)\n",
    "        return x\n",
    "\n",
    "images = torch.zeros(1,1,32,32).float()\n",
    "net = Net()\n",
    "\n",
    "# test sizes\n",
    "net(images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 36, 36])\n",
      "torch.Size([1, 6, 32, 32])\n",
      "torch.Size([1, 6, 16, 16])\n",
      "torch.Size([1, 16, 12, 12])\n",
      "torch.Size([1, 16, 6, 6])\n",
      "torch.Size([1, 576])\n",
      "torch.Size([1, 10])\n",
      "OUTPUT tensor([[ 0.1236, -0.0587,  0.0465, -0.1093,  0.1002,  0.0442,  0.0430, -0.0308,\n",
      "         -0.1157, -0.1075]], grad_fn=<AddmmBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# now with new data - your image size is for example 36x36 - still 10 categories\n",
    "\n",
    "class NetYou(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 6 * 6, 120)\n",
    "        # self.fc1 = nn.Linear(36*36, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        print(x.shape)\n",
    "        x = self.conv1(x)\n",
    "        print(x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(x.shape)\n",
    "        x = self.conv2(x)\n",
    "        print(x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(x.shape)\n",
    "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
    "        print(x.shape)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        print(x.shape)\n",
    "        return x\n",
    "\n",
    "images = torch.zeros(1,1,36,36).float()\n",
    "net = NetYou()\n",
    "\n",
    "# test sizes\n",
    "\n",
    "out = net(images)\n",
    "print(\"OUTPUT\", out)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input: torch.Size([1, 1, 64, 64])\n",
      "after 1st conv: torch.Size([1, 6, 60, 60])\n",
      "after 1st pool: torch.Size([1, 6, 20, 20])\n",
      "torch.Size([1, 16, 16, 16])\n",
      "torch.Size([1, 16, 5, 5])\n",
      "torch.Size([1, 400])\n",
      "torch.Size([1, 10])\n",
      "OUTPUT tensor([[-0.0929, -0.0381, -0.1086, -0.0270, -0.0347, -0.0871, -0.0408,  0.0501,\n",
      "         -0.0742, -0.0289]], grad_fn=<AddmmBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# now with new data - your image size is for example 64x64 - still 10 categories\n",
    "\n",
    "class NetYou(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(3, 3)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        # self.conv3 = nn.Conv2d(16, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        # self.fc1 = nn.Linear(36*36, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        print(\"input:\", x.shape)\n",
    "        x = self.conv1(x)\n",
    "        print(\"after 1st conv:\", x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(\"after 1st pool:\", x.shape)\n",
    "        x = self.conv2(x)\n",
    "        print(x.shape)\n",
    "        x = self.pool(F.relu(x))\n",
    "        print(x.shape)\n",
    "        # x = self.conv3(x)\n",
    "        # print(x.shape)\n",
    "        # x = self.pool(F.relu(x))\n",
    "        # print(x.shape)\n",
    "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
    "        print(x.shape)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        print(x.shape)\n",
    "        return x\n",
    "\n",
    "images = torch.zeros(1,1,64,64).float()\n",
    "net = NetYou()\n",
    "\n",
    "# test sizes\n",
    "out = net(images)\n",
    "print(\"OUTPUT\", out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: torch.Size([1, 1, 360, 360])\n",
      "After: torch.Size([1, 1, 36, 36])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/homebrew/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# what if you have some large images, that are too large for small neural nets?\n",
    "\n",
    "import torchvision\n",
    "\n",
    "images = torch.zeros(1,1,360,360).float()\n",
    "print('Before:', images.shape)\n",
    "\n",
    "resizer = torchvision.transforms.Resize(size=(36,36))\n",
    "\n",
    "images = resizer(images)\n",
    "print('After:', images.shape)\n",
    "\n",
    "# it is better to do this on the entire dataset before training\n",
    "# since during training you may have to resize images at EVERY batch ==> inefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before (104, 86)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# using PIL module\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    " \n",
    "# Opens a image:\n",
    "im = Image.open(r\"images/home.png\")\n",
    "width, height = im.size\n",
    "print(\"Before\", im.size)\n",
    "\n",
    "newsize = (600, 500)\n",
    "im = im.resize(newsize)\n",
    "# plt.imshow(im)\n",
    "plt.imshow(im)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}