{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 学习微调已经预训练好的网络\n",
    "\n",
    "调整一个预训练好的VGG16网络，使其能够分类kaggle数据库中的猴子数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PACKAGE LOADING SUCCESSFUL...\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import time\n",
    "\n",
    "import PIL\n",
    "import sklearn\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torchviz\n",
    "import torchvision\n",
    "import torch.utils.data as torch_data\n",
    "\n",
    "sns.set()\n",
    "plt.rc('font', family='SimHei')\n",
    "plt.rc('axes', unicode_minus=False)\n",
    "assert torch.cuda.is_available(), Exception('CUDA IS NOT AVAILABLE!')\n",
    "print('PACKAGE LOADING SUCCESSFUL...\\n\\n')\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 加载预训练的模型用以定义自己的模型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从本地加载模型\n",
      "MyVGG16(\n",
      "  (vgg): Sequential(\n",
      "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): ReLU(inplace=True)\n",
      "    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (3): ReLU(inplace=True)\n",
      "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (6): ReLU(inplace=True)\n",
      "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (8): ReLU(inplace=True)\n",
      "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (11): ReLU(inplace=True)\n",
      "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (13): ReLU(inplace=True)\n",
      "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (15): ReLU(inplace=True)\n",
      "    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (18): ReLU(inplace=True)\n",
      "    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (20): ReLU(inplace=True)\n",
      "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (22): ReLU(inplace=True)\n",
      "    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (25): ReLU(inplace=True)\n",
      "    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (27): ReLU(inplace=True)\n",
      "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (29): ReLU(inplace=True)\n",
      "    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (classifier): Sequential(\n",
      "    (0): Linear(in_features=25088, out_features=512, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Dropout(p=0.5, inplace=False)\n",
      "    (3): Linear(in_features=512, out_features=256, bias=True)\n",
      "    (4): ReLU()\n",
      "    (5): Dropout(p=0.5, inplace=False)\n",
      "    (6): Linear(in_features=256, out_features=10, bias=True)\n",
      "    (7): Softmax(dim=1)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class MyVGG16(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyVGG16, self).__init__()\n",
    "\n",
    "        try:\n",
    "            vgg16 = torchvision.models.vgg16(pretrained=False)\n",
    "            vgg16.load_state_dict(torch.load('E:/MyResources/PyTorch深度学习入门与实战/Torch预训练模型/vgg16-397923af.pth'))\n",
    "            print('从本地加载模型')\n",
    "        except FileNotFoundError as e:\n",
    "            vgg16 = torchvision.models.vgg16(pretrained=True)\n",
    "            print('从网络获取模型')\n",
    "\n",
    "        vgg = vgg16.features\n",
    "        for p in vgg.parameters():  # 冻结特征提取层的参数，不进行更新\n",
    "            p.requires_grad_(False)\n",
    "\n",
    "        self.vgg = vgg\n",
    "        self.classifier = torch.nn.Sequential(\n",
    "            torch.nn.Linear(25088, 512),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Dropout(p=0.5),\n",
    "            torch.nn.Linear(512, 256),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Dropout(p=0.5),\n",
    "            torch.nn.Linear(256, 10),\n",
    "            torch.nn.Softmax(dim=1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.vgg(x)\n",
    "        x = torch.reshape(x, (x.shape[0], -1))\n",
    "        return self.classifier(x)\n",
    "\n",
    "\n",
    "my_vgg16 = MyVGG16()\n",
    "print(my_vgg16)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 训练数据的准备"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(train_data.targets)=1097, len(validation_data.targets)=272\n"
     ]
    }
   ],
   "source": [
    "train_transform = torchvision.transforms.Compose([\n",
    "    torchvision.transforms.RandomResizedCrop(224),\n",
    "    torchvision.transforms.RandomHorizontalFlip(p=0.5),\n",
    "    torchvision.transforms.ToTensor(),\n",
    "    torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "])\n",
    "\n",
    "validation_transform = torchvision.transforms.Compose([\n",
    "    torchvision.transforms.Resize(256),\n",
    "    torchvision.transforms.CenterCrop(224),\n",
    "    torchvision.transforms.ToTensor(),\n",
    "    torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "])\n",
    "\n",
    "train_data = torchvision.datasets.ImageFolder(\n",
    "    root='E:/MyResources/PyTorch深度学习入门与实战/程序（有数据）/data/chap6/10-monkey-species/training',\n",
    "    transform=train_transform,\n",
    ")\n",
    "\n",
    "validation_data = torchvision.datasets.ImageFolder(\n",
    "    root='E:/MyResources/PyTorch深度学习入门与实战/程序（有数据）/data/chap6/10-monkey-species/validation',\n",
    "    transform=validation_transform,\n",
    ")\n",
    "\n",
    "train_loader = torch_data.DataLoader(\n",
    "    dataset=train_data,\n",
    "    batch_size=32,\n",
    "    shuffle=True,\n",
    "    num_workers=2,\n",
    ")\n",
    "\n",
    "validation_loader = torch_data.DataLoader(\n",
    "    dataset=validation_data,\n",
    "    batch_size=32,\n",
    "    shuffle=True,\n",
    "    num_workers=2,\n",
    ")\n",
    "\n",
    "print(f'{len(train_data.targets)=}, {len(validation_data.targets)=}')\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 开始微调网络"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第1轮训练，耗时19.502秒。\n",
      "训练集损失：2.147，验证集损失：1.706，训练集精度：0.321，验证集精度：0.835。\n",
      "-------------------- \n",
      "\n",
      "第2轮训练，耗时18.160秒。\n",
      "训练集损失：1.819，验证集损失：1.536，训练集精度：0.678，验证集精度：0.952。\n",
      "-------------------- \n",
      "\n",
      "第3轮训练，耗时20.053秒。\n",
      "训练集损失：1.702，验证集损失：1.508，训练集精度：0.784，验证集精度：0.974。\n",
      "-------------------- \n",
      "\n",
      "第4轮训练，耗时18.104秒。\n",
      "训练集损失：1.645，验证集损失：1.485，训练集精度：0.834，验证集精度：0.978。\n",
      "-------------------- \n",
      "\n",
      "第5轮训练，耗时18.577秒。\n",
      "训练集损失：1.606，验证集损失：1.484，训练集精度：0.872，验证集精度：0.978。\n",
      "-------------------- \n",
      "\n",
      "第6轮训练，耗时18.712秒。\n",
      "训练集损失：1.601，验证集损失：1.483，训练集精度：0.870，验证集精度：0.985。\n",
      "-------------------- \n",
      "\n",
      "第7轮训练，耗时19.952秒。\n",
      "训练集损失：1.582，验证集损失：1.478，训练集精度：0.891，验证集精度：0.985。\n",
      "-------------------- \n",
      "\n",
      "第8轮训练，耗时18.402秒。\n",
      "训练集损失：1.587，验证集损失：1.477，训练集精度：0.881，验证集精度：0.985。\n",
      "-------------------- \n",
      "\n",
      "第9轮训练，耗时18.641秒。\n",
      "训练集损失：1.580，验证集损失：1.479，训练集精度：0.884，验证集精度：0.989。\n",
      "-------------------- \n",
      "\n",
      "第10轮训练，耗时19.492秒。\n",
      "训练集损失：1.546，验证集损失：1.481，训练集精度：0.930，验证集精度：0.978。\n",
      "-------------------- \n",
      "\n",
      "训练总计耗时：189.59948468208313秒。\n"
     ]
    }
   ],
   "source": [
    "net = my_vgg16.to('cuda')\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=0.0003)\n",
    "loss_func = torch.nn.CrossEntropyLoss().to('cuda')\n",
    "\n",
    "since = time.time()\n",
    "train_loss_all, train_accuracy_all = [], []\n",
    "validation_loss_all, validation_accuracy_all = [], []\n",
    "\n",
    "for epoch in range(10):\n",
    "    epoch_since = time.time()\n",
    "    train_loss, validation_loss, train_accuracy, validation_accuracy = 0, 0, 0, 0\n",
    "\n",
    "    net.train()\n",
    "    for step, (X, y) in enumerate(train_loader):\n",
    "        X, y = X.to('cuda'), y.to('cuda')\n",
    "        out = net(X)\n",
    "        predict = torch.argmax(out, dim=1)\n",
    "        loss = loss_func(out, y)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_loss += loss.item() * X.shape[0]\n",
    "        train_accuracy += torch.sum(predict == y)\n",
    "\n",
    "    net.eval()\n",
    "    for step, (X, y) in enumerate(validation_loader):\n",
    "        X, y = X.to('cuda'), y.to('cuda')\n",
    "        out = net(X)\n",
    "        predict = torch.argmax(out, dim=1)\n",
    "        loss = loss_func(out, y)\n",
    "        validation_loss += loss.item() * X.shape[0]\n",
    "        validation_accuracy += torch.sum(predict == y)\n",
    "\n",
    "    train_loss_all.append(train_loss / len(train_data.targets))\n",
    "    train_accuracy_all.append(train_accuracy / len(train_data.targets))\n",
    "    validation_loss_all.append(validation_loss / len(validation_data.targets))\n",
    "    validation_accuracy_all.append(validation_accuracy / len(validation_data.targets))\n",
    "\n",
    "    print(f'第{epoch + 1}轮训练，耗时{time.time() - epoch_since:.3f}秒。')\n",
    "    print(f'训练集损失：{train_loss_all[-1]:.3f}，验证集损失：{validation_loss_all[-1]:.3f}，'\n",
    "          f'训练集精度：{train_accuracy_all[-1]:.3f}，验证集精度：{validation_accuracy_all[-1]:.3f}。')\n",
    "    print('--' * 10, '\\n')\n",
    "\n",
    "print(f'训练总计耗时：{time.time() - since}秒。')\n",
    "del net, optimizer, loss_func, since, epoch, epoch_since, train_loss, validation_loss, train_accuracy, validation_accuracy,\\\n",
    "    step, X, y, out, predict, loss\n",
    "torch.cuda.empty_cache()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 可视化一下训练的结果"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x246c841ce80>"
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 720x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 720x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(train_loss_all, 'ro-', label='训练集损失')\n",
    "plt.plot(validation_loss_all, 'gs-', label='测试集损失')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(train_accuracy_all, 'ro-', label='训练集精度')\n",
    "plt.plot(validation_accuracy_all, 'gs-', label='测试集精度')\n",
    "plt.legend()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}