NN_Episode11.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NN_Episode11.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "QfRzyjrJSMdM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "43fd4510-821a-4f90-dd76-d35bda056036"
      },
      "source": [
        "import torch \n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from tqdm import tqdm\n",
        "import matplotlib.pyplot as plt\n",
        "from keras.datasets import mnist\n",
        "from google.colab import output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W7_CZ27llagu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# device = torch.device('cpu')\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYe3Jor9tWo8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class NeuralNet(nn.Module):\n",
        "    def __init__(self, input_shape, output_shape, output_act, seed=43):\n",
        "        super(NeuralNet, self).__init__()\n",
        "        torch.manual_seed(seed)\n",
        "        torch.cuda.manual_seed(seed)\n",
        "\n",
        "        self.fc1 = nn.Linear(input_shape, 500)\n",
        "        self.fc2 = nn.Linear(500, 50)\n",
        "        self.fc3 = nn.Linear(50, output_shape)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "        self.output_act = output_act\n",
        "\n",
        "        self.do1 = nn.Dropout(p=0.2)\n",
        "        self.do2 = nn.Dropout(p=0.4)\n",
        "\n",
        "        self.report = dict()\n",
        "        self.report['train_loss'] = []\n",
        "        self.report['train_acc'] = []\n",
        "        self.report['test_loss'] = []\n",
        "        self.report['test_acc'] = [] \n",
        "    \n",
        "    def forward(self, x):\n",
        "        out = self.fc1(x)\n",
        "        out = self.relu(out)\n",
        "        out = self.do2(out)\n",
        "\n",
        "        out = self.fc2(out)\n",
        "        out = self.relu(out)\n",
        "        out = self.do1(out)\n",
        "\n",
        "        out = self.fc3(out)\n",
        "        if self.output_act:\n",
        "            out = self.output_act(out)\n",
        "        return out\n",
        "\n",
        "    def test(self, criterion, testdata):\n",
        "        mean_loss = 0.0\n",
        "        accuracy = 0.0\n",
        "        total = 0.0\n",
        "\n",
        "        with torch.no_grad():\n",
        "            for x, y in testdata:\n",
        "                x, y = x.to(device), y.to(device)\n",
        "                out = self(x)\n",
        "                loss = criterion(out, y)\n",
        "                total += y.size(0)\n",
        "                mean_loss += loss.item() * y.size(0)\n",
        "                if len(y.size())==2:\n",
        "                    if out.size(1) == 1:\n",
        "                        accuracy += (torch.round(out) == y).sum()\n",
        "                    else:\n",
        "                        accuracy += (torch.argmax(out, dim=1) == torch.argmax(y, dim=1)).sum()\n",
        "                else:\n",
        "                    accuracy += (torch.argmax(out, dim=1) == y).sum()\n",
        "\n",
        "        self.report['test_loss'].append(mean_loss/total)\n",
        "        self.report['test_acc'].append(accuracy/total)\n",
        "\n",
        "    def learn(self, criterion, epochs, traindata, testdata, \n",
        "            r_lambda=0, optimizer=None, lr_schedulers=None, \n",
        "            nesterov=False, eta=0.001, verbos=1):\n",
        "\n",
        "        if optimizer:\n",
        "            optimizer = optimizer[0](self.parameters(), lr=eta,\n",
        "                                     weight_decay=r_lambda, **optimizer[1])\n",
        "        else:\n",
        "            optimizer = torch.optim.SGD(self.parameters(), lr=eta,\n",
        "                                        momentum=0.9, weight_decay=r_lambda,\n",
        "                                        nesterov=nesterov)\n",
        "\n",
        "        l_bar = '{percentage:3.0f}%|'\n",
        "        r_bar = '|{n_fmt}/{total_fmt}[{elapsed}<{remaining},{rate_fmt}{postfix}]'\n",
        "        t = tqdm(range(epochs), disable=(not verbos), position=0, leave=True,\n",
        "                 bar_format= l_bar+ '{bar}' + r_bar +' {desc}')\n",
        "        for i in t:\n",
        "            mean_loss = 0.0\n",
        "            mean_accuracy = 0.0\n",
        "            total = 0.0\n",
        "\n",
        "            for step, (x, y) in enumerate(traindata):\n",
        "                x, y = x.to(device), y.to(device)\n",
        "                out = self(x)\n",
        "                loss = criterion(out, y)\n",
        "                \n",
        "                optimizer.zero_grad()\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "                \n",
        "                if len(y.size())==2:\n",
        "                    if out.size(1) == 1:\n",
        "                        accuracy = (torch.round(out) == y).sum()\n",
        "                    else:\n",
        "                        accuracy = (torch.argmax(out, dim=1) == torch.argmax(y, dim=1)).sum()\n",
        "                else:\n",
        "                    accuracy = (torch.argmax(out, dim=1) == y).sum()\n",
        "\n",
        "                if verbos == 1:\n",
        "                    if i>0:\n",
        "                        t.set_description(\"train loss:{:.8f} train acc:{:.2f} test loss:{:.8f} test acc:{:.2f}\" \n",
        "                                    .format(loss.item(), \n",
        "                                            accuracy/(y.size(0)*1.),\n",
        "                                            self.report['test_loss'][-1],\n",
        "                                            self.report['test_acc'][-1]))\n",
        "                    else:\n",
        "                        t.set_description(\"train loss:{}\".format(loss.item()))\n",
        "                    t.refresh()\n",
        "\n",
        "                total += y.size(0)\n",
        "                mean_loss += loss.item() * y.size(0)\n",
        "                mean_accuracy += accuracy\n",
        "\n",
        "            self.report['train_loss'].append(mean_loss/total)\n",
        "            self.report['train_acc'].append(mean_accuracy/total)\n",
        "\n",
        "            self.test(criterion, testdata)\n",
        "\n",
        "            if verbos == 1:\n",
        "                t.set_description(\"train loss:{:.8f} train acc:{:.2f} test loss:{:.8f} test acc:{:.2f}\" \n",
        "                            .format(self.report['train_loss'][-1], \n",
        "                                    self.report['train_acc'][-1],\n",
        "                                    self.report['test_loss'][-1],\n",
        "                                    self.report['test_acc'][-1]))\n",
        "                t.refresh()\n",
        "\n",
        "    def weight_init(self, m):\n",
        "        if isinstance(m, nn.Linear):\n",
        "            nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu'))\n",
        "            nn.init.zeros_(m.bias)\n",
        "\n",
        "    def reset(self):\n",
        "        self.apply(self.weight_init)\n",
        "        self.report['train_loss'] = []\n",
        "        self.report['train_acc'] = []\n",
        "        self.report['test_loss'] = []\n",
        "        self.report['test_acc'] = [] "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zqw4iQi7en0s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def to_binary(x):\n",
        "    return x%2==0\n",
        "\n",
        "def to_one_hot(x):\n",
        "    one_hot = np.zeros((x.size, x.max()+1))\n",
        "    one_hot[np.arange(x.size), x] = 1\n",
        "    return one_hot\n",
        "\n",
        "class MNISTDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, train=True):\n",
        "        if train:\n",
        "            (x_train, y_train), _ = mnist.load_data()\n",
        "            self.X = torch.from_numpy((x_train/255).reshape(-1, 784).astype('float32'))\n",
        "            self.y = torch.from_numpy((y_train/9).reshape(-1, 1).astype('float32'))\n",
        "        else:\n",
        "            _, (x_test, y_test) = mnist.load_data()\n",
        "            self.X = torch.from_numpy((x_test/255).reshape(-1, 784).astype('float32'))\n",
        "            self.y = torch.from_numpy((y_test/9).reshape(-1, 1).astype('float32'))\n",
        "            \n",
        "    def __getitem__(self, index):\n",
        "        return self.X[index], self.y[index]\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.X.shape[0]\n",
        "\n",
        "class MNISTDatasetB(torch.utils.data.Dataset):\n",
        "    def __init__(self, train=True):\n",
        "        if train:\n",
        "            (x_train, y_train), _ = mnist.load_data()\n",
        "            y_train = to_binary(y_train)\n",
        "            self.X = torch.from_numpy((x_train/255).reshape(-1, 784).astype('float32'))\n",
        "            self.y = torch.from_numpy((y_train).reshape(-1, 1).astype('float32'))\n",
        "        else:\n",
        "            _, (x_test, y_test) = mnist.load_data()\n",
        "            y_test = to_binary(y_test)\n",
        "            self.X = torch.from_numpy((x_test/255).reshape(-1, 784).astype('float32'))\n",
        "            self.y = torch.from_numpy((y_test).reshape(-1, 1).astype('float32'))\n",
        "            \n",
        "    def __getitem__(self, index):\n",
        "        return self.X[index], self.y[index]\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.X.shape[0]\n",
        "\n",
        "class MNISTDatasetC(torch.utils.data.Dataset):\n",
        "    def __init__(self, one_hot=False, train=True):\n",
        "        if train:\n",
        "            (x_train, y_train), _ = mnist.load_data()\n",
        "            if one_hot:\n",
        "                y_train = to_one_hot(y_train)\n",
        "                self.y = torch.from_numpy((y_train).reshape(-1, 10).astype('float32'))\n",
        "            else:\n",
        "                self.y = torch.from_numpy((y_train)).long()\n",
        "            self.X = torch.from_numpy((x_train/255).reshape(-1, 784).astype('float32'))\n",
        "        else:\n",
        "            _, (x_test, y_test) = mnist.load_data()\n",
        "            if one_hot:\n",
        "                y_test = to_one_hot(y_test)\n",
        "                self.y = torch.from_numpy((y_test).reshape(-1, 10).astype('float32'))\n",
        "            else:\n",
        "                self.y = torch.from_numpy((y_test)).long()\n",
        "            self.X = torch.from_numpy((x_test/255).reshape(-1, 784).astype('float32'))\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        return self.X[index], self.y[index]\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.X.shape[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ewcRulUJo-34",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "RMSprop = (torch.optim.RMSprop, {'alpha':0.99, 'eps':1e-08,\n",
        "                                 'momentum':0, 'centered':False})\n",
        "Adam = (torch.optim.Adam, {'betas':(0.9, 0.999), 'eps':1e-08,\n",
        "                           'amsgrad':False})\n",
        "Adadelta = (torch.optim.Adadelta, {'rho':0.9, 'eps':1e-06})\n",
        "Adagrad = (torch.optim.Adagrad, {'lr_decay':0, 'initial_accumulator_value':0,\n",
        "                                'eps':1e-10})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nHnRrcOJk-1Q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "cef5917e-ceb8-404d-8536-9aa501c8c7a1"
      },
      "source": [
        "epochs = 20\n",
        "batch_size = 256\n",
        "\n",
        "traindata = MNISTDatasetC()\n",
        "testdata = MNISTDatasetC(train=False)\n",
        "traindata = torch.utils.data.DataLoader(dataset=traindata, \n",
        "                                           batch_size=batch_size, \n",
        "                                           shuffle=True)\n",
        "testdata = torch.utils.data.DataLoader(dataset=testdata, \n",
        "                                          batch_size=batch_size, \n",
        "                                          shuffle=False)\n",
        "\n",
        "mynet = NeuralNet(784, 10, nn.LogSoftmax(dim=1)).to(device)\n",
        "mynet.reset()\n",
        "mynet.learn(nn.NLLLoss(), epochs, traindata, testdata, optimizer=RMSprop,\n",
        "            r_lambda=1e-3, eta=0.002)\n",
        "\n",
        "plt.plot(np.arange(epochs), mynet.report['train_acc'], label=\"train\")\n",
        "plt.plot(np.arange(epochs), mynet.report['test_acc'], label=\"test\")\n",
        "\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# regression \n",
        "# train loss:0.27970338 train acc:0.65 test loss:0.28329675 test acc:0.67\n",
        "\n",
        "# binary classification\n",
        "# train loss:0.02197217 train acc:0.95 test loss:0.05292147 test acc:0.87: Linear\n",
        "# train loss:0.01843358 train acc:0.95 test loss:0.01552843 test acc:0.96: Sigmoid + huber\n",
        "# train loss:0.07190176 train acc:0.98 test loss:0.09157893 test acc:0.97: Sigmoid + BCE\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████|20/20[00:52<00:00, 2.63s/it] train loss:0.12794790 train acc:0.96 test loss:0.21182963 test acc:0.94: \n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rduwBlI2C0cY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 465
        },
        "outputId": "53e19f12-0701-42a3-f3c4-970d81d1c711"
      },
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "\n",
        "c = 10\n",
        "for imgs, labels in testdata:\n",
        "    for img, label in zip(imgs, labels):\n",
        "        x, y = (img).to(device), (label).to(device)\n",
        "        img = (img.reshape(28,28,1) * 255).numpy().astype('uint8')\n",
        "        cv2_imshow(img)\n",
        "        with torch.no_grad():\n",
        "            out = mynet(x.reshape(-1, 28*28))\n",
        "            print(torch.argmax(out))\n",
        "            c -= 1\n",
        "        if c == 0:\n",
        "            break\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABkUlEQVR4nO3UvY4BURjG8WOtQqIxQqIQEolCI5OQ+I5EKapxC1PR6XUaF+AOuASNSzCKKRAfI4IIkSAojuCxhewWZhKz62zn382bd345xcwh5N07phnUo1wuJ4riYrGglNZqteVyORqNXkXH47HH4/l5PBwOnU5H8+X5fF6pVCRJeph/qldFUQwEAt1u1+/38zyfSqXC4fBsNnO5XPeFy+WyXq+dTichZDqdqlGNkz5ktVp5npckKRQK3SeU0sFg0Ov1OI4rFArVavUpoitBEK7XqyzLHMexER0Ox2q1ut1ugiBoLnz8Ac3n83a7fbvd9vv91473XSwWO51OAJLJJBuREFIulwE0m02TycRGNJvN7XabUhqNRtmIhJBSqQSg0WgwEzOZzPl83u12kUiEjWiz2RRFAVCv19mIRqOx1WoBGA6HXq+XDerz+QAAyGazbES32z2ZTAAUi0WD4fldoav7hwkgGAyyEROJxH6//y365N+Px+MWi4UQoijK8XjUiWpc0upkWU6n05vNRif6L30Ba8S1kC+UbMgAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F335C0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(7, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABq0lEQVR4nO2VO4vCQBDH545LQBHEWEgaFSwFq/Ri76MR/ByCD0ivldraaWEVRAn2FoIkFiK4IIKVXdTOJorriMWCyMlFiSkO7v7VzoPfzLAvgD+tD+twoVBwuVyxWCybzQJAs9nUdb3T6dgvqCgKPmi1WgWDQQeIi8Wi0WioqspMWZbtECVJOp1OiEgICYfDHo8HAHien81miFir1exAU6kUpZQQIorizSnL8vF4RMREImEHCgChUEgQhHvPfD5n49uHflOxWDwcDoioaZrb7XaAmEwmGdEwjHg8/jT/8xWoJEk8zwOAoiij0ejdHgFAVVXTNBGx3W6zY/CuRFHc7XaIuN1uI5GIA0QA0DSN7Xi9XneGmE6n2cEcDofODO73+yeTicNtVqtVRuz1es60CQBscES8v6kv6utphiAIlNKbud/vKaUcx3m9XgDw+Xz5fJ6FELFcLpum+RxKCLk3u92uYRiBQCCXyz0mbzabSqXy48vf7/czmYx1vfP5fLlcAGAwGEynUwAYj8e6rlt9J6VSieM4to5Go7fWWq3Wer1mhZfLpXXhf/1iXQEBYPmer6PclwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F309E8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(2, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABGUlEQVR4nO2PMaqDQBRFHxEhTDoLtdMqqQZJaREC2mUVbsB1CAHb7EGYwlWICFNnOhsDAZEQSJHG5y9+KcTxO/CbnPq+w3kAX/6d7XaLiHEcf9is5kr3+z0i3m63BWEjkiR5Pp8qjZTS1+t1uVw+z+a9v9vtCCFZli0IG1FVVV3Xm81GmdF1XUQUQkwuZ7x/PB4BoG1blVJKKQCcz2f5kwl83++6jnO+Xq8nx7KlYRgahiGEeL/fyqSe5w3DwBiT3E9j2/b9fr9er5J7qdIoikzTLMtSpdRxHAB4PB6SUimapkHEIAgk99Olh8PBsqxlVSPSNEVEzrmmaZInE6WEkNPpBACMsb7vlwb+out6URR5nhNC1Bi//I0fXzdfFqFsUAMAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F30748>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(1, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABmUlEQVR4nO2UsarCMBSGNVwXXe1qhCI+gFAn09F2EHwNEYW+gY5CEaHg7Avo2EkXXdTNSZTWQSSCq+Mh6FBubmlvbxsR7uK/neTvl5P2/E2lPvoX5XK58XjMGNtutxjj90BLpRIAAABjrN1ux/pRrEOSpMlkItTE19/b3W632WwqisJXCCEIod1ut1wuhU76EWMMfOKl4ziVSuUVom3bj8eD+XS73U6nEy+Fiaqquq7r79SyrEajQQjp9XreSqvVEiAWi8Xr9crv6zjOYDDIZrPeLsaYUgoA9/vdMIxMJpMI6p+h+Xyez+cDhk6nw4+UZVkMutlsCoVC2IAxXq/XUdDIOUUIIYSq1er5fA7vptNp9K1+v5+oU9M0vU6jDK9c/3A4REElSVJVlX9GSumv70cMOhqN+JC5rlur1cKemJgGZNt2uVzm5X6/X61WSR8+Ho9eZnRd13X9crl4ZSBgQg2lDMMIhD1cWpYlBuWZCUMppYvFQpZlHjABEUKGw2EYmuQnHSNN02azGQBMp9N6va5pWtIB+ui9egK2cH+krlU9uwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F309E8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(0, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABr0lEQVR4nO2UsYrqQBSGTy6RGBWEgDYiCqkMplCwsNRCwcJGO99ACx/Bzkb0FcQuip1YCj5AGtHGQtDKKVIJEtEZZovAsqwz0Vm2uvd+RSDzn/lyJpMMwH/+BvL5/PF4ZEaVSiWZTDKjP/7SarWqKAozqtfrg8FAWCrLcq1W46W2bRuGEQ6HxaSlUqlYLI7HY2aqaZphGKFQyMfwHdM0HcfZ7/eRSIRZsF6vMcaxWExAalmW67qFQoHXJqWUECIgbTabl8tlu93yCobDISFktVoFAoF3pdPpFGPcbreZaTqdRgjd7/dyufyuMRqNnk4njDGvoN/vY4x91sHYfUVREomEZVm8ObquA8But3u3TQBQVdW27c1mo2nacxqPxwkhhJBOp8MzyM9DruseDodGo7FcLkej0ed4NpvVdT2VSlFKAcC7CpDJZGaz2fV6xV9ACJ3P58fj4d2qqsqbLvmoc7mc9/o85vM5AEwmk1arBQCyzFjlD+n1el6npmnyaoSfJkmSJEkA4PNJCUsppS+36MV5+kwwGASA2+0mOtEPhJDjON1u9zeli8VC4Jf/J/kAsJy0J0vfqC0AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F30748>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(4, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABJklEQVR4nO2QsaqDMBSGj9oindMxow/gkiV0Ljh0yGMUX8H38AGkD9BVV7eAQ+dCQTehQrdQ9XiHQCkd2lAz3Xu/6UDO+fj/APzzO9ntdogYx7HneXaMhJCmaRAREVerlR2pEEIbD4eD4zgWjL7vSym1NIoiC0YAYIxp4/1+f7/pmkuFEHrI8/z7aC+UZYmISqkwDO0YOee6+/V6/bhsWp8xpoc0Tb+P9kKWZYjYdR2l1I5xs9kMw4CIl8vFZN+oPiHEdV0AKIpiVrpnHt0fPzsXSqnufjqdDE8+1+ec6+7H43FWumf2+z0itm27Xq8NTz4n3W63AFDX9e12syNdLpdBEACAUqrveztSRJRSAsD5fDY0AsDi/fM4jkmSTNNUVZW59I/zAy1IjoR8lotXAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F309E8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(1, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABuUlEQVR4nO2Tv8txYRjHr55eSjpJcUwkMkmJxSIWUjKaGAwG/4BdnbIYDaKccDIoFqPyYzIhZmzqqJNyyqSuyzOcenqH95zn6DnL+/Z+t/u+vn361HXfAP/z14dl2dVqVa/XvV6vWsdms+VyOZPJpItot9slSXo+n6PRSIN4Op1kWQ4EAt8THQ7HfD5HxGazqVFrNBqIWC6XdWmm02lERESn06nWCQaDRDSZTBiG+Z7Ismy73UbEUqmkQRRFkYiKxaIuTUEQXq/XZrOxWq1qnUqlQkQ8z+siAsBgMEDE6XT6x51aLBaO4263GyKqEX6pDbLZ7Gw2u9/vrVbr6zKRSCSTyVgsBgDj8VivJgBEo9HL5aIsiojwt3wdj8ej3+9/w3S73YZCoXA4nMlkqtWqJEn9fl8ZCYJwOBwAYL1en8/nN0w14vP5iGi322k8tbfT6/UQMZVKGUbM5/NEJMtyJBIxDMrzPBENh0PDiAAgiuLj8TBSU/lC1+vVMCIA7Pd7ROx2uwDAMIzH49Eof7yFRsRCobBcLjmO+5GjEsVU+VGdTsftdhsAjcfji8WiVqu5XC6z2WwA8d/NJyPm4mFTBiHoAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F30748>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(4, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABpUlEQVR4nO3TLasyQRTA8YOg7oJsWBEMokERMYjBj2ATNCmKza+w3Wj0JQimBYOTBPPatmkzihtWLAZ1UVhFlHPmBkFuuN6wz/Ck+0/DDPzCGQ7AX399TlGU4XBomqbf7xcjNpvN7XaLiIgYDocFiLFY7HA4ENELZYypqvqvaL/fR8Q3ioiO42iaFggEPIqJROJyuSDiarUyDOPt7vf7aDTqEa1UKkRkmiYASJLUarUsyyIizvlyufx9Dr5PD8FgkHPe6/UA4H6/67puWRbnnHN+u90ej4cXtNFoAECpVHrfFAqF12GxWLiu+wv6sVqt9hpoJpOpVquMsefzeTqdiOh4PGazWS+oqqqO43z/fcMwUqnUer1GxNFo5AUFgGKxeD6fOedENBgMJEkCgE6nQ0S2bSeTSe+uruvdbjcUCr1uZFmezWaIOB6PPaI/Vq/XEXG32wlYsHc+n48xhojtdlsYCgD5fP56vSJiOp0W6WqaRkTT6VSWZWFoJBLZbDZElMvlhKEAEI/HiWgymYhEAWA+n7uu63HBPqUoim3b5XJZJPr/+gKWK/X5t4s6oAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F309E8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(9, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABzklEQVR4nO2Uz8spURjHz+WmGCUlNtNJWVohG1sbpfwF/A3YWSgWrJQVNfaK3aQsJEtlbExqhMmPlPJjp8zImGfcxXQl73VjXsv3s3p6OufT9zmdcxD64dP80rDHarVijNV6tVolk0mO43ieHw6HWiKEw+FKpTKdTuEv4/FYFEW1fs/lcrmKxeLxeJRlGZ5zW//7FSlJkvF4/Gt/MpmMRqOv/adSm82WSCS63W6r1ZIk6XA4CIJAEES73eY4rt/vsyx7Op0EQXglFkIIEQQxGAwAIBKJqB2n04kQwhjrdLpXLfcYDIZGowEAuVzOZDJpUTxgNpvz+TwA7HY7i8XyASNCKBqNAsByuSRJUrPk8YACgQBCiGXZ9Xr9rXT37Pd7ABBFMZPJeDwebZLHZ3q9XhVFUWtFUSiKYhgGYzybzdQr6Xa7e73ee3MUCoX/vBmV7XZbr9ffkOr1er/fz/P8YrG4XC7PvLIsp9PpN7w3gsFgKBRiGOafXpqmtUhVUqkUAJzPZ4qifD5ftVr9gNTr9d7SdTqd20dVKpW0S41GY61Wux9ckiSapgmC0C5FCDkcjmazudlsAGA+n2ez2W/p7onFYuVy2W63f8z4w+v8Ac6uZGUupqg9AAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F30748>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(6, device='cuda:0')\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAACB0lEQVR4nO3Tva/pYBwH8Oemx1uQGJyIzWAggo2hS2MQk0RisjIYLBIRMYgEg8Wq1g4Wgz/AYGuM6GiQUkOFpC0h1PM8d2gi7j33XuceHc93fX759NvnBYDvfEfX/PjknNfrdTqdqVSKoiiEEE3TLMsuFosvfjYYDNI0vd1u0a+5Xq8cx3W7XaPR+B9cKBTq9XqSJGnKer3u9/utVktV1clkghDabDY8z+fz+c+KvV7v3m40GnU6HbPZrC2Nx2Ofz8ey7Ol0Wi6XEML39/cnnNlsrtVqEEKEkCiK9XrdarU+Dszn80AgEI/H71vxHE0kEofDASEkCEIkEnlcIgjC4/GUSiWe5xVFQQhhjBmGMRgMj2NvH1GCICCEAABVVaPRaDqd9vl8AIDz+ez3+/1+/263c7lc2rAois1mU1XVJ00tFstwODwejxBCjLH2g6qq/nb6t9ttMBi43e6Pwl/vqcPhqFQqJEnu9/vVamUymcLh8ONu0DRdrVYlSXrS8d9hGEbrKMtyNpslCOIlDgBQLpev16uGZjKZVzkAQC6X084aIcRxnMlkelWMRCKyLGuioigkSepQs9FoaOLxeKQoSgfRbrdfLhcNpWlaB9FmswmCoInT6fT+9l9KMpm8X/5YLKaDCACYzWaa2G639REBAOv1GmMsiuIf3+IXUywWMcaFQkE38ZX8BPsRV1ef4T8ZAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=28x28 at 0x7FD099F309E8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "tensor(9, device='cuda:0')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JFh7AnzWFn-j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ToyNet(nn.Module):\n",
        "    def __init__(self, seed=43):\n",
        "        super(ToyNet, self).__init__()\n",
        "        torch.manual_seed(seed)\n",
        "        torch.cuda.manual_seed(seed)\n",
        "\n",
        "        self.toy = nn.Linear(1, 1)\n",
        "\n",
        "        self.sigmoid = nn.Sigmoid()\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out = self.toy(x)\n",
        "        out = self.sigmoid(out)\n",
        "        return out\n",
        "\n",
        "    def learn(self, criterion, epochs, toydata, eta=0.001, verbos=1):\n",
        "\n",
        "        optimizer = torch.optim.SGD(self.parameters(), lr=eta, momentum=0.9)\n",
        "\n",
        "        t = tqdm(range(epochs), disable=(not verbos), position=0, leave=True)\n",
        "        for i in t:\n",
        "            for step, (x, y) in enumerate(toydata):\n",
        "                x, y = x.to(device), y.to(device)\n",
        "                out = self(x)\n",
        "                loss = criterion(out, y)\n",
        "                \n",
        "                optimizer.zero_grad()\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "\n",
        "    def weight_init(self, m):\n",
        "        if isinstance(m, nn.Linear):\n",
        "            nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu'))\n",
        "            nn.init.zeros_(m.bias)\n",
        "\n",
        "    def reset(self):\n",
        "        self.apply(self.weight_init)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cz4U9ZjGgeW9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ToyDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self):\n",
        "        x = np.array([0.0])\n",
        "        y = np.array([1.0])\n",
        "        self.X = torch.from_numpy((x).reshape(-1, 1).astype('float32'))\n",
        "        self.y = torch.from_numpy((y).reshape(-1, 1).astype('float32'))\n",
        "            \n",
        "    def __getitem__(self, index):\n",
        "        return self.X[index], self.y[index]\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.X.shape[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NCknYxlfg2Pl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "77264562-eb45-4292-e83d-81a65671100d"
      },
      "source": [
        "epochs = 100\n",
        "\n",
        "toydata = ToyDataset()\n",
        "toydata = torch.utils.data.DataLoader(dataset=toydata)\n",
        "\n",
        "mynet = ToyNet().to(device)\n",
        "mynet.reset()\n",
        "mynet.learn(nn.SmoothL1Loss(), epochs, toydata, eta=0.01)\n",
        "\n",
        "x = (torch.tensor([0.0])).to(device)\n",
        "print()\n",
        "print(mynet(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [00:00<00:00, 804.52it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "tensor([0.7049], device='cuda:0', grad_fn=<SigmoidBackward>)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    }
  ]
}