functional_api.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Model_layer.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPjQkfzk96N1zivTvap4zTY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bipinKrishnan/torchkeras/blob/master/functional_api.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sTRyumaWcSwb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install pkbar"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-oEWtsIX6Xz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "from torch import optim\n",
        "from torchsummary import summary as summary_\n",
        "import pkbar\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCugQ8DJae0g",
        "colab_type": "text"
      },
      "source": [
        "# TorchKeras"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_h4x_jTPpIfL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def Input(size):\n",
        "  return size"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-JJKHynxYHIj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Dense(nn.Module):\n",
        "  def __init__(self, outputs, activation):\n",
        "    super().__init__()\n",
        "    self.outputs = outputs\n",
        "    self.activation = activation\n",
        "\n",
        "  def __call__(self, inputs):\n",
        "    if type(inputs) == int:\n",
        "      self.inputs_size = inputs\n",
        "      self.layers = nn.Sequential(\n",
        "        nn.Linear(self.inputs_size, self.outputs),\n",
        "        self.activation\n",
        "    )\n",
        "\n",
        "      return self.layers\n",
        "\n",
        "    else:\n",
        "      self.inputs = inputs\n",
        "      self.layers = list(inputs)\n",
        "      self.layers.extend([nn.Linear(self.layers[-2].out_features, self.outputs), self.activation])\n",
        "\n",
        "      self.layers = nn.Sequential(*self.layers)\n",
        "\n",
        "      return self.layers"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XZ81UK7tegjA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Model():\n",
        "  def __init__(self, inputs, outputs, device):\n",
        "    self.input_size = inputs\n",
        "    self.device = device\n",
        "    self.model = outputs.to(self.device)\n",
        "\n",
        "  def compile(self, optimizer, loss, metrics):\n",
        "    self.opt = optimizer\n",
        "    self.criterion = loss\n",
        "    self.metrics = metrics\n",
        "\n",
        "  def summary(self):\n",
        "    summary_(self.model, (1, self.input_size), device=self.device)\n",
        "    print(\"Device Type:\", self.device)\n",
        "\n",
        "  def fit(self, data_x, data_y, epochs):\n",
        "    self.model.train()\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "      print(\"Epoch {}/{}\".format(epoch+1, epochs))\n",
        "      progress = pkbar.Kbar(target=len(data_x), width=25)\n",
        "      \n",
        "      for i, (data, target) in enumerate(zip(data_x, data_y)):\n",
        "        self.opt.zero_grad()\n",
        "\n",
        "        train_out = self.model(data.to(self.device))\n",
        "        loss = self.criterion(train_out, target.to(self.device))\n",
        "        loss.backward()\n",
        "\n",
        "        self.opt.step()\n",
        "\n",
        "        progress.update(i, values=[(\"loss: \", loss.item())])\n",
        "\n",
        "      progress.add(1)\n",
        "\n",
        "  def evaluate(self, test_x, test_y):\n",
        "    self.model.eval()\n",
        "    correct, loss = 0.0, 0.0\n",
        "\n",
        "    progress = pkbar.Kbar(target=len(test_x), width=25)\n",
        "\n",
        "    for i, (data, target) in enumerate(zip(test_x, test_y)):\n",
        "      out = self.model(data.to(self.device))\n",
        "      loss += self.criterion(out, target.to(self.device))\n",
        "\n",
        "      correct += ((torch.max(out, 1)[1]) == target.to(self.device)).sum()\n",
        "\n",
        "      progress.update(i, values=[(\"loss\", loss.item()/len(test_x)), (\"acc\", (correct/len(test_x)).item())])\n",
        "    progress.add(1)\n",
        "\n",
        "\n",
        "  def fit_generator(self, generator, epochs):\n",
        "    self.model.train()\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "      print(\"Epoch {}/{}\".format(epoch+1, epochs))\n",
        "      progress = pkbar.Kbar(target=len(generator), width=25)\n",
        "\n",
        "      for i, (data, target) in enumerate(generator):\n",
        "        self.opt.zero_grad()\n",
        "\n",
        "        train_out = self.model(data.to(self.device))\n",
        "        loss = self.criterion(train_out.squeeze(), target.to(self.device))\n",
        "        loss.backward()\n",
        "\n",
        "        self.opt.step()\n",
        "\n",
        "        progress.update(i, values=[(\"loss: \", loss.item())])\n",
        "\n",
        "      progress.add(1)\n",
        "      \n",
        "\n",
        "  def evaluate_generator(self, generator):\n",
        "    self.model.eval()\n",
        "    correct, loss = 0.0, 0.0\n",
        "\n",
        "    progress = pkbar.Kbar(target=len(generator), width=25)\n",
        "\n",
        "    for i, (data, target) in enumerate(generator):\n",
        "      out = self.model(data.to(self.device))\n",
        "      loss += self.criterion(out.squeeze(), target.to(self.device))\n",
        "\n",
        "      correct += (torch.max(out.squeeze(), 1)[1] == target.to(self.device)).sum()\n",
        "\n",
        "      progress.update(i, values=[(\"test_acc\", (correct/len(generator)).item()), (\"test_loss\", loss.item()/len(generator))])\n",
        "\n",
        "    progress.add(1)\n",
        "      "
      ],
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N21QvHSGaZ3L",
        "colab_type": "text"
      },
      "source": [
        "# Test data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Otnl-l-iZJJO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "input = Input(size=1024)\n",
        "x = Dense(54, nn.ReLU())(input)\n",
        "y = Dense(34, nn.ReLU())(x)\n",
        "z = Dense(43, activation=nn.ReLU())(y)\n",
        "a = Dense(10, activation=nn.ReLU())(z)\n",
        "b = Dense(1, activation=nn.Sigmoid())(a)"
      ],
      "execution_count": 87,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SKHqRcKYeLPI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = Model(input, b, 'cuda')\n",
        "model.compile(optim.Adam(z.parameters(), lr=0.001), nn.BCELoss(), 'accuracy')"
      ],
      "execution_count": 88,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ajMFyfaGyrGJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "2d38a457-6333-4f5e-931b-46acf4c5a548"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Linear-1                [-1, 1, 54]          55,350\n",
            "              ReLU-2                [-1, 1, 54]               0\n",
            "            Linear-3                [-1, 1, 34]           1,870\n",
            "              ReLU-4                [-1, 1, 34]               0\n",
            "            Linear-5                [-1, 1, 43]           1,505\n",
            "              ReLU-6                [-1, 1, 43]               0\n",
            "            Linear-7                [-1, 1, 10]             440\n",
            "              ReLU-8                [-1, 1, 10]               0\n",
            "            Linear-9                 [-1, 1, 1]              11\n",
            "          Sigmoid-10                 [-1, 1, 1]               0\n",
            "================================================================\n",
            "Total params: 59,176\n",
            "Trainable params: 59,176\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.00\n",
            "Params size (MB): 0.23\n",
            "Estimated Total Size (MB): 0.23\n",
            "----------------------------------------------------------------\n",
            "Device Type: cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "99Pyms_5rYtP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "x = torch.rand((10, 1, 1024), dtype=torch.float)\n",
        "y = torch.tensor((torch.rand(10, 1) < 0.5), dtype=torch.float)\n",
        "#y = torch.tensor([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], dtype=torch.int64).reshape(-1, 1)"
      ],
      "execution_count": 90,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HSCwl4yqsPhw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        },
        "outputId": "c44c3d1a-aaa7-40d1-efad-c7f1ffdecf6f"
      },
      "source": [
        "model.fit(x, y, 4)"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/4\n",
            "10/10 [=========================] - 0s 2ms/step - loss: : 0.6943\n",
            "Epoch 2/4\n",
            "10/10 [=========================] - 0s 2ms/step - loss: : 0.6751\n",
            "Epoch 3/4\n",
            "10/10 [=========================] - 0s 2ms/step - loss: : 0.6546\n",
            "Epoch 4/4\n",
            "10/10 [=========================] - 0s 3ms/step - loss: : 0.6284\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3oRV0zycttMR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e4dc91f4-3f64-4222-f76c-95d9ac15ebcf"
      },
      "source": [
        "model.evaluate(x, y)"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10/10 [=========================] - 0s 1ms/step - loss: 0.3598 - acc: 0.1111    \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qtA78EwuB_QB",
        "colab_type": "text"
      },
      "source": [
        "# CIFAR100"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hGCt0wTGCAjI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torchvision\n",
        "from torchvision import transforms\n",
        "from torch.utils.data import DataLoader\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R4jc8Zb5CE2Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bs = 128\n",
        "\n",
        "transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),\n",
        "                                transforms.Resize((1, 28*28)),\n",
        "                                transforms.ToTensor()\n",
        "])\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR100(root='./data', train=True, download=True, transform=transform)\n",
        "testset = torchvision.datasets.CIFAR100(root='./data', train=False, download=True, transform=transform)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wFRZvUpvUQ1n",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "128b79e3-bd6e-4900-8a2a-4a809842b12f"
      },
      "source": [
        "#images for feeding fit_generator dense network \n",
        "#must be resized to (1, 1, height*width*channel)\n",
        "trainset[0][0].shape"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 1, 784])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9hYwVNEsCJ7o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "trainloader = DataLoader(trainset, batch_size=bs, shuffle=True)\n",
        "testloader = DataLoader(testset, batch_size=bs)"
      ],
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vhQI6UtDE1DZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "932376ca-6c91-4233-a319-fcf675702d2f"
      },
      "source": [
        "input = Input(size=784)\n",
        "x = Dense(1000, nn.ReLU())(input)\n",
        "y = Dense(500, nn.ReLU())(x)\n",
        "z = Dense(700, activation=nn.ReLU())(y)\n",
        "a = Dense(200, activation=nn.ReLU())(z)\n",
        "b = Dense(100, activation=nn.ReLU())(a)\n",
        "\n",
        "model = Model(input, b, device)\n",
        "model.compile(optim.Adam(b.parameters(), lr=0.001), nn.CrossEntropyLoss(), 'accuracy')\n",
        "model.summary()"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Linear-1              [-1, 1, 1000]         785,000\n",
            "              ReLU-2              [-1, 1, 1000]               0\n",
            "            Linear-3               [-1, 1, 500]         500,500\n",
            "              ReLU-4               [-1, 1, 500]               0\n",
            "            Linear-5               [-1, 1, 700]         350,700\n",
            "              ReLU-6               [-1, 1, 700]               0\n",
            "            Linear-7               [-1, 1, 200]         140,200\n",
            "              ReLU-8               [-1, 1, 200]               0\n",
            "            Linear-9               [-1, 1, 100]          20,100\n",
            "             ReLU-10               [-1, 1, 100]               0\n",
            "================================================================\n",
            "Total params: 1,796,500\n",
            "Trainable params: 1,796,500\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.04\n",
            "Params size (MB): 6.85\n",
            "Estimated Total Size (MB): 6.89\n",
            "----------------------------------------------------------------\n",
            "Device Type: cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2ahcZ9IDeEd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        },
        "outputId": "868ec121-5128-4aa6-810a-bd7f611c80e0"
      },
      "source": [
        "model.fit_generator(trainloader, 3)"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "391/391 [=========================] - 13s 33ms/step - loss: : 4.5967\n",
            "Epoch 2/3\n",
            "391/391 [=========================] - 13s 33ms/step - loss: : 4.5844\n",
            "Epoch 3/3\n",
            "391/391 [=========================] - 13s 33ms/step - loss: : 4.5749\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YIP9jwX1bsP2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "038544d9-c875-446e-96fc-b549398e845f"
      },
      "source": [
        "model.evaluate_generator(testloader)"
      ],
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "79/79 [=========================] - 2s 31ms/step - test_acc: 2.0894 - test_loss: 2.3429\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7PqD8aKda0GR"
      },
      "source": [
        "# CIFAR10"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RxbpAFqEa0Gv",
        "colab": {}
      },
      "source": [
        "bs = 64\n",
        "\n",
        "transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),\n",
        "                                transforms.Resize((1, 28*28)),\n",
        "                                transforms.ToTensor()\n",
        "])\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ZnANxHHFa0HF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eb9ac719-28a5-4fbe-8e32-83335a35a989"
      },
      "source": [
        "#images for feeding fit_generator dense network \n",
        "#must be of the form (1, 1, height*width*channel)\n",
        "trainset[0][0].shape"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 1, 784])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "B_ywq52Ba0HR",
        "colab": {}
      },
      "source": [
        "trainloader = DataLoader(trainset, batch_size=bs, shuffle=True)\n",
        "testloader = DataLoader(testset, batch_size=bs)"
      ],
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jSO7gtHea0Hb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "59dcc061-22ac-453f-ea89-39a443a0690a"
      },
      "source": [
        "input = Input(size=784)\n",
        "x = Dense(1024, nn.ReLU())(input)\n",
        "y = Dense(800, nn.ReLU())(x)\n",
        "z = Dense(300, activation=nn.ReLU())(y)\n",
        "a = Dense(200, activation=nn.ReLU())(z)\n",
        "b = Dense(10, activation=nn.ReLU())(a)\n",
        "\n",
        "model = Model(input, b, 'cuda')\n",
        "model.compile(optim.Adam(b.parameters(), lr=0.001), nn.CrossEntropyLoss(), 'accuracy')\n",
        "model.summary()"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Linear-1              [-1, 1, 1024]         803,840\n",
            "              ReLU-2              [-1, 1, 1024]               0\n",
            "            Linear-3               [-1, 1, 800]         820,000\n",
            "              ReLU-4               [-1, 1, 800]               0\n",
            "            Linear-5               [-1, 1, 300]         240,300\n",
            "              ReLU-6               [-1, 1, 300]               0\n",
            "            Linear-7               [-1, 1, 200]          60,200\n",
            "              ReLU-8               [-1, 1, 200]               0\n",
            "            Linear-9                [-1, 1, 10]           2,010\n",
            "             ReLU-10                [-1, 1, 10]               0\n",
            "================================================================\n",
            "Total params: 1,926,350\n",
            "Trainable params: 1,926,350\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.04\n",
            "Params size (MB): 7.35\n",
            "Estimated Total Size (MB): 7.39\n",
            "----------------------------------------------------------------\n",
            "Device Type: cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "fIfJtFala0Hm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        },
        "outputId": "0dfb0ab3-da67-4e80-d006-7120673de57a"
      },
      "source": [
        "model.fit_generator(trainloader, 3)"
      ],
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "782/782 [=========================] - 14s 18ms/step - loss: : 2.2989\n",
            "Epoch 2/3\n",
            "782/782 [=========================] - 14s 18ms/step - loss: : 2.2935\n",
            "Epoch 3/3\n",
            "782/782 [=========================] - 14s 18ms/step - loss: : 2.2767\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Yo1h0ywGa0Hx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0efd308e-1374-429b-f97e-190fd2efd0b1"
      },
      "source": [
        "model.evaluate_generator(testloader)"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "157/157 [=========================] - 2s 16ms/step - test_acc: 5.2690 - test_loss: 1.1446\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wlI2RCv5bI0g"
      },
      "source": [
        "# MNIST"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "fN8MtErvbI1E",
        "colab": {}
      },
      "source": [
        "bs = 32\n",
        "\n",
        "transform = transforms.Compose([\n",
        "                                transforms.Resize((1, 28*28)),\n",
        "                                transforms.ToTensor()\n",
        "])\n",
        "\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)"
      ],
      "execution_count": 106,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Sw437nMwbI1V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "53123577-e553-46cf-c04a-a929ac58ea64"
      },
      "source": [
        "#images for feeding fit_generator dense network \n",
        "#must be of the form (1, 1, height*width*channel)\n",
        "trainset[0][0].shape"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 1, 784])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "zslLOsG3bI1j",
        "colab": {}
      },
      "source": [
        "trainloader = DataLoader(trainset, batch_size=bs, shuffle=True)\n",
        "testloader = DataLoader(testset, batch_size=bs)"
      ],
      "execution_count": 108,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "p91ByqQ2bI1v",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "9562459f-c830-434e-8fb2-9704971501d5"
      },
      "source": [
        "input = Input(size=784)\n",
        "x = Dense(700, nn.ReLU())(input)\n",
        "y = Dense(200, nn.ReLU())(x)\n",
        "z = Dense(300, activation=nn.ReLU())(y)\n",
        "a = Dense(100, activation=nn.ReLU())(z)\n",
        "b = Dense(10, activation=nn.ReLU())(a)\n",
        "\n",
        "model = Model(input, b, 'cuda')\n",
        "model.compile(optim.Adam(b.parameters(), lr=0.001), nn.CrossEntropyLoss(), 'accuracy')\n",
        "model.summary()"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Linear-1               [-1, 1, 700]         549,500\n",
            "              ReLU-2               [-1, 1, 700]               0\n",
            "            Linear-3               [-1, 1, 200]         140,200\n",
            "              ReLU-4               [-1, 1, 200]               0\n",
            "            Linear-5               [-1, 1, 300]          60,300\n",
            "              ReLU-6               [-1, 1, 300]               0\n",
            "            Linear-7               [-1, 1, 100]          30,100\n",
            "              ReLU-8               [-1, 1, 100]               0\n",
            "            Linear-9                [-1, 1, 10]           1,010\n",
            "             ReLU-10                [-1, 1, 10]               0\n",
            "================================================================\n",
            "Total params: 781,110\n",
            "Trainable params: 781,110\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.02\n",
            "Params size (MB): 2.98\n",
            "Estimated Total Size (MB): 3.00\n",
            "----------------------------------------------------------------\n",
            "Device Type: cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "G9dQdMOybI16",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        },
        "outputId": "68e52dae-e6b7-4f04-ed8d-7303d3a7051a"
      },
      "source": [
        "model.fit_generator(trainloader, 3)"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "1875/1875 [=========================] - 17s 9ms/step - loss: : 1.6028\n",
            "Epoch 2/3\n",
            "1875/1875 [=========================] - 17s 9ms/step - loss: : 1.3103\n",
            "Epoch 3/3\n",
            "1875/1875 [=========================] - 17s 9ms/step - loss: : 1.2229\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "w4vo6b2YbI2E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e43bc49c-6280-4b56-a559-475571cefa5a"
      },
      "source": [
        "model.evaluate_generator(testloader)"
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "313/313 [=========================] - 2s 7ms/step - test_acc: 9.8077 - test_loss: 0.5984\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}