DataTraining.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tester():\n",
    "    # 本类用于图像测试，提供正确数、已测试数、错误索引列表、错误预测值列表、\n",
    "    # 错误对应字典供外部使用，同时train函数要传入模型、测试集、过程打印次数（默认6）\n",
    "    \n",
    "    def __init__(self):\n",
    "        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        model.eval()\n",
    "        self.eval_acc = 0\n",
    "        self.tested_num = 0\n",
    "        self.error_list=[]\n",
    "        self.wrong_pred=[]\n",
    "        self.wrong_dict={}\n",
    "        self.loss_list=[]\n",
    "        self.acc_list=[]\n",
    "        \n",
    "    def test(self, model, test_loader, print_interval=6):\n",
    "        for num, data in enumerate(test_loader): \n",
    "            img, label = data\n",
    "            label = label.long().to(device)   # load the testing data\n",
    "            img = img.to(device)\n",
    "\n",
    "            out = model(img)\n",
    "            loss = model.criterion(out, label)  # forward\n",
    "\n",
    "            _, pred = torch.max(out ,1)   # get the results\n",
    "\n",
    "            # the wrong-predicted number\n",
    "            self.wrong_pred.extend([pred[i].data.item() for i in range(len(pred)) if pred[i]!=label[i]])\n",
    "            # the index of the wrong prediction\n",
    "            self.error_list.extend([ i+self.tested_num for i in range(len(pred)) if pred[i]!=label[i] ])\n",
    "            self.loss_list.extend([loss.data.item()])\n",
    "           \n",
    "            num_correct = (pred == label).sum()    # count the correct numbers\n",
    "            self.tested_num += label.cpu().numpy().size  # count the tested numbers\n",
    "            self.eval_acc += num_correct.data.item()    # calculate the accuracy\n",
    "            self.acc_list.extend([self.eval_acc/ self.tested_num])\n",
    "            \n",
    "            if( num % int(len(test_loader.dataset)/((print_interval-1)*test_loader.batch_size)) == 0 ):\n",
    "                print('tested: {}/{}'.format(self.tested_num, len(test_loader.dataset)))\n",
    "                print('loss is {} '.format(loss.data.item()))\n",
    "                print('acc is {} '.format(self.eval_acc/ self.tested_num))\n",
    "                print('')\n",
    "        \n",
    "        self.wrong_dict = dict(zip(self.error_list, self.wrong_pred))\n",
    "        print(\"Total acc is {}\".format(self.eval_acc/ self.tested_num))\n",
    "        \n",
    "    def print_error_list(self):\n",
    "        print(self.error_list)\n",
    "        \n",
    "    def print_wrong_pred(self):\n",
    "        print(self.wrong_pred)\n",
    "        \n",
    "    def loss(self):\n",
    "        plt.figure(figsize=(10,6))\n",
    "        plt.plot(range(len(self.loss_list)), self.loss_list, 'bo')\n",
    "        plt.grid(True)\n",
    "        plt.title(\"Convergence of Loss Function\")\n",
    "        plt.xlabel(\"Iteration number\")\n",
    "        plt.ylabel(\"Cost function\")\n",
    "        # dummy = plt.xlim([-0.05*epoch,1.05*epoch])\n",
    "        # dummy = plt.ylim([7,45])\n",
    "        \n",
    "    def accuracy(self):\n",
    "        plt.figure(figsize=(10,6))\n",
    "        plt.plot(range(len(self.acc_list)), self.acc_list, 'ro')\n",
    "        plt.grid(True)\n",
    "        plt.title(\"Distribution of Accuracy\")\n",
    "        plt.xlabel(\"Iteration number\")\n",
    "        plt.ylabel(\"Accuracy\")\n",
    "        # dummy = plt.xlim([-0.05*epoch,1.05*epoch])\n",
    "        # dummy = plt.ylim([7,45])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer():\n",
    "    # 本类用于图像测试，提供正确数、已测试数、错误索引列表、错误预测值列表、\n",
    "    # 错误对应字典供外部使用，同时train函数要传入模型、测试集、过程打印次数（默认6）\n",
    "    \n",
    "    def __init__(self):\n",
    "        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        model.train()\n",
    "        self.eval_acc = 0\n",
    "        self.trained_num = 0\n",
    "        self.loss_list=[]\n",
    "        self.acc_list=[]\n",
    "        \n",
    "    def train(self, model, train_loader, epochs=1, print_interval=6):\n",
    "        for e in range(epochs):\n",
    "            self.trained_num=0\n",
    "            self.eval_acc=0\n",
    "            print('epoch: {}'.format(e+1))\n",
    "            for num, data in enumerate(train_loader): \n",
    "                img, label = data\n",
    "                label = label.long().to(device)   # load the testing data\n",
    "                img = img.to(device)\n",
    "\n",
    "                out = model(img)\n",
    "                loss = model.criterion(out, label)  # forward\n",
    "                \n",
    "                model.optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                model.optimizer.step()    # backward\n",
    "\n",
    "                _, pred = torch.max(out ,1)   # get the results\n",
    "\n",
    "                num_correct = (pred == label).sum()    # count the correct numbers\n",
    "                self.trained_num += label.cpu().numpy().size  # count the tested numbers\n",
    "                self.eval_acc += num_correct.data.item()    # calculate the accuracy\n",
    "                self.acc_list.extend([self.eval_acc/ self.trained_num])\n",
    "                self.loss_list.extend([loss.data.item()])\n",
    "\n",
    "                if( num % int(len(train_loader.dataset)/((print_interval-1)*train_loader.batch_size)) == 0 ):\n",
    "                    print('trained: {}/{}'.format(self.trained_num, len(train_loader.dataset)))\n",
    "                    print('loss is {} '.format(loss.data.item()))\n",
    "                    print('acc is {} '.format(self.eval_acc/ self.trained_num))\n",
    "                    print('')\n",
    "            \n",
    "            print(\"Total acc is {}\".format(self.eval_acc/ self.trained_num))\n",
    "   \n",
    "    def loss(self):\n",
    "        plt.figure(figsize=(10,6))\n",
    "        plt.plot(range(len(self.loss_list)), self.loss_list, 'bo')\n",
    "        plt.grid(True)\n",
    "        plt.title(\"Convergence of Loss Function\")\n",
    "        plt.xlabel(\"Iteration number\")\n",
    "        plt.ylabel(\"Cost function\")\n",
    "        # dummy = plt.xlim([-0.05*epoch,1.05*epoch])\n",
    "        # dummy = plt.ylim([7,45])\n",
    "        \n",
    "    def accuracy(self):\n",
    "        plt.figure(figsize=(10,6))\n",
    "        plt.plot(range(len(self.acc_list)), self.acc_list, 'ro')\n",
    "        plt.grid(True)\n",
    "        plt.title(\"Distribution of Accuracy\")\n",
    "        plt.xlabel(\"Iteration number\")\n",
    "        plt.ylabel(\"Accuracy\")\n",
    "        # dummy = plt.xlim([-0.05*epoch,1.05*epoch])\n",
    "        # dummy = plt.ylim([7,45])\n",
    "        \n",
    "    def save(self, file_name='./model_state1.pth'):\n",
    "        torch.save(model.state_dict(), file_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN( nn.Module ):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            nn.Conv2d(1, 16, kernel_size = 3),  # 26*26*16\n",
    "            nn.BatchNorm2d(16),\n",
    "            nn.ReLU(inplace=True))\n",
    "        self.layer2 = nn.Sequential(\n",
    "            nn.Conv2d(16, 32, kernel_size = 3),  # 24*24*32\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2)) # 12*12*32\n",
    "        self.layer3 = nn.Sequential(\n",
    "            nn.Conv2d(32, 64, kernel_size = 3),  # 10*10*64\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True))\n",
    "        self.layer4 = nn.Sequential(\n",
    "            nn.Conv2d(64, 128, kernel_size = 3),  # 8*8*128\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2))  # 4*4*128\n",
    "            \n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(128*4*4, 1024),\n",
    "            nn.ReLU(inplace = True),\n",
    "            nn.Linear(1024, 128),\n",
    "            nn.ReLU(inplace = True),\n",
    "            nn.Linear(128, 10))\n",
    "        \n",
    "    def forward(self, x):\n",
    "            x = self.layer1(x)\n",
    "            x = self.layer2(x)\n",
    "            x = self.layer3(x)\n",
    "            x = self.layer4(x)\n",
    "            x = x.view(x.size(0), -1)  # 每个批次中的每一个输入都拉成一个维度，这样N个输入就有N*（32*7*7）的输出即N*1568\n",
    "            x = self.fc(x)\n",
    "            return x\n",
    "    def set_criterion(self, criterion):\n",
    "        self.criterion = criterion\n",
    "    \n",
    "    def set_optimizer(self, optimizer):\n",
    "        self.optimizer = optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 256\n",
    "learning_rate = 1e-2\n",
    "epochs = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_tf = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize([0.5], [0.5])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = datasets.MNIST(\n",
    "    root='./data', train=True, \n",
    "    transform=data_tf, download=True )\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "test_dataset = datasets.MNIST(\n",
    "    root='./data', train=False,\n",
    "    transform=data_tf, download=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CNN().to(device)\n",
    "# model.load_state_dict(torch.load('model_state1.pth'))\n",
    "    \n",
    "model.set_criterion(nn.CrossEntropyLoss())\n",
    "model.set_optimizer(optim.Adam(model.parameters(), lr=learning_rate))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1\n",
      "trained: 256/60000\n",
      "loss is 2.296675205230713 \n",
      "acc is 0.12890625 \n",
      "\n",
      "trained: 30208/60000\n",
      "loss is 0.09739945083856583 \n",
      "acc is 0.6867055084745762 \n",
      "\n",
      "trained: 60000/60000\n",
      "loss is 0.14552386105060577 \n",
      "acc is 0.8247166666666667 \n",
      "\n",
      "Total acc is 0.8247166666666667\n",
      "epoch: 2\n",
      "trained: 256/60000\n",
      "loss is 0.12292638421058655 \n",
      "acc is 0.94921875 \n",
      "\n",
      "trained: 30208/60000\n",
      "loss is 0.0892307236790657 \n",
      "acc is 0.9765293961864406 \n",
      "\n",
      "trained: 60000/60000\n",
      "loss is 0.13127897679805756 \n",
      "acc is 0.9775166666666667 \n",
      "\n",
      "Total acc is 0.9775166666666667\n",
      "epoch: 3\n",
      "trained: 256/60000\n",
      "loss is 0.08539851009845734 \n",
      "acc is 0.9765625 \n",
      "\n",
      "trained: 30208/60000\n",
      "loss is 0.08660118281841278 \n",
      "acc is 0.9850039724576272 \n",
      "\n",
      "trained: 60000/60000\n",
      "loss is 0.1624564677476883 \n",
      "acc is 0.9859833333333333 \n",
      "\n",
      "Total acc is 0.9859833333333333\n",
      "epoch: 4\n",
      "trained: 256/60000\n",
      "loss is 0.015888534486293793 \n",
      "acc is 0.99609375 \n",
      "\n",
      "trained: 30208/60000\n",
      "loss is 0.018261006101965904 \n",
      "acc is 0.9874205508474576 \n",
      "\n",
      "trained: 60000/60000\n",
      "loss is 0.07117073982954025 \n",
      "acc is 0.9871833333333333 \n",
      "\n",
      "Total acc is 0.9871833333333333\n",
      "epoch: 5\n",
      "trained: 256/60000\n",
      "loss is 0.019980672746896744 \n",
      "acc is 0.9921875 \n",
      "\n",
      "trained: 30208/60000\n",
      "loss is 0.02216179668903351 \n",
      "acc is 0.988380561440678 \n",
      "\n",
      "trained: 60000/60000\n",
      "loss is 0.03798920288681984 \n",
      "acc is 0.9895833333333334 \n",
      "\n",
      "Total acc is 0.9895833333333334\n"
     ]
    }
   ],
   "source": [
    "inputs = Trainer()\n",
    "inputs.train(model, train_loader, epochs, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "inputs.accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tested: 256/10000\n",
      "loss is 0.029910005629062653 \n",
      "acc is 0.98828125 \n",
      "\n",
      "tested: 2048/10000\n",
      "loss is 0.051838114857673645 \n",
      "acc is 0.9833984375 \n",
      "\n",
      "tested: 3840/10000\n",
      "loss is 0.05697105824947357 \n",
      "acc is 0.9841145833333333 \n",
      "\n",
      "tested: 5632/10000\n",
      "loss is 0.001963285729289055 \n",
      "acc is 0.9849076704545454 \n",
      "\n",
      "tested: 7424/10000\n",
      "loss is 0.004537742584943771 \n",
      "acc is 0.9870689655172413 \n",
      "\n",
      "tested: 9216/10000\n",
      "loss is 0.0006924308836460114 \n",
      "acc is 0.9894748263888888 \n",
      "\n",
      "Total acc is 0.9896\n"
     ]
    }
   ],
   "source": [
    "result = Tester()\n",
    "result.test(model, test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "result.accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs.save()  # save the parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\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": [
    "data, label = test_dataset[115]\n",
    "x = data.view(28,28)\n",
    "plt.imshow(x, cmap='gray')\n",
    "print(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 提取中间层结果\n",
    "class Layer_Hook:\n",
    "    count=0\n",
    "    def __init__(self, layer):\n",
    "        for module in layer.modules():\n",
    "            if isinstance(module, nn.Conv2d):\n",
    "                self.count = module.out_channels\n",
    "        self.hook = layer.register_forward_hook(self.hook_fn)\n",
    "    \n",
    "    def hook_fn(self, module, input, output):\n",
    "        self.features = output\n",
    "    \n",
    "    def remove(self):\n",
    "        self.hook.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 64 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conv_out = Layer_Hook(model.layer3)\n",
    "img, label = test_dataset[151]\n",
    "label = torch.from_numpy(np.array(label))   # load the testing data\n",
    "img = img.view(1,1,28,28)    \n",
    "out = model(img.to(device))\n",
    "conv_out.remove()\n",
    "act = conv_out.features\n",
    "num = conv_out.count\n",
    "cols = 8\n",
    "\n",
    "fig = plt.figure(figsize=(20, 20))\n",
    "fig.subplots_adjust(left=0, right=1, bottom=0, top=0.8, hspace=0, wspace=0.2)\n",
    "for i in range(num):\n",
    "    ax = fig.add_subplot(int(num/cols)+1, cols, i+1, xticks=[], yticks=[])\n",
    "    ax.imshow(act[0][i].cpu().detach().numpy(), cmap='gray')"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}