{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# MNIST" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import torch.optim as optim\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "from torchvision import datasets, transforms, utils\n", "from torch.autograd import Variable" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def show_batch(batch):\n", " im = utils.make_grid(batch)\n", " plt.imshow(np.transpose(im.numpy(), (1, 2, 0)))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "train_loader = torch.utils.data.DataLoader(datasets.MNIST('../mnist_data', \n", " download=True, \n", " train=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(), # first, convert image to PyTorch tensor\n", " transforms.Normalize((0.1307,), (0.3081,)) # normalize inputs\n", " ])), \n", " batch_size=10, shuffle=True)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "test_loader = torch.utils.data.DataLoader(datasets.MNIST('../mnist_data', \n", " download=True, \n", " train=False,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(), # first, convert image to PyTorch tensor\n", " transforms.Normalize((0.1307,), (0.3081,)) # normalize inputs\n", " ])), \n", " batch_size=10, shuffle=True)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "class CNNClassifier(nn.Module):\n", " def __init__(self):\n", " super(CNNClassifier, self).__init__()\n", " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", " self.dropout = nn.Dropout2d()\n", " self.fc1 = nn.Linear(320, 50)\n", " self.fc2 = nn.Linear(50, 10)\n", "\n", " def forward(self, x):\n", " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", " x = F.relu(F.max_pool2d(self.dropout(self.conv2(x)), 2))\n", " x = x.view(-1, 320)\n", " x = F.relu(self.fc1(x))\n", " x = F.dropout(x, training=self.training)\n", " x = self.fc2(x)\n", " \n", " return F.log_softmax(x, dim=1)\n", " \n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "clf = CNNClassifier()\n", "opt = optim.SGD(clf.parameters(), lr=0.01, momentum=0.9)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "train_size = 1000\n", "test_size = 100" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def train():\n", " clf.train()\n", " step_id = []\n", " test_losses = []\n", " test_accuracies = []\n", " train_losses = []\n", " train_accuracies = []\n", " \n", " for batch_id, (data, label) in enumerate(train_loader):\n", " if batch_id > train_size:\n", " break\n", " \n", " data = Variable(data)\n", " target = Variable(label)\n", " \n", " opt.zero_grad()\n", " preds = clf(data)\n", " loss = F.nll_loss(preds, target)\n", " loss.backward()\n", " opt.step()\n", " \n", " if batch_id % 100 == 0:\n", " step_id.append(batch_id)\n", " \n", " test_loss, test_acc = check(batch_id)\n", " test_losses.append(test_loss)\n", " test_accuracies.append(test_acc)\n", " \n", " train_loss, train_acc = check(batch_id, train=True)\n", " train_losses.append(train_loss)\n", " train_accuracies.append(train_acc)\n", "\n", " return step_id, test_losses, test_accuracies, train_losses, train_accuracies\n", "\n", "def check(step_id, train=False):\n", " clf.eval() # set model in inference mode (need this because of dropout)\n", " loss = 0\n", " batch_id = 0\n", " correct = 0\n", " keyword = \"test\"\n", " loader = test_loader\n", " \n", " if train:\n", " loader = train_loader\n", " keyword = \"train\"\n", " \n", " for data, target in loader:\n", " if batch_id > test_size:\n", " break\n", " \n", " with torch.no_grad():\n", " data = Variable(data) \n", " target = Variable(target)\n", " \n", " output = clf(data)\n", " correct += (torch.max(output.data, 1)[1] == target).sum()\n", " loss += F.nll_loss(output, target).item()\n", " batch_id += 1\n", "\n", " loss /= batch_id # loss function already averages over batch size\n", " acc = float(correct) / batch_id * loader.batch_size\n", " \n", " print(\"{0} step: {1} | loss: {2:.4f} | accuracy: {3:.4f}\".format(\n", " keyword,\n", " step_id,\n", " loss,\n", " acc\n", " ))\n", " \n", " return loss, acc" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "test step: 0 | loss: 2.3156 | accuracy: 2.6733\n", "train step: 0 | loss: 2.3125 | accuracy: 3.1683\n", "test step: 100 | loss: 0.5973 | accuracy: 80.0990\n", "train step: 100 | loss: 0.5346 | accuracy: 83.7624\n", "test step: 200 | loss: 0.4255 | accuracy: 85.8416\n", "train step: 200 | loss: 0.4913 | accuracy: 82.6733\n", "test step: 300 | loss: 0.3554 | accuracy: 88.4158\n", "train step: 300 | loss: 0.3324 | accuracy: 89.4059\n", "test step: 400 | loss: 0.2737 | accuracy: 90.4950\n", "train step: 400 | loss: 0.2891 | accuracy: 91.3861\n", "test step: 500 | loss: 0.2359 | accuracy: 92.0792\n", "train step: 500 | loss: 0.2491 | accuracy: 91.9802\n", "test step: 600 | loss: 0.2778 | accuracy: 92.2772\n", "train step: 600 | loss: 0.2523 | accuracy: 92.5743\n", "test step: 700 | loss: 0.2092 | accuracy: 93.5644\n", "train step: 700 | loss: 0.2833 | accuracy: 92.2772\n", "test step: 800 | loss: 0.3277 | accuracy: 91.8812\n", "train step: 800 | loss: 0.3238 | accuracy: 90.3960\n", "test step: 900 | loss: 0.2016 | accuracy: 94.6535\n", "train step: 900 | loss: 0.1831 | accuracy: 94.6535\n", "test step: 1000 | loss: 0.1458 | accuracy: 95.7426\n", "train step: 1000 | loss: 0.1661 | accuracy: 94.8515\n" ] } ], "source": [ "steps, test_losses, test_accuracies, train_losses, train_accuracies = train()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Графики зависимости потерь и точности от шага обучения" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(16, 6))\n", "\n", "ax1=plt.subplot(1, 2, 2)\n", "ax1.plot(steps, train_losses, label=\"train loss\")\n", "ax1.plot(steps, test_losses, label=\"test loss\")\n", "\n", "plt.ylabel(\"NLE loss\")\n", "plt.xlabel(\"step num\")\n", "plt.legend()\n", "\n", "ax2=plt.subplot(1, 2, 1)\n", "ax2.plot(steps, train_accuracies, label=\"train\")\n", "ax2.plot(steps, test_accuracies, label=\"test\")\n", "\n", "plt.ylabel(\"accuracy\")\n", "plt.xlabel(\"step num\")\n", "plt.legend\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Наложение шума" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def noised_data(disp):\n", " train_loader = torch.utils.data.DataLoader(\n", " datasets.MNIST('../mnist_data', \n", " download=True, \n", " train=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(), # first, convert image to PyTorch tensor\n", " transforms.Normalize((0.1307,), (0.3081,)), # normalize inputs\n", " transforms.Lambda(lambda x: x + torch.Tensor(x.shape).normal_(0, disp))\n", " ])), \n", " batch_size=10, shuffle=True\n", " )\n", "\n", " test_loader = torch.utils.data.DataLoader(\n", " datasets.MNIST('../mnist_data', \n", " download=True, \n", " train=False,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(), # first, convert image to PyTorch tensor\n", " transforms.Normalize((0.1307,), (0.3081,)), # normalize inputs\n", " transforms.Lambda(lambda x: x + torch.Tensor(x.shape).normal_(0, disp))\n", " ])), \n", " batch_size=10, shuffle=True)\n", " \n", " return train_loader, test_loader" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "test step: 0 | loss: 2.3050 | accuracy: 7.8218\n", "train step: 0 | loss: 2.3051 | accuracy: 7.2277\n", "test step: 100 | loss: 0.7230 | accuracy: 79.2079\n", "train step: 100 | loss: 0.7597 | accuracy: 78.8119\n", "test step: 200 | loss: 0.3936 | accuracy: 88.2178\n", "train step: 200 | loss: 0.4733 | accuracy: 85.9406\n", "test step: 300 | loss: 0.2314 | accuracy: 92.2772\n", "train step: 300 | loss: 0.2357 | accuracy: 92.9703\n", "test step: 400 | loss: 0.2481 | accuracy: 93.3663\n", "train step: 400 | loss: 0.2706 | accuracy: 91.7822\n", "test step: 500 | loss: 0.1727 | accuracy: 95.5446\n", "train step: 500 | loss: 0.1336 | accuracy: 95.5446\n", "test step: 600 | loss: 0.1631 | accuracy: 94.6535\n", "train step: 600 | loss: 0.1964 | accuracy: 93.4653\n", "test step: 700 | loss: 0.1804 | accuracy: 94.0594\n", "train step: 700 | loss: 0.2348 | accuracy: 92.1782\n", "test step: 800 | loss: 0.1886 | accuracy: 94.0594\n", "train step: 800 | loss: 0.2076 | accuracy: 93.8614\n", "test step: 900 | loss: 0.1270 | accuracy: 96.1386\n", "train step: 900 | loss: 0.1459 | accuracy: 95.5446\n", "test step: 1000 | loss: 0.1585 | accuracy: 95.3465\n", "train step: 1000 | loss: 0.1463 | accuracy: 96.6337\n", "test step: 0 | loss: 2.3074 | accuracy: 10.0000\n", "train step: 0 | loss: 2.3076 | accuracy: 8.9109\n", "test step: 100 | loss: 0.8277 | accuracy: 71.4851\n", "train step: 100 | loss: 0.8025 | accuracy: 71.3861\n", "test step: 200 | loss: 0.4096 | accuracy: 88.8119\n", "train step: 200 | loss: 0.3751 | accuracy: 89.4059\n", "test step: 300 | loss: 0.2473 | accuracy: 92.9703\n", "train step: 300 | loss: 0.2716 | accuracy: 92.3762\n", "test step: 400 | loss: 0.2613 | accuracy: 92.4752\n", "train step: 400 | loss: 0.2333 | accuracy: 92.0792\n", "test step: 500 | loss: 0.2486 | accuracy: 93.4653\n", "train step: 500 | loss: 0.2278 | accuracy: 93.0693\n", "test step: 600 | loss: 0.1431 | accuracy: 95.3465\n", "train step: 600 | loss: 0.1984 | accuracy: 94.1584\n", "test step: 700 | loss: 0.2199 | accuracy: 92.5743\n", "train step: 700 | loss: 0.2144 | accuracy: 93.8614\n", "test step: 800 | loss: 0.2306 | accuracy: 93.1683\n", "train step: 800 | loss: 0.2037 | accuracy: 92.4752\n", "test step: 900 | loss: 0.2168 | accuracy: 93.8614\n", "train step: 900 | loss: 0.2203 | accuracy: 92.7723\n", "test step: 1000 | loss: 0.1638 | accuracy: 94.5545\n", "train step: 1000 | loss: 0.1754 | accuracy: 94.7525\n", "test step: 0 | loss: 2.3041 | accuracy: 17.0297\n", "train step: 0 | loss: 2.3074 | accuracy: 16.9307\n", "test step: 100 | loss: 0.6731 | accuracy: 78.3168\n", "train step: 100 | loss: 0.7055 | accuracy: 76.3366\n", "test step: 200 | loss: 0.4103 | accuracy: 85.8416\n", "train step: 200 | loss: 0.3921 | accuracy: 84.7525\n", "test step: 300 | loss: 0.2703 | accuracy: 91.1881\n", "train step: 300 | loss: 0.3240 | accuracy: 89.9010\n", "test step: 400 | loss: 0.2650 | accuracy: 92.4752\n", "train step: 400 | loss: 0.2231 | accuracy: 92.9703\n", "test step: 500 | loss: 0.2657 | accuracy: 91.3861\n", "train step: 500 | loss: 0.2938 | accuracy: 91.1881\n", "test step: 600 | loss: 0.1974 | accuracy: 93.2673\n", "train step: 600 | loss: 0.1841 | accuracy: 93.9604\n", "test step: 700 | loss: 0.2167 | accuracy: 93.6634\n", "train step: 700 | loss: 0.1536 | accuracy: 94.8515\n", "test step: 800 | loss: 0.1682 | accuracy: 94.4554\n", "train step: 800 | loss: 0.1462 | accuracy: 96.0396\n", "test step: 900 | loss: 0.1138 | accuracy: 96.3366\n", "train step: 900 | loss: 0.1446 | accuracy: 95.3465\n", "test step: 1000 | loss: 0.2650 | accuracy: 93.0693\n", "train step: 1000 | loss: 0.2711 | accuracy: 93.2673\n", "test step: 0 | loss: 2.3199 | accuracy: 10.0000\n", "train step: 0 | loss: 2.3223 | accuracy: 9.5050\n", "test step: 100 | loss: 0.7317 | accuracy: 76.3366\n", "train step: 100 | loss: 0.8359 | accuracy: 73.2673\n", "test step: 200 | loss: 0.4111 | accuracy: 86.9307\n", "train step: 200 | loss: 0.4354 | accuracy: 84.6535\n", "test step: 300 | loss: 0.3767 | accuracy: 88.7129\n", "train step: 300 | loss: 0.3117 | accuracy: 89.4059\n", "test step: 400 | loss: 0.2833 | accuracy: 90.8911\n", "train step: 400 | loss: 0.3485 | accuracy: 89.7030\n", "test step: 500 | loss: 0.2704 | accuracy: 92.1782\n", "train step: 500 | loss: 0.2820 | accuracy: 91.4851\n", "test step: 600 | loss: 0.2025 | accuracy: 93.5644\n", "train step: 600 | loss: 0.2516 | accuracy: 92.0792\n", "test step: 700 | loss: 0.2398 | accuracy: 92.6733\n", "train step: 700 | loss: 0.2198 | accuracy: 92.8713\n", "test step: 800 | loss: 0.2110 | accuracy: 93.3663\n", "train step: 800 | loss: 0.2289 | accuracy: 92.4752\n", "test step: 900 | loss: 0.2384 | accuracy: 92.0792\n", "train step: 900 | loss: 0.2323 | accuracy: 94.0594\n", "test step: 1000 | loss: 0.2373 | accuracy: 93.1683\n", "train step: 1000 | loss: 0.2530 | accuracy: 92.2772\n", "test step: 0 | loss: 2.3243 | accuracy: 6.3366\n", "train step: 0 | loss: 2.3209 | accuracy: 4.7525\n", "test step: 100 | loss: 0.6502 | accuracy: 77.5248\n", "train step: 100 | loss: 0.6559 | accuracy: 77.9208\n", "test step: 200 | loss: 0.4712 | accuracy: 83.7624\n", "train step: 200 | loss: 0.4907 | accuracy: 85.1485\n", "test step: 300 | loss: 0.4522 | accuracy: 84.1584\n", "train step: 300 | loss: 0.4241 | accuracy: 85.8416\n", "test step: 400 | loss: 0.3996 | accuracy: 87.3267\n", "train step: 400 | loss: 0.4431 | accuracy: 85.3465\n", "test step: 500 | loss: 0.3483 | accuracy: 88.9109\n", "train step: 500 | loss: 0.4539 | accuracy: 87.5248\n", "test step: 600 | loss: 0.4028 | accuracy: 87.0297\n", "train step: 600 | loss: 0.3446 | accuracy: 89.1089\n", "test step: 700 | loss: 0.3051 | accuracy: 90.7921\n", "train step: 700 | loss: 0.3136 | accuracy: 89.0099\n", "test step: 800 | loss: 0.4096 | accuracy: 87.3267\n", "train step: 800 | loss: 0.4506 | accuracy: 86.1386\n", "test step: 900 | loss: 0.4134 | accuracy: 88.5149\n", "train step: 900 | loss: 0.3879 | accuracy: 88.1188\n", "test step: 1000 | loss: 0.2437 | accuracy: 93.1683\n", "train step: 1000 | loss: 0.2751 | accuracy: 92.2772\n", "test step: 0 | loss: 2.8023 | accuracy: 10.1980\n", "train step: 0 | loss: 2.8325 | accuracy: 10.1980\n", "test step: 100 | loss: 2.3001 | accuracy: 11.7822\n", "train step: 100 | loss: 2.3000 | accuracy: 13.0693\n", "test step: 200 | loss: 2.2979 | accuracy: 10.7921\n", "train step: 200 | loss: 2.3063 | accuracy: 10.8911\n", "test step: 300 | loss: 2.3019 | accuracy: 10.3960\n", "train step: 300 | loss: 2.3042 | accuracy: 11.5842\n", "test step: 400 | loss: 2.3052 | accuracy: 9.7030\n", "train step: 400 | loss: 2.3013 | accuracy: 11.3861\n", "test step: 500 | loss: 2.3087 | accuracy: 9.0099\n", "train step: 500 | loss: 2.3053 | accuracy: 12.3762\n", "test step: 600 | loss: 2.3042 | accuracy: 10.6931\n", "train step: 600 | loss: 2.3034 | accuracy: 10.4950\n", "test step: 700 | loss: 2.2989 | accuracy: 11.5842\n", "train step: 700 | loss: 2.3035 | accuracy: 12.3762\n", "test step: 800 | loss: 2.3012 | accuracy: 11.0891\n", "train step: 800 | loss: 2.3032 | accuracy: 11.7822\n", "test step: 900 | loss: 2.3038 | accuracy: 9.2079\n", "train step: 900 | loss: 2.3002 | accuracy: 10.2970\n", "test step: 1000 | loss: 2.3041 | accuracy: 9.2079\n", "train step: 1000 | loss: 2.3057 | accuracy: 9.6040\n" ] } ], "source": [ "disps = [0.1, 0.2, 0.4, 0.8, 1, 10]\n", "\n", "results = []\n", "for (disp_id, disp) in enumerate(disps):\n", " train_loader, test_loader = noised_data(disp)\n", " clf = CNNClassifier()\n", " opt = optim.SGD(clf.parameters(), lr=0.01, momentum=0.9)\n", "\n", " results.append(train())" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "plt.figure(figsize=(16, 16))\n", "\n", "subplot_index = 0\n", "\n", "for (disp_id, disp) in enumerate(disps):\n", " subplot_index += 1\n", " steps, test_losses, test_accuracies, train_losses, train_accuracies = results[disp_id]\n", " \n", " plt.subplot(len(disps), 2, subplot_index)\n", "# plt.plot(x, x ** disp_id)\n", " plt.plot(steps, train_losses, label=\"train loss\")\n", " plt.plot(steps, test_losses, label=\"test loss\")\n", " plt.title(\"losses, disp = {0}\".format(disp))\n", "\n", " plt.ylabel(\"NLE loss\")\n", " plt.xlabel(\"step num\")\n", " plt.legend()\n", " \n", " subplot_index += 1\n", "\n", " plt.subplot(len(disps), 2, subplot_index)\n", " plt.plot(steps, train_accuracies, label=\"train\")\n", " plt.plot(steps, test_accuracies, label=\"test\")\n", " plt.title(\"accuracy, disp = {0}\".format(disp))\n", " \n", " plt.ylabel(\"accuracy\")\n", " plt.xlabel(\"step num\")\n", " plt.legend()\n", " \n", " plt.subplots_adjust(hspace=0.6)" ] }, { "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.7.0" } }, "nbformat": 4, "nbformat_minor": 2 }