rnn_mnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as dsets\n",
    "\n",
    "import sys\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if cuda else \"cpu\")\n",
    "save_path = 'cache/models'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([60000, 28, 28])\n",
      "torch.Size([10000, 28, 28])\n",
      "28 10\n",
      "number of epochs: 17\n"
     ]
    }
   ],
   "source": [
    "train_dataset = dsets.MNIST(root='./data', \n",
    "                            train=True, \n",
    "                            transform=transforms.ToTensor(),\n",
    "                            download=True)\n",
    "test_dataset = dsets.MNIST(root='./data', \n",
    "                           train=False, \n",
    "                           transform=transforms.ToTensor())\n",
    "print(train_dataset.data.size())\n",
    "print(test_dataset.data.size())\n",
    "\n",
    "p = train_dataset.data.size()[1]\n",
    "num_cls = len(set(train_dataset.targets.numpy()))\n",
    "print(p, num_cls)\n",
    "\n",
    "batch_size = 100\n",
    "n_iters = 10000\n",
    "num_epochs = int(n_iters / (len(train_dataset) / batch_size))+1\n",
    "print('number of epochs: {}'.format(num_epochs))\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, \n",
    "                                           batch_size=batch_size, \n",
    "                                           shuffle=True)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, \n",
    "                                          batch_size=batch_size, \n",
    "                                          shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNNModel(\n",
      "  (rnn): RNN(28, 100, num_layers=2, batch_first=True)\n",
      "  (fc): Linear(in_features=100, out_features=10, bias=True)\n",
      ")\n",
      "10\n",
      "torch.Size([100, 28])\n",
      "torch.Size([100, 100])\n",
      "torch.Size([100])\n",
      "torch.Size([100])\n",
      "torch.Size([100, 100])\n",
      "torch.Size([100, 100])\n",
      "torch.Size([100])\n",
      "torch.Size([100])\n",
      "torch.Size([10, 100])\n",
      "torch.Size([10])\n"
     ]
    }
   ],
   "source": [
    "class RNNModel(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):\n",
    "        super(RNNModel, self).__init__()\n",
    "        # Hidden dimensions\n",
    "        self.hidden_dim = hidden_dim\n",
    "\n",
    "        # Number of hidden layers\n",
    "        self.layer_dim = layer_dim\n",
    "\n",
    "        # Building your RNN\n",
    "        # batch_first=True causes input/output tensors to be of shape\n",
    "        # (batch_dim, seq_dim, feature_dim)\n",
    "        self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='tanh')\n",
    "\n",
    "        # Readout layer\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Initialize hidden state with zeros\n",
    "        #######################\n",
    "        #  USE GPU FOR MODEL  #\n",
    "        #######################\n",
    "        h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).to(device)\n",
    "\n",
    "        # One time step\n",
    "        # We need to detach the hidden state to prevent exploding/vanishing gradients\n",
    "        # This is part of truncated backpropagation through time (BPTT)\n",
    "        out, hn = self.rnn(x, h0.detach())\n",
    "\n",
    "        # Index hidden state of last time step\n",
    "        # out.size() --> 100, 28, 100\n",
    "        # out[:, -1, :] --> 100, 100 --> just want last time step hidden states! \n",
    "        out = self.fc(out[:, -1, :]) \n",
    "        # out.size() --> 100, 10\n",
    "        return out\n",
    "\n",
    "input_dim = 28\n",
    "hidden_dim = 100\n",
    "layer_dim = 2  # ONLY CHANGE IS HERE FROM ONE LAYER TO TWO LAYER\n",
    "output_dim = 10\n",
    "\n",
    "model = RNNModel(input_dim, hidden_dim, layer_dim, output_dim)\n",
    "model.to(device)\n",
    "\n",
    "# JUST PRINTING MODEL & PARAMETERS \n",
    "print(model)\n",
    "print(len(list(model.parameters())))\n",
    "for i in range(len(list(model.parameters()))):\n",
    "    print(list(model.parameters())[i].size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNNModel(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):\n",
    "        super(RNNModel, self).__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.layer_dim = layer_dim\n",
    "        self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='tanh')\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).to(device)\n",
    "        out, hn = self.rnn(x, h0.detach())\n",
    "        out = self.fc(out[:, -1, :])\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 500. Loss: 2.189953327178955. Accuracy: 30.09000015258789\n",
      " Best model saved.\n",
      "Iteration: 1000. Loss: 1.464716911315918. Accuracy: 52.5099983215332\n",
      " Best model saved.\n",
      "Iteration: 1500. Loss: 1.197921872138977. Accuracy: 60.38999938964844\n",
      " Best model saved.\n",
      "Iteration: 2000. Loss: 1.0363229513168335. Accuracy: 68.69000244140625\n",
      " Best model saved.\n",
      "Iteration: 2500. Loss: 0.6255834698677063. Accuracy: 76.91999816894531\n",
      " Best model saved.\n",
      "Iteration: 3000. Loss: 0.5705212950706482. Accuracy: 82.12999725341797\n",
      " Best model saved.\n",
      "Iteration: 3500. Loss: 0.5536036491394043. Accuracy: 86.5999984741211\n",
      " Best model saved.\n",
      "Iteration: 4000. Loss: 0.39299893379211426. Accuracy: 88.87999725341797\n",
      " Best model saved.\n",
      "Iteration: 4500. Loss: 0.2634774148464203. Accuracy: 90.4800033569336\n",
      " Best model saved.\n",
      "Iteration: 5000. Loss: 0.22030633687973022. Accuracy: 92.36000061035156\n",
      " Best model saved.\n",
      "Iteration: 5500. Loss: 0.2439391016960144. Accuracy: 93.6500015258789\n",
      " Best model saved.\n",
      "Iteration: 6000. Loss: 0.12624262273311615. Accuracy: 94.8499984741211\n",
      " Best model saved.\n",
      "Iteration: 6500. Loss: 0.16215141117572784. Accuracy: 94.6500015258789\n",
      "Iteration: 7000. Loss: 0.2833154797554016. Accuracy: 94.93000030517578\n",
      " Best model saved.\n",
      "Iteration: 7500. Loss: 0.06710797548294067. Accuracy: 95.05999755859375\n",
      " Best model saved.\n",
      "Iteration: 8000. Loss: 0.1914539933204651. Accuracy: 95.02999877929688\n",
      "Iteration: 8500. Loss: 0.24739862978458405. Accuracy: 95.8499984741211\n",
      " Best model saved.\n",
      "Iteration: 9000. Loss: 0.15410462021827698. Accuracy: 96.19999694824219\n",
      " Best model saved.\n",
      "Iteration: 9500. Loss: 0.20557960867881775. Accuracy: 95.18000030517578\n",
      "Iteration: 10000. Loss: 0.13346438109874725. Accuracy: 96.36000061035156\n",
      " Best model saved.\n"
     ]
    }
   ],
   "source": [
    "### Model Training\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "learning_rate = 0.01\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  \n",
    "\n",
    "# Number of steps to unroll\n",
    "seq_dim = 28  \n",
    "\n",
    "iter = 0\n",
    "best_acc = 0\n",
    "for epoch in range(num_epochs):\n",
    "    for i, (images, labels) in enumerate(train_loader):\n",
    "        model.train()\n",
    "        # Load images as tensors with gradient accumulation abilities\n",
    "        images, labels = images.view(-1, seq_dim, \n",
    "                                     input_dim).requires_grad_().to(device), labels.to(device)\n",
    "\n",
    "        # Clear gradients w.r.t. parameters\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # Forward pass to get output/logits\n",
    "        # outputs.size() --> 100, 10\n",
    "        outputs = model(images)\n",
    "\n",
    "        # Calculate Loss: softmax --> cross entropy loss\n",
    "        loss = criterion(outputs, labels)\n",
    "\n",
    "        # Getting gradients w.r.t. parameters\n",
    "        loss.backward()\n",
    "\n",
    "        # Updating parameters\n",
    "        optimizer.step()\n",
    "\n",
    "        iter += 1\n",
    "\n",
    "        if iter % 500 == 0:\n",
    "            model.eval()\n",
    "            # Calculate Accuracy         \n",
    "            correct = 0\n",
    "            total = 0\n",
    "            with torch.no_grad():\n",
    "                # Iterate through test dataset\n",
    "                for images, labels in test_loader:\n",
    "                    # Resize images\n",
    "                    images = images.view(-1, seq_dim, input_dim).to(device)\n",
    "\n",
    "                    # Forward pass only to get logits/output\n",
    "                    outputs = model(images)\n",
    "\n",
    "                    # Get predictions from the maximum value\n",
    "                    _, predicted = torch.max(outputs.data, 1)\n",
    "\n",
    "                    # Total number of labels\n",
    "                    total += labels.size(0)\n",
    "\n",
    "                    # Total correct predictions\n",
    "                    if cuda:\n",
    "                        correct += (predicted.cpu() == labels.cpu()).sum()\n",
    "                    else:\n",
    "                        correct += (predicted == labels).sum()\n",
    "\n",
    "            accuracy = 100 * correct.float() / total\n",
    "\n",
    "            # Print Loss\n",
    "            print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.item(), accuracy))\n",
    "            if accuracy > best_acc:\n",
    "                best_acc = accuracy\n",
    "                torch.save({'epoch': epoch,\n",
    "                            'model': model.state_dict(),\n",
    "                            'optimizer': optimizer.state_dict()\n",
    "                           }, '{}/rnn_iter_{}.pth'.format(save_path, iter))\n",
    "                print('\\r Best model saved.\\r')\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Load and use the best model\n",
    "bst_mdl = save_path+'/rnn_best.pth'\n",
    "model.load_state_dict(torch.load(bst_mdl)['model'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1., device='cuda:0', grad_fn=<MaxBackward1>)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "images[0].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 21%|██        | 21/100 [02:03<08:17,  6.30s/it]"
     ]
    }
   ],
   "source": [
    "### Feeding white-noise\n",
    "model.eval()\n",
    "\n",
    "batch_size = 10000\n",
    "all_size = 1000000\n",
    "iters = 100\n",
    "stats = {} # recording the bias\n",
    "noise = {}\n",
    "\n",
    "for i in range(num_cls):\n",
    "    stats[i] = 0\n",
    "    noise[i] = []\n",
    "\n",
    "with tqdm(total=iters, file=sys.stdout) as pbar:\n",
    "    for kk in range(iters):\n",
    "        z = torch.rand(all_size, p, p)\n",
    "        for k in range(0, all_size, batch_size):\n",
    "            with torch.no_grad():\n",
    "                cur_data = z[k:k+batch_size]\n",
    "                if cuda:\n",
    "                    cur_data = cur_data.cuda()\n",
    "                pred = model(cur_data).max(1)[1]\n",
    "\n",
    "            for i in range(num_cls):\n",
    "                noise[i].append(cur_data[pred == i].cpu())\n",
    "                stats[i] += (pred == i).sum().cpu()\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: tensor(1060840),\n",
       " 1: tensor(0),\n",
       " 2: tensor(617),\n",
       " 3: tensor(9562),\n",
       " 4: tensor(0),\n",
       " 5: tensor(0),\n",
       " 6: tensor(0),\n",
       " 7: tensor(2),\n",
       " 8: tensor(8622748),\n",
       " 9: tensor(306231)}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# acc = 96.36000061035156\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize\n",
    "for i in range(num_cls):\n",
    "    if stats[i] != 0:\n",
    "        print(i)\n",
    "        plt.imshow(torch.cat(noise[i]).mean(0))\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}