120_利用GPU训练.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 利用GPU训练(方式一)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① GPU训练主要有三部分，网络模型、数据(输入、标注)、损失函数，这三部分放到GPU上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "训练数据集的长度：50000\n",
      "测试数据集的长度：10000\n",
      "-----第 1 轮训练开始-----\n",
      "训练次数：100，Loss：2.289992094039917\n",
      "训练次数：200，Loss：2.2927844524383545\n",
      "训练次数：300，Loss：2.2730984687805176\n",
      "训练次数：400，Loss：2.2006278038024902\n",
      "训练次数：500，Loss：2.1675028800964355\n",
      "训练次数：600，Loss：2.116072416305542\n",
      "训练次数：700，Loss：2.04477596282959\n",
      "整体测试集上的Loss：317.0560564994812\n",
      "整体测试集上的正确率：0.28700000047683716\n",
      "模型已保存\n",
      "-----第 2 轮训练开始-----\n",
      "训练次数：800，Loss：1.893830418586731\n",
      "训练次数：900，Loss：1.8772207498550415\n",
      "训练次数：1000，Loss：1.9800275564193726\n",
      "训练次数：1100，Loss：2.007078170776367\n",
      "训练次数：1200，Loss：1.7352533340454102\n",
      "训练次数：1300，Loss：1.6947956085205078\n",
      "训练次数：1400，Loss：1.756855845451355\n",
      "训练次数：1500，Loss：1.8372352123260498\n",
      "整体测试集上的Loss：299.94190883636475\n",
      "整体测试集上的正确率：0.31619998812675476\n",
      "模型已保存\n",
      "-----第 3 轮训练开始-----\n",
      "训练次数：1600，Loss：1.7673416137695312\n",
      "训练次数：1700，Loss：1.6654351949691772\n",
      "训练次数：1800，Loss：1.9246405363082886\n",
      "训练次数：1900，Loss：1.7132933139801025\n",
      "训练次数：2000，Loss：1.93990159034729\n",
      "训练次数：2100，Loss：1.4903961420059204\n",
      "训练次数：2200，Loss：1.4754142761230469\n",
      "训练次数：2300，Loss：1.7652970552444458\n",
      "整体测试集上的Loss：272.9526561498642\n",
      "整体测试集上的正确率：0.37139999866485596\n",
      "模型已保存\n",
      "-----第 4 轮训练开始-----\n",
      "训练次数：2400，Loss：1.7254819869995117\n",
      "训练次数：2500，Loss：1.3386430740356445\n",
      "训练次数：2600，Loss：1.5852587223052979\n",
      "训练次数：2700，Loss：1.648303508758545\n",
      "训练次数：2800，Loss：1.4971883296966553\n",
      "训练次数：2900，Loss：1.5891362428665161\n",
      "训练次数：3000，Loss：1.3380193710327148\n",
      "训练次数：3100，Loss：1.542701005935669\n",
      "整体测试集上的Loss：278.19843327999115\n",
      "整体测试集上的正确率：0.36139997839927673\n",
      "模型已保存\n",
      "-----第 5 轮训练开始-----\n",
      "训练次数：3200，Loss：1.3419318199157715\n",
      "训练次数：3300，Loss：1.468044400215149\n",
      "训练次数：3400，Loss：1.484485149383545\n",
      "训练次数：3500，Loss：1.54210364818573\n",
      "训练次数：3600，Loss：1.5797978639602661\n",
      "训练次数：3700，Loss：1.3390973806381226\n",
      "训练次数：3800，Loss：1.3077597618103027\n",
      "训练次数：3900，Loss：1.4766919612884521\n",
      "整体测试集上的Loss：269.36583971977234\n",
      "整体测试集上的正确率：0.3871999979019165\n",
      "模型已保存\n",
      "-----第 6 轮训练开始-----\n",
      "训练次数：4000，Loss：1.439847469329834\n",
      "训练次数：4100，Loss：1.436941146850586\n",
      "训练次数：4200，Loss：1.5766061544418335\n",
      "训练次数：4300，Loss：1.249019742012024\n",
      "训练次数：4400，Loss：1.164270281791687\n",
      "训练次数：4500，Loss：1.4175126552581787\n",
      "训练次数：4600，Loss：1.4056789875030518\n",
      "整体测试集上的Loss：252.13275730609894\n",
      "整体测试集上的正确率：0.4244000017642975\n",
      "模型已保存\n",
      "-----第 7 轮训练开始-----\n",
      "训练次数：4700，Loss：1.3679763078689575\n",
      "训练次数：4800，Loss：1.526027798652649\n",
      "训练次数：4900，Loss：1.3590809106826782\n",
      "训练次数：5000，Loss：1.4296003580093384\n",
      "训练次数：5100，Loss：0.9916519522666931\n",
      "训练次数：5200，Loss：1.3147145509719849\n",
      "训练次数：5300，Loss：1.2122020721435547\n",
      "训练次数：5400，Loss：1.3860883712768555\n",
      "整体测试集上的Loss：235.14292180538177\n",
      "整体测试集上的正确率：0.46209999918937683\n",
      "模型已保存\n",
      "-----第 8 轮训练开始-----\n",
      "训练次数：5500，Loss：1.2311736345291138\n",
      "训练次数：5600，Loss：1.2175472974777222\n",
      "训练次数：5700，Loss：1.2189043760299683\n",
      "训练次数：5800，Loss：1.2750414609909058\n",
      "训练次数：5900，Loss：1.3556095361709595\n",
      "训练次数：6000，Loss：1.5370352268218994\n",
      "训练次数：6100，Loss：1.025504231452942\n",
      "训练次数：6200，Loss：1.0661875009536743\n",
      "整体测试集上的Loss：222.47956597805023\n",
      "整体测试集上的正确率：0.4927999973297119\n",
      "模型已保存\n",
      "-----第 9 轮训练开始-----\n",
      "训练次数：6300，Loss：1.4051152467727661\n",
      "训练次数：6400，Loss：1.1392022371292114\n",
      "训练次数：6500，Loss：1.6226587295532227\n",
      "训练次数：6600，Loss：1.0815491676330566\n",
      "训练次数：6700，Loss：1.048026442527771\n",
      "训练次数：6800，Loss：1.1510660648345947\n",
      "训练次数：6900，Loss：1.1476961374282837\n",
      "训练次数：7000，Loss：0.9481611847877502\n",
      "整体测试集上的Loss：212.00453734397888\n",
      "整体测试集上的正确率：0.5181999802589417\n",
      "模型已保存\n",
      "-----第 10 轮训练开始-----\n",
      "训练次数：7100，Loss：1.2802095413208008\n",
      "训练次数：7200，Loss：0.9643581509590149\n",
      "训练次数：7300，Loss：1.098695993423462\n",
      "训练次数：7400，Loss：0.8831453323364258\n",
      "训练次数：7500，Loss：1.19520902633667\n",
      "训练次数：7600，Loss：1.2724679708480835\n",
      "训练次数：7700，Loss：0.8894400000572205\n",
      "训练次数：7800，Loss：1.205102801322937\n",
      "整体测试集上的Loss：202.72463756799698\n",
      "整体测试集上的正确率：0.54339998960495\n",
      "模型已保存\n"
     ]
    }
   ],
   "source": [
    "import torchvision\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里\n",
    "class Tudui(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Tudui, self).__init__()        \n",
    "        self.model1 = nn.Sequential(\n",
    "            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×5，步长1，填充2    \n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,32,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,64,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Flatten(),  # 展平后变成 64*4*4 了\n",
    "            nn.Linear(64*4*4,64),\n",
    "            nn.Linear(64,10)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.model1(x)\n",
    "        return x\n",
    "\n",
    "# 准备数据集\n",
    "train_data = torchvision.datasets.CIFAR10(\"./dataset\",train=True,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "test_data = torchvision.datasets.CIFAR10(\"./dataset\",train=False,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "\n",
    "# length 长度\n",
    "train_data_size = len(train_data)\n",
    "test_data_size = len(test_data)\n",
    "# 如果train_data_size=10，则打印：训练数据集的长度为：10\n",
    "print(\"训练数据集的长度：{}\".format(train_data_size))\n",
    "print(\"测试数据集的长度：{}\".format(test_data_size))\n",
    "\n",
    "# 利用 Dataloader 来加载数据集\n",
    "train_dataloader = DataLoader(train_data, batch_size=64)        \n",
    "test_dataloader = DataLoader(test_data, batch_size=64)\n",
    "\n",
    "# 创建网络模型\n",
    "tudui = Tudui() \n",
    "if torch.cuda.is_available():\n",
    "    tudui = tudui.cuda() # 网络模型转移到cuda上\n",
    "\n",
    "# 损失函数\n",
    "loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写\n",
    "if torch.cuda.is_available():\n",
    "    loss_fn = loss_fn.cuda()        # 损失函数转移到cuda上\n",
    "\n",
    "# 优化器\n",
    "learning = 0.01  # 1e-2 就是 0.01 的意思\n",
    "optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  \n",
    "\n",
    "# 设置网络的一些参数\n",
    "# 记录训练的次数\n",
    "total_train_step = 0\n",
    "# 记录测试的次数\n",
    "total_test_step = 0\n",
    "\n",
    "# 训练的轮次\n",
    "epoch = 10\n",
    "\n",
    "# 添加 tensorboard\n",
    "writer = SummaryWriter(\"logs\")\n",
    "\n",
    "for i in range(epoch):\n",
    "    print(\"-----第 {} 轮训练开始-----\".format(i+1))\n",
    "    \n",
    "    # 训练步骤开始\n",
    "    tudui.train() # 当网络中有dropout层、batchnorm层时，这些层能起作用\n",
    "    for data in train_dataloader:\n",
    "        imgs, targets = data\n",
    "        if torch.cuda.is_available():\n",
    "            imgs = imgs.cuda()  # 数据放到cuda上\n",
    "            targets = targets.cuda() # 数据放到cuda上\n",
    "        outputs = tudui(imgs)\n",
    "        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距\n",
    "        \n",
    "        # 优化器对模型调优\n",
    "        optimizer.zero_grad()  # 梯度清零\n",
    "        loss.backward() # 反向传播，计算损失函数的梯度\n",
    "        optimizer.step()   # 根据梯度，对网络的参数进行调优\n",
    "        \n",
    "        total_train_step = total_train_step + 1\n",
    "        if total_train_step % 100 == 0:\n",
    "            print(\"训练次数：{}，Loss：{}\".format(total_train_step,loss.item()))  # 方式二：获得loss值\n",
    "            writer.add_scalar(\"train_loss\",loss.item(),total_train_step)\n",
    "    \n",
    "    # 测试步骤开始（每一轮训练后都查看在测试数据集上的loss情况）\n",
    "    tudui.eval()  # 当网络中有dropout层、batchnorm层时，这些层不能起作用\n",
    "    total_test_loss = 0\n",
    "    total_accuracy = 0\n",
    "    with torch.no_grad():  # 没有梯度了\n",
    "        for data in test_dataloader: # 测试数据集提取数据\n",
    "            imgs, targets = data # 数据放到cuda上\n",
    "            if torch.cuda.is_available():\n",
    "                imgs = imgs.cuda() # 数据放到cuda上\n",
    "                targets = targets.cuda()\n",
    "            outputs = tudui(imgs)\n",
    "            loss = loss_fn(outputs, targets) # 仅data数据在网络模型上的损失\n",
    "            total_test_loss = total_test_loss + loss.item() # 所有loss\n",
    "            accuracy = (outputs.argmax(1) == targets).sum()\n",
    "            total_accuracy = total_accuracy + accuracy\n",
    "            \n",
    "    print(\"整体测试集上的Loss：{}\".format(total_test_loss))\n",
    "    print(\"整体测试集上的正确率：{}\".format(total_accuracy/test_data_size))\n",
    "    writer.add_scalar(\"test_loss\",total_test_loss,total_test_step)\n",
    "    writer.add_scalar(\"test_accuracy\",total_accuracy/test_data_size,total_test_step)  \n",
    "    total_test_step = total_test_step + 1\n",
    "    \n",
    "    torch.save(tudui, \"./model/tudui_{}.pth\".format(i)) # 保存每一轮训练后的结果\n",
    "    #torch.save(tudui.state_dict(),\"tudui_{}.path\".format(i)) # 保存方式二         \n",
    "    print(\"模型已保存\")\n",
    "    \n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. GPU训练时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "训练数据集的长度：50000\n",
      "测试数据集的长度：10000\n",
      "-----第 1 轮训练开始-----\n",
      "1.0935008525848389\n",
      "训练次数：100，Loss：2.2871038913726807\n",
      "2.1766483783721924\n",
      "训练次数：200，Loss：2.2836720943450928\n",
      "3.27374267578125\n",
      "训练次数：300，Loss：2.259164333343506\n",
      "4.42803692817688\n",
      "训练次数：400，Loss：2.170818328857422\n",
      "5.506956577301025\n",
      "训练次数：500，Loss：2.1002814769744873\n",
      "6.58754301071167\n",
      "训练次数：600，Loss：2.0413668155670166\n",
      "7.650376319885254\n",
      "训练次数：700，Loss：2.0200154781341553\n",
      "整体测试集上的Loss：316.68364894390106\n",
      "整体测试集上的正确率：0.2789999842643738\n",
      "模型已保存\n",
      "-----第 2 轮训练开始-----\n",
      "10.175889730453491\n",
      "训练次数：800，Loss：1.8918509483337402\n",
      "11.24414849281311\n",
      "训练次数：900，Loss：1.8798954486846924\n",
      "12.356922149658203\n",
      "训练次数：1000，Loss：1.970682978630066\n",
      "13.43547511100769\n",
      "训练次数：1100，Loss：2.0064470767974854\n",
      "14.509244680404663\n",
      "训练次数：1200，Loss：1.7197221517562866\n",
      "15.598143815994263\n",
      "训练次数：1300，Loss：1.6999645233154297\n",
      "16.67508888244629\n",
      "训练次数：1400，Loss：1.7595139741897583\n",
      "17.747746229171753\n",
      "训练次数：1500，Loss：1.849331259727478\n",
      "整体测试集上的Loss：304.3353645801544\n",
      "整体测试集上的正确率：0.31610000133514404\n",
      "模型已保存\n",
      "-----第 3 轮训练开始-----\n",
      "20.33113145828247\n",
      "训练次数：1600，Loss：1.7673357725143433\n",
      "21.411443948745728\n",
      "训练次数：1700，Loss：1.6436196565628052\n",
      "22.475884914398193\n",
      "训练次数：1800，Loss：1.9101005792617798\n",
      "23.543425798416138\n",
      "训练次数：1900，Loss：1.7177188396453857\n",
      "24.60761523246765\n",
      "训练次数：2000，Loss：1.9782830476760864\n",
      "25.691354751586914\n",
      "训练次数：2100，Loss：1.523171067237854\n",
      "26.782272815704346\n",
      "训练次数：2200，Loss：1.4762014150619507\n",
      "27.82503628730774\n",
      "训练次数：2300，Loss：1.7781658172607422\n",
      "整体测试集上的Loss：272.44360399246216\n",
      "整体测试集上的正确率：0.37199997901916504\n",
      "模型已保存\n",
      "-----第 4 轮训练开始-----\n",
      "30.293652772903442\n",
      "训练次数：2400，Loss：1.7340704202651978\n",
      "31.373929500579834\n",
      "训练次数：2500，Loss：1.3520257472991943\n",
      "32.44764447212219\n",
      "训练次数：2600，Loss：1.574364423751831\n",
      "33.513572454452515\n",
      "训练次数：2700，Loss：1.6468950510025024\n",
      "34.61698246002197\n",
      "训练次数：2800，Loss：1.4663115739822388\n",
      "35.69143986701965\n",
      "训练次数：2900，Loss：1.6123905181884766\n",
      "36.75266122817993\n",
      "训练次数：3000，Loss：1.3316911458969116\n",
      "37.8302538394928\n",
      "训练次数：3100，Loss：1.5095850229263306\n",
      "整体测试集上的Loss：264.94398534297943\n",
      "整体测试集上的正确率：0.3986999988555908\n",
      "模型已保存\n",
      "-----第 5 轮训练开始-----\n",
      "40.43262219429016\n",
      "训练次数：3200，Loss：1.3727346658706665\n",
      "41.48542404174805\n",
      "训练次数：3300，Loss：1.443982481956482\n",
      "42.52226686477661\n",
      "训练次数：3400，Loss：1.5196319818496704\n",
      "43.57080316543579\n",
      "训练次数：3500，Loss：1.5449475049972534\n",
      "44.60450720787048\n",
      "训练次数：3600，Loss：1.568708062171936\n",
      "45.64966917037964\n",
      "训练次数：3700，Loss：1.3194901943206787\n",
      "46.709717750549316\n",
      "训练次数：3800，Loss：1.2732317447662354\n",
      "47.74911880493164\n",
      "训练次数：3900，Loss：1.415683388710022\n",
      "整体测试集上的Loss：253.18030643463135\n",
      "整体测试集上的正确率：0.42249998450279236\n",
      "模型已保存\n",
      "-----第 6 轮训练开始-----\n",
      "50.21744728088379\n",
      "训练次数：4000，Loss：1.3912277221679688\n",
      "51.265125036239624\n",
      "训练次数：4100，Loss：1.410901665687561\n",
      "52.28390049934387\n",
      "训练次数：4200，Loss：1.521787405014038\n",
      "53.33956241607666\n",
      "训练次数：4300，Loss：1.2260788679122925\n",
      "54.391708850860596\n",
      "训练次数：4400，Loss：1.1339644193649292\n",
      "55.45666837692261\n",
      "训练次数：4500，Loss：1.3752398490905762\n",
      "56.52565860748291\n",
      "训练次数：4600，Loss：1.4126766920089722\n",
      "整体测试集上的Loss：236.17250859737396\n",
      "整体测试集上的正确率：0.45719999074935913\n",
      "模型已保存\n",
      "-----第 7 轮训练开始-----\n",
      "58.975016832351685\n",
      "训练次数：4700，Loss：1.327752947807312\n",
      "60.01860165596008\n",
      "训练次数：4800，Loss：1.5265493392944336\n",
      "61.06228733062744\n",
      "训练次数：4900，Loss：1.382441520690918\n",
      "62.13616943359375\n",
      "训练次数：5000，Loss：1.4380030632019043\n",
      "63.18708825111389\n",
      "训练次数：5100，Loss：1.0084904432296753\n",
      "64.28091526031494\n",
      "训练次数：5200，Loss：1.312524437904358\n",
      "65.38735771179199\n",
      "训练次数：5300，Loss：1.1935137510299683\n",
      "66.48723554611206\n",
      "训练次数：5400，Loss：1.3607358932495117\n",
      "整体测试集上的Loss：223.93975222110748\n",
      "整体测试集上的正确率：0.4819999933242798\n",
      "模型已保存\n",
      "-----第 8 轮训练开始-----\n",
      "69.10827493667603\n",
      "训练次数：5500，Loss：1.1847436428070068\n",
      "70.24965786933899\n",
      "训练次数：5600，Loss：1.2199389934539795\n",
      "71.35597825050354\n",
      "训练次数：5700，Loss：1.2233123779296875\n",
      "72.44557046890259\n",
      "训练次数：5800，Loss：1.2635695934295654\n",
      "73.50763511657715\n",
      "训练次数：5900，Loss：1.3924380540847778\n",
      "74.50808930397034\n",
      "训练次数：6000，Loss：1.5825486183166504\n",
      "75.47654867172241\n",
      "训练次数：6100，Loss：1.035813570022583\n",
      "76.46864604949951\n",
      "训练次数：6200，Loss：1.1380523443222046\n",
      "整体测试集上的Loss：212.88353633880615\n",
      "整体测试集上的正确率：0.513700008392334\n",
      "模型已保存\n",
      "-----第 9 轮训练开始-----\n",
      "78.92930197715759\n",
      "训练次数：6300，Loss：1.4175732135772705\n",
      "80.02452445030212\n",
      "训练次数：6400，Loss：1.1150474548339844\n",
      "81.0898060798645\n",
      "训练次数：6500，Loss：1.5558857917785645\n",
      "82.11342310905457\n",
      "训练次数：6600，Loss：1.095849633216858\n",
      "83.19743394851685\n",
      "训练次数：6700，Loss：1.061813235282898\n",
      "84.28776097297668\n",
      "训练次数：6800，Loss：1.160451054573059\n",
      "85.28279232978821\n",
      "训练次数：6900，Loss：1.1402560472488403\n",
      "86.31971287727356\n",
      "训练次数：7000，Loss：0.9515166282653809\n",
      "整体测试集上的Loss：203.51595824956894\n",
      "整体测试集上的正确率：0.5372999906539917\n",
      "模型已保存\n",
      "-----第 10 轮训练开始-----\n",
      "88.85867476463318\n",
      "训练次数：7100，Loss：1.2563235759735107\n",
      "89.92428064346313\n",
      "训练次数：7200，Loss：1.028809905052185\n",
      "90.95707082748413\n",
      "训练次数：7300，Loss：1.08479642868042\n",
      "91.98656606674194\n",
      "训练次数：7400，Loss：0.8235641717910767\n",
      "92.97793579101562\n",
      "训练次数：7500，Loss：1.2311100959777832\n",
      "93.9680666923523\n",
      "训练次数：7600，Loss：1.2486273050308228\n",
      "94.95079374313354\n",
      "训练次数：7700，Loss：0.9207454919815063\n",
      "95.94353938102722\n",
      "训练次数：7800，Loss：1.2435222864151\n",
      "整体测试集上的Loss：194.90294301509857\n",
      "整体测试集上的正确率：0.557200014591217\n",
      "模型已保存\n"
     ]
    }
   ],
   "source": [
    "import torchvision\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import time\n",
    "\n",
    "# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里\n",
    "class Tudui(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Tudui, self).__init__()        \n",
    "        self.model1 = nn.Sequential(\n",
    "            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×5，步长1，填充2    \n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,32,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,64,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Flatten(),  # 展平后变成 64*4*4 了\n",
    "            nn.Linear(64*4*4,64),\n",
    "            nn.Linear(64,10)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.model1(x)\n",
    "        return x\n",
    "\n",
    "# 准备数据集\n",
    "train_data = torchvision.datasets.CIFAR10(\"./dataset\",train=True,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "test_data = torchvision.datasets.CIFAR10(\"./dataset\",train=False,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "\n",
    "# length 长度\n",
    "train_data_size = len(train_data)\n",
    "test_data_size = len(test_data)\n",
    "# 如果train_data_size=10，则打印：训练数据集的长度为：10\n",
    "print(\"训练数据集的长度：{}\".format(train_data_size))\n",
    "print(\"测试数据集的长度：{}\".format(test_data_size))\n",
    "\n",
    "# 利用 Dataloader 来加载数据集\n",
    "train_dataloader = DataLoader(train_data, batch_size=64)        \n",
    "test_dataloader = DataLoader(test_data, batch_size=64)\n",
    "\n",
    "# 创建网络模型\n",
    "tudui = Tudui() \n",
    "if torch.cuda.is_available():\n",
    "    tudui = tudui.cuda() # 网络模型转移到cuda上\n",
    "\n",
    "# 损失函数\n",
    "loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写\n",
    "if torch.cuda.is_available():\n",
    "    loss_fn = loss_fn.cuda()        # 损失函数转移到cuda上\n",
    "\n",
    "# 优化器\n",
    "learning = 0.01  # 1e-2 就是 0.01 的意思\n",
    "optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  \n",
    "\n",
    "# 设置网络的一些参数\n",
    "# 记录训练的次数\n",
    "total_train_step = 0\n",
    "# 记录测试的次数\n",
    "total_test_step = 0\n",
    "\n",
    "# 训练的轮次\n",
    "epoch = 10\n",
    "\n",
    "# 添加 tensorboard\n",
    "writer = SummaryWriter(\"logs\")\n",
    "start_time = time.time()\n",
    "\n",
    "for i in range(epoch):\n",
    "    print(\"-----第 {} 轮训练开始-----\".format(i+1))\n",
    "    \n",
    "    # 训练步骤开始\n",
    "    tudui.train() # 当网络中有dropout层、batchnorm层时，这些层能起作用\n",
    "    for data in train_dataloader:\n",
    "        imgs, targets = data\n",
    "        if torch.cuda.is_available():\n",
    "            imgs = imgs.cuda()  # 数据放到cuda上\n",
    "            targets = targets.cuda() # 数据放到cuda上\n",
    "        outputs = tudui(imgs)\n",
    "        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距\n",
    "        \n",
    "        # 优化器对模型调优\n",
    "        optimizer.zero_grad()  # 梯度清零\n",
    "        loss.backward() # 反向传播，计算损失函数的梯度\n",
    "        optimizer.step()   # 根据梯度，对网络的参数进行调优\n",
    "        \n",
    "        total_train_step = total_train_step + 1\n",
    "        if total_train_step % 100 == 0:\n",
    "            end_time = time.time()\n",
    "            print(end_time - start_time) # 运行训练一百次后的时间间隔\n",
    "            print(\"训练次数：{}，Loss：{}\".format(total_train_step,loss.item()))  # 方式二：获得loss值\n",
    "            writer.add_scalar(\"train_loss\",loss.item(),total_train_step)\n",
    "    \n",
    "    # 测试步骤开始（每一轮训练后都查看在测试数据集上的loss情况）\n",
    "    tudui.eval()  # 当网络中有dropout层、batchnorm层时，这些层不能起作用\n",
    "    total_test_loss = 0\n",
    "    total_accuracy = 0\n",
    "    with torch.no_grad():  # 没有梯度了\n",
    "        for data in test_dataloader: # 测试数据集提取数据\n",
    "            imgs, targets = data # 数据放到cuda上\n",
    "            if torch.cuda.is_available():\n",
    "                imgs = imgs.cuda() # 数据放到cuda上\n",
    "                targets = targets.cuda()\n",
    "            outputs = tudui(imgs)\n",
    "            loss = loss_fn(outputs, targets) # 仅data数据在网络模型上的损失\n",
    "            total_test_loss = total_test_loss + loss.item() # 所有loss\n",
    "            accuracy = (outputs.argmax(1) == targets).sum()\n",
    "            total_accuracy = total_accuracy + accuracy\n",
    "            \n",
    "    print(\"整体测试集上的Loss：{}\".format(total_test_loss))\n",
    "    print(\"整体测试集上的正确率：{}\".format(total_accuracy/test_data_size))\n",
    "    writer.add_scalar(\"test_loss\",total_test_loss,total_test_step)\n",
    "    writer.add_scalar(\"test_accuracy\",total_accuracy/test_data_size,total_test_step)  \n",
    "    total_test_step = total_test_step + 1\n",
    "    \n",
    "    torch.save(tudui, \"./model/tudui_{}.pth\".format(i)) # 保存每一轮训练后的结果\n",
    "    #torch.save(tudui.state_dict(),\"tudui_{}.path\".format(i)) # 保存方式二         \n",
    "    print(\"模型已保存\")\n",
    "    \n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. CPU训练时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "训练数据集的长度：50000\n",
      "测试数据集的长度：10000\n",
      "-----第 1 轮训练开始-----\n",
      "3.761235237121582\n",
      "训练次数：100，Loss：2.291699171066284\n",
      "7.478676080703735\n",
      "训练次数：200，Loss：2.2810616493225098\n",
      "11.149278163909912\n",
      "训练次数：300，Loss：2.2673659324645996\n",
      "14.876582384109497\n",
      "训练次数：400，Loss：2.210559606552124\n",
      "18.794732332229614\n",
      "训练次数：500，Loss：2.074248790740967\n",
      "22.666887521743774\n",
      "训练次数：600，Loss：2.029463052749634\n",
      "26.518835306167603\n",
      "训练次数：700，Loss：2.025493860244751\n",
      "整体测试集上的Loss：315.7099049091339\n",
      "整体测试集上的正确率：0.2777999937534332\n",
      "模型已保存\n",
      "-----第 2 轮训练开始-----\n",
      "33.49093294143677\n",
      "训练次数：800，Loss：1.8920475244522095\n",
      "37.37390112876892\n",
      "训练次数：900，Loss：1.8434715270996094\n",
      "41.431575775146484\n",
      "训练次数：1000，Loss：1.9236050844192505\n",
      "45.389270067214966\n",
      "训练次数：1100，Loss：2.011040687561035\n",
      "49.43605923652649\n",
      "训练次数：1200，Loss：1.6993070840835571\n",
      "53.62735366821289\n",
      "训练次数：1300，Loss：1.6654363870620728\n",
      "58.2660493850708\n",
      "训练次数：1400，Loss：1.753265142440796\n",
      "62.52872014045715\n",
      "训练次数：1500，Loss：1.813820481300354\n",
      "整体测试集上的Loss：304.07691729068756\n",
      "整体测试集上的正确率：0.3098999857902527\n",
      "模型已保存\n",
      "-----第 3 轮训练开始-----\n",
      "70.04687976837158\n",
      "训练次数：1600，Loss：1.7496393918991089\n",
      "74.19148874282837\n",
      "训练次数：1700，Loss：1.6370826959609985\n",
      "78.51184940338135\n",
      "训练次数：1800，Loss：1.8948217630386353\n",
      "83.03685450553894\n",
      "训练次数：1900，Loss：1.7091740369796753\n",
      "87.36472058296204\n",
      "训练次数：2000，Loss：1.9168915748596191\n",
      "91.5152907371521\n",
      "训练次数：2100，Loss：1.5194813013076782\n",
      "95.88392543792725\n",
      "训练次数：2200，Loss：1.4738638401031494\n",
      "100.08612132072449\n",
      "训练次数：2300，Loss：1.7649239301681519\n",
      "整体测试集上的Loss：266.925869345665\n",
      "整体测试集上的正确率：0.38499999046325684\n",
      "模型已保存\n",
      "-----第 4 轮训练开始-----\n",
      "107.81971716880798\n",
      "训练次数：2400，Loss：1.7411062717437744\n",
      "111.95616102218628\n",
      "训练次数：2500，Loss：1.3490957021713257\n",
      "116.07963228225708\n",
      "训练次数：2600，Loss：1.577816367149353\n",
      "120.41316413879395\n",
      "训练次数：2700，Loss：1.6967650651931763\n",
      "124.64287948608398\n",
      "训练次数：2800，Loss：1.4929475784301758\n",
      "128.7123486995697\n",
      "训练次数：2900，Loss：1.6131006479263306\n",
      "132.94610214233398\n",
      "训练次数：3000，Loss：1.347227931022644\n",
      "137.22871589660645\n",
      "训练次数：3100，Loss：1.4926567077636719\n",
      "整体测试集上的Loss：260.8921568393707\n",
      "整体测试集上的正确率：0.40639999508857727\n",
      "模型已保存\n",
      "-----第 5 轮训练开始-----\n",
      "145.22107672691345\n",
      "训练次数：3200，Loss：1.3609188795089722\n",
      "149.55124926567078\n",
      "训练次数：3300，Loss：1.459675669670105\n",
      "153.86187386512756\n",
      "训练次数：3400，Loss：1.4940723180770874\n",
      "158.21399784088135\n",
      "训练次数：3500，Loss：1.5735642910003662\n",
      "162.51304960250854\n",
      "训练次数：3600，Loss：1.6013926267623901\n",
      "166.73556113243103\n",
      "训练次数：3700，Loss：1.3678141832351685\n",
      "170.68037581443787\n",
      "训练次数：3800，Loss：1.2831741571426392\n",
      "174.55300641059875\n",
      "训练次数：3900，Loss：1.4196735620498657\n",
      "整体测试集上的Loss：258.5555330514908\n",
      "整体测试集上的正确率：0.4147000014781952\n",
      "模型已保存\n",
      "-----第 6 轮训练开始-----\n",
      "181.89517664909363\n",
      "训练次数：4000，Loss：1.394544243812561\n",
      "185.81528973579407\n",
      "训练次数：4100，Loss：1.4785242080688477\n",
      "189.75436854362488\n",
      "训练次数：4200，Loss：1.504089593887329\n",
      "193.7331829071045\n",
      "训练次数：4300，Loss：1.1989901065826416\n",
      "197.86846470832825\n",
      "训练次数：4400，Loss：1.169187068939209\n",
      "202.10944604873657\n",
      "训练次数：4500，Loss：1.3368093967437744\n",
      "206.46737694740295\n",
      "训练次数：4600，Loss：1.4030650854110718\n",
      "整体测试集上的Loss：248.35702466964722\n",
      "整体测试集上的正确率：0.43479999899864197\n",
      "模型已保存\n",
      "-----第 7 轮训练开始-----\n",
      "213.79702472686768\n",
      "训练次数：4700，Loss：1.2863177061080933\n",
      "217.70893836021423\n",
      "训练次数：4800，Loss：1.5342319011688232\n",
      "221.56816983222961\n",
      "训练次数：4900，Loss：1.412546157836914\n",
      "225.4557182788849\n",
      "训练次数：5000，Loss：1.435633897781372\n",
      "229.29314064979553\n",
      "训练次数：5100，Loss：1.050623893737793\n",
      "233.22323894500732\n",
      "训练次数：5200，Loss：1.327545166015625\n",
      "237.1871302127838\n",
      "训练次数：5300，Loss：1.2706438302993774\n",
      "241.23810291290283\n",
      "训练次数：5400，Loss：1.3970144987106323\n",
      "整体测试集上的Loss：238.9216102361679\n",
      "整体测试集上的正确率：0.4553000032901764\n",
      "模型已保存\n",
      "-----第 8 轮训练开始-----\n",
      "248.59216332435608\n",
      "训练次数：5500，Loss：1.1989145278930664\n",
      "252.57087922096252\n",
      "训练次数：5600，Loss：1.2739124298095703\n",
      "256.6464595794678\n",
      "训练次数：5700，Loss：1.2550328969955444\n",
      "260.85662841796875\n",
      "训练次数：5800，Loss：1.2594654560089111\n",
      "264.96409726142883\n",
      "训练次数：5900，Loss：1.352506399154663\n",
      "269.10122084617615\n",
      "训练次数：6000，Loss：1.5692474842071533\n",
      "273.26241970062256\n",
      "训练次数：6100，Loss：1.051681399345398\n",
      "277.37177181243896\n",
      "训练次数：6200，Loss：1.1093714237213135\n",
      "整体测试集上的Loss：229.03875291347504\n",
      "整体测试集上的正确率：0.48089998960494995\n",
      "模型已保存\n",
      "-----第 9 轮训练开始-----\n",
      "285.03535556793213\n",
      "训练次数：6300，Loss：1.438887119293213\n",
      "289.1406488418579\n",
      "训练次数：6400，Loss：1.1292884349822998\n",
      "293.3350794315338\n",
      "训练次数：6500，Loss：1.5554381608963013\n",
      "297.4605076313019\n",
      "训练次数：6600，Loss：1.12319815158844\n",
      "301.41761565208435\n",
      "训练次数：6700，Loss：1.0609500408172607\n",
      "305.4384708404541\n",
      "训练次数：6800，Loss：1.1414461135864258\n",
      "309.32322096824646\n",
      "训练次数：6900，Loss：1.0653573274612427\n",
      "313.22136521339417\n",
      "训练次数：7000，Loss：0.9645416140556335\n",
      "整体测试集上的Loss：217.3968950510025\n",
      "整体测试集上的正确率：0.508400022983551\n",
      "模型已保存\n",
      "-----第 10 轮训练开始-----\n",
      "320.61516642570496\n",
      "训练次数：7100，Loss：1.252223253250122\n",
      "324.5729761123657\n",
      "训练次数：7200，Loss：1.0116769075393677\n",
      "328.631311416626\n",
      "训练次数：7300，Loss：1.1434015035629272\n",
      "332.65182423591614\n",
      "训练次数：7400，Loss：0.8558588624000549\n",
      "336.61728739738464\n",
      "训练次数：7500，Loss：1.2400795221328735\n",
      "340.65006160736084\n",
      "训练次数：7600，Loss：1.3492536544799805\n",
      "344.64593052864075\n",
      "训练次数：7700，Loss：0.9260987043380737\n",
      "348.731153011322\n",
      "训练次数：7800，Loss：1.3142049312591553\n",
      "整体测试集上的Loss：208.29399240016937\n",
      "整体测试集上的正确率：0.5317999720573425\n",
      "模型已保存\n"
     ]
    }
   ],
   "source": [
    "import torchvision\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import time\n",
    "\n",
    "# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里\n",
    "class Tudui(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Tudui, self).__init__()        \n",
    "        self.model1 = nn.Sequential(\n",
    "            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×5，步长1，填充2    \n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,32,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,64,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Flatten(),  # 展平后变成 64*4*4 了\n",
    "            nn.Linear(64*4*4,64),\n",
    "            nn.Linear(64,10)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.model1(x)\n",
    "        return x\n",
    "\n",
    "# 准备数据集\n",
    "train_data = torchvision.datasets.CIFAR10(\"./dataset\",train=True,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "test_data = torchvision.datasets.CIFAR10(\"./dataset\",train=False,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "\n",
    "# length 长度\n",
    "train_data_size = len(train_data)\n",
    "test_data_size = len(test_data)\n",
    "# 如果train_data_size=10，则打印：训练数据集的长度为：10\n",
    "print(\"训练数据集的长度：{}\".format(train_data_size))\n",
    "print(\"测试数据集的长度：{}\".format(test_data_size))\n",
    "\n",
    "# 利用 Dataloader 来加载数据集\n",
    "train_dataloader = DataLoader(train_data, batch_size=64)        \n",
    "test_dataloader = DataLoader(test_data, batch_size=64)\n",
    "\n",
    "# 创建网络模型\n",
    "tudui = Tudui() \n",
    "\n",
    "# 损失函数\n",
    "loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写\n",
    "\n",
    "# 优化器\n",
    "learning = 0.01  # 1e-2 就是 0.01 的意思\n",
    "optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  \n",
    "\n",
    "# 设置网络的一些参数\n",
    "# 记录训练的次数\n",
    "total_train_step = 0\n",
    "# 记录测试的次数\n",
    "total_test_step = 0\n",
    "\n",
    "# 训练的轮次\n",
    "epoch = 10\n",
    "\n",
    "# 添加 tensorboard\n",
    "writer = SummaryWriter(\"logs\")\n",
    "start_time = time.time()\n",
    "\n",
    "for i in range(epoch):\n",
    "    print(\"-----第 {} 轮训练开始-----\".format(i+1))\n",
    "    \n",
    "    # 训练步骤开始\n",
    "    tudui.train() # 当网络中有dropout层、batchnorm层时，这些层能起作用\n",
    "    for data in train_dataloader:\n",
    "        imgs, targets = data\n",
    "        outputs = tudui(imgs)\n",
    "        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距\n",
    "        \n",
    "        # 优化器对模型调优\n",
    "        optimizer.zero_grad()  # 梯度清零\n",
    "        loss.backward() # 反向传播，计算损失函数的梯度\n",
    "        optimizer.step()   # 根据梯度，对网络的参数进行调优\n",
    "        \n",
    "        total_train_step = total_train_step + 1\n",
    "        if total_train_step % 100 == 0:\n",
    "            end_time = time.time()\n",
    "            print(end_time - start_time) # 运行训练一百次后的时间间隔\n",
    "            print(\"训练次数：{}，Loss：{}\".format(total_train_step,loss.item()))  # 方式二：获得loss值\n",
    "            writer.add_scalar(\"train_loss\",loss.item(),total_train_step)\n",
    "    \n",
    "    # 测试步骤开始（每一轮训练后都查看在测试数据集上的loss情况）\n",
    "    tudui.eval()  # 当网络中有dropout层、batchnorm层时，这些层不能起作用\n",
    "    total_test_loss = 0\n",
    "    total_accuracy = 0\n",
    "    with torch.no_grad():  # 没有梯度了\n",
    "        for data in test_dataloader: # 测试数据集提取数据\n",
    "            imgs, targets = data \n",
    "            outputs = tudui(imgs)\n",
    "            loss = loss_fn(outputs, targets) # 仅data数据在网络模型上的损失\n",
    "            total_test_loss = total_test_loss + loss.item() # 所有loss\n",
    "            accuracy = (outputs.argmax(1) == targets).sum()\n",
    "            total_accuracy = total_accuracy + accuracy\n",
    "            \n",
    "    print(\"整体测试集上的Loss：{}\".format(total_test_loss))\n",
    "    print(\"整体测试集上的正确率：{}\".format(total_accuracy/test_data_size))\n",
    "    writer.add_scalar(\"test_loss\",total_test_loss,total_test_step)\n",
    "    writer.add_scalar(\"test_accuracy\",total_accuracy/test_data_size,total_test_step)  \n",
    "    total_test_step = total_test_step + 1\n",
    "    \n",
    "    torch.save(tudui, \"./model/tudui_{}.pth\".format(i)) # 保存每一轮训练后的结果\n",
    "    #torch.save(tudui.state_dict(),\"tudui_{}.path\".format(i)) # 保存方式二         \n",
    "    print(\"模型已保存\")\n",
    "    \n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 利用GPU训练(方式二)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 电脑上有两个显卡时，可以用指定cuda:0、cuda:1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "训练数据集的长度：50000\n",
      "测试数据集的长度：10000\n",
      "-----第 1 轮训练开始-----\n",
      "1.1190404891967773\n",
      "训练次数：100，Loss：2.2926671504974365\n",
      "2.2812979221343994\n",
      "训练次数：200，Loss：2.291703701019287\n",
      "3.386057138442993\n",
      "训练次数：300，Loss：2.2745745182037354\n",
      "4.541907548904419\n",
      "训练次数：400，Loss：2.221169948577881\n",
      "5.640037298202515\n",
      "训练次数：500，Loss：2.143411159515381\n",
      "6.726482629776001\n",
      "训练次数：600，Loss：2.0441091060638428\n",
      "7.838879585266113\n",
      "训练次数：700，Loss：2.0090014934539795\n",
      "整体测试集上的Loss：312.4657955169678\n",
      "整体测试集上的正确率：0.28279998898506165\n",
      "模型已保存\n",
      "-----第 2 轮训练开始-----\n",
      "10.41140604019165\n",
      "训练次数：800，Loss：1.8645917177200317\n",
      "11.455690383911133\n",
      "训练次数：900，Loss：1.827837347984314\n",
      "12.512084007263184\n",
      "训练次数：1000，Loss：1.9033353328704834\n",
      "13.599088907241821\n",
      "训练次数：1100，Loss：2.0170090198516846\n",
      "14.64348030090332\n",
      "训练次数：1200，Loss：1.7100862264633179\n",
      "15.72208046913147\n",
      "训练次数：1300，Loss：1.6826354265213013\n",
      "16.752166986465454\n",
      "训练次数：1400，Loss：1.7191925048828125\n",
      "17.81931185722351\n",
      "训练次数：1500，Loss：1.8116774559020996\n",
      "整体测试集上的Loss：306.7045053243637\n",
      "整体测试集上的正确率：0.3068999946117401\n",
      "模型已保存\n",
      "-----第 3 轮训练开始-----\n",
      "20.318028688430786\n",
      "训练次数：1600，Loss：1.7589811086654663\n",
      "21.38711452484131\n",
      "训练次数：1700，Loss：1.6722180843353271\n",
      "22.505618572235107\n",
      "训练次数：1800，Loss：1.9415262937545776\n",
      "23.604503393173218\n",
      "训练次数：1900，Loss：1.7454909086227417\n",
      "24.74000310897827\n",
      "训练次数：2000，Loss：1.9074403047561646\n",
      "25.785309076309204\n",
      "训练次数：2100，Loss：1.5321683883666992\n",
      "26.833311796188354\n",
      "训练次数：2200，Loss：1.4686038494110107\n",
      "27.883039236068726\n",
      "训练次数：2300，Loss：1.8088748455047607\n",
      "整体测试集上的Loss：264.2274956703186\n",
      "整体测试集上的正确率：0.3926999866962433\n",
      "模型已保存\n",
      "-----第 4 轮训练开始-----\n",
      "30.434141159057617\n",
      "训练次数：2400，Loss：1.7530766725540161\n",
      "31.50102210044861\n",
      "训练次数：2500，Loss：1.3466917276382446\n",
      "32.588942766189575\n",
      "训练次数：2600，Loss：1.5937833786010742\n",
      "33.64913892745972\n",
      "训练次数：2700，Loss：1.6885923147201538\n",
      "34.69320559501648\n",
      "训练次数：2800，Loss：1.5292593240737915\n",
      "35.72002124786377\n",
      "训练次数：2900，Loss：1.6046268939971924\n",
      "36.74435377120972\n",
      "训练次数：3000，Loss：1.3702434301376343\n",
      "37.789002656936646\n",
      "训练次数：3100，Loss：1.5583586692810059\n",
      "整体测试集上的Loss：247.68864715099335\n",
      "整体测试集上的正确率：0.42879998683929443\n",
      "模型已保存\n",
      "-----第 5 轮训练开始-----\n",
      "40.23552346229553\n",
      "训练次数：3200，Loss：1.3889607191085815\n",
      "41.28690481185913\n",
      "训练次数：3300，Loss：1.4547197818756104\n",
      "42.32324028015137\n",
      "训练次数：3400，Loss：1.487451434135437\n",
      "43.36912536621094\n",
      "训练次数：3500，Loss：1.6039626598358154\n",
      "44.43635702133179\n",
      "训练次数：3600，Loss：1.5406546592712402\n",
      "45.52009439468384\n",
      "训练次数：3700，Loss：1.355963110923767\n",
      "46.61804127693176\n",
      "训练次数：3800，Loss：1.293853521347046\n",
      "47.66825032234192\n",
      "训练次数：3900，Loss：1.4567005634307861\n",
      "整体测试集上的Loss：239.61021220684052\n",
      "整体测试集上的正确率：0.44669997692108154\n",
      "模型已保存\n",
      "-----第 6 轮训练开始-----\n",
      "50.18902587890625\n",
      "训练次数：4000，Loss：1.4021949768066406\n",
      "51.221325397491455\n",
      "训练次数：4100，Loss：1.4686369895935059\n",
      "52.25768494606018\n",
      "训练次数：4200，Loss：1.5711930990219116\n",
      "53.29710626602173\n",
      "训练次数：4300，Loss：1.2274739742279053\n",
      "54.35805821418762\n",
      "训练次数：4400，Loss：1.1256041526794434\n",
      "55.45258617401123\n",
      "训练次数：4500，Loss：1.346487045288086\n",
      "56.498899936676025\n",
      "训练次数：4600，Loss：1.4574103355407715\n",
      "整体测试集上的Loss：229.56566536426544\n",
      "整体测试集上的正确率：0.4640999734401703\n",
      "模型已保存\n",
      "-----第 7 轮训练开始-----\n",
      "58.9901008605957\n",
      "训练次数：4700，Loss：1.3305902481079102\n",
      "60.09166860580444\n",
      "训练次数：4800，Loss：1.5128451585769653\n",
      "61.15304517745972\n",
      "训练次数：4900，Loss：1.4225473403930664\n",
      "62.24405121803284\n",
      "训练次数：5000，Loss：1.4352083206176758\n",
      "63.328041315078735\n",
      "训练次数：5100，Loss：1.0108458995819092\n",
      "64.43191266059875\n",
      "训练次数：5200，Loss：1.2999461889266968\n",
      "65.55889964103699\n",
      "训练次数：5300，Loss：1.2483041286468506\n",
      "66.67005276679993\n",
      "训练次数：5400，Loss：1.40975821018219\n",
      "整体测试集上的Loss：221.8911657333374\n",
      "整体测试集上的正确率：0.4901999831199646\n",
      "模型已保存\n",
      "-----第 8 轮训练开始-----\n",
      "69.31889057159424\n",
      "训练次数：5500，Loss：1.2309132814407349\n",
      "70.37002444267273\n",
      "训练次数：5600，Loss：1.2406929731369019\n",
      "71.45024251937866\n",
      "训练次数：5700，Loss：1.206421136856079\n",
      "72.53801417350769\n",
      "训练次数：5800，Loss：1.2449841499328613\n",
      "73.61350750923157\n",
      "训练次数：5900，Loss：1.382934331893921\n",
      "74.64801716804504\n",
      "训练次数：6000，Loss：1.5476189851760864\n",
      "75.68919968605042\n",
      "训练次数：6100，Loss：1.0594358444213867\n",
      "76.78617668151855\n",
      "训练次数：6200，Loss：1.1037648916244507\n",
      "整体测试集上的Loss：214.6394373178482\n",
      "整体测试集上的正确率：0.5138999819755554\n",
      "模型已保存\n",
      "-----第 9 轮训练开始-----\n",
      "79.35270118713379\n",
      "训练次数：6300，Loss：1.4193459749221802\n",
      "80.38360047340393\n",
      "训练次数：6400，Loss：1.1300890445709229\n",
      "81.4340546131134\n",
      "训练次数：6500，Loss：1.5622072219848633\n",
      "82.51292634010315\n",
      "训练次数：6600，Loss：1.119008183479309\n",
      "83.57669281959534\n",
      "训练次数：6700，Loss：1.0774811506271362\n",
      "84.61026763916016\n",
      "训练次数：6800，Loss：1.1881333589553833\n",
      "85.65419411659241\n",
      "训练次数：6900，Loss：1.116170048713684\n",
      "86.69365286827087\n",
      "训练次数：7000，Loss：0.9820349812507629\n",
      "整体测试集上的Loss：204.89984810352325\n",
      "整体测试集上的正确率：0.5370000004768372\n",
      "模型已保存\n",
      "-----第 10 轮训练开始-----\n",
      "89.25331830978394\n",
      "训练次数：7100，Loss：1.339141607284546\n",
      "90.34024834632874\n",
      "训练次数：7200，Loss：0.8925604224205017\n",
      "91.38928580284119\n",
      "训练次数：7300，Loss：1.134442925453186\n",
      "92.44890975952148\n",
      "训练次数：7400，Loss：0.8384325504302979\n",
      "93.53598165512085\n",
      "训练次数：7500，Loss：1.2126699686050415\n",
      "94.57306551933289\n",
      "训练次数：7600，Loss：1.2007839679718018\n",
      "95.60608768463135\n",
      "训练次数：7700，Loss：0.8869692087173462\n",
      "96.65610480308533\n",
      "训练次数：7800，Loss：1.3008511066436768\n",
      "整体测试集上的Loss：195.62357383966446\n",
      "整体测试集上的正确率：0.5604999661445618\n",
      "模型已保存\n"
     ]
    }
   ],
   "source": [
    "import torchvision\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import time\n",
    "\n",
    "# 定义训练的设备\n",
    "#device = torch.device(\"cpu\")\n",
    "#device = torch.device(\"cuda\")   # 使用 GPU 方式一 \n",
    "#device = torch.device(\"cuda:0\") # 使用 GPU 方式二\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里\n",
    "class Tudui(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Tudui, self).__init__()        \n",
    "        self.model1 = nn.Sequential(\n",
    "            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×5，步长1，填充2    \n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,32,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Conv2d(32,64,5,1,2),\n",
    "            nn.MaxPool2d(2),\n",
    "            nn.Flatten(),  # 展平后变成 64*4*4 了\n",
    "            nn.Linear(64*4*4,64),\n",
    "            nn.Linear(64,10)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.model1(x)\n",
    "        return x\n",
    "\n",
    "# 准备数据集\n",
    "train_data = torchvision.datasets.CIFAR10(\"./dataset\",train=True,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "test_data = torchvision.datasets.CIFAR10(\"./dataset\",train=False,transform=torchvision.transforms.ToTensor(),download=True)       \n",
    "\n",
    "# length 长度\n",
    "train_data_size = len(train_data)\n",
    "test_data_size = len(test_data)\n",
    "# 如果train_data_size=10，则打印：训练数据集的长度为：10\n",
    "print(\"训练数据集的长度：{}\".format(train_data_size))\n",
    "print(\"测试数据集的长度：{}\".format(test_data_size))\n",
    "\n",
    "# 利用 Dataloader 来加载数据集\n",
    "train_dataloader = DataLoader(train_data, batch_size=64)        \n",
    "test_dataloader = DataLoader(test_data, batch_size=64)\n",
    "\n",
    "# 创建网络模型\n",
    "tudui = Tudui() \n",
    "tudui = tudui.to(device) # 也可以不赋值，直接 tudui.to(device) \n",
    "\n",
    "\n",
    "# 损失函数\n",
    "loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写\n",
    "loss_fn = loss_fn.to(device) # 也可以不赋值，直接loss_fn.to(device)\n",
    "\n",
    "# 优化器\n",
    "learning = 0.01  # 1e-2 就是 0.01 的意思\n",
    "optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  \n",
    "\n",
    "# 设置网络的一些参数\n",
    "# 记录训练的次数\n",
    "total_train_step = 0\n",
    "# 记录测试的次数\n",
    "total_test_step = 0\n",
    "\n",
    "# 训练的轮次\n",
    "epoch = 10\n",
    "\n",
    "# 添加 tensorboard\n",
    "writer = SummaryWriter(\"logs\")\n",
    "start_time = time.time()\n",
    "\n",
    "for i in range(epoch):\n",
    "    print(\"-----第 {} 轮训练开始-----\".format(i+1))\n",
    "    \n",
    "    # 训练步骤开始\n",
    "    tudui.train() # 当网络中有dropout层、batchnorm层时，这些层能起作用\n",
    "    for data in train_dataloader:\n",
    "        imgs, targets = data            \n",
    "        imgs = imgs.to(device) # 也可以不赋值，直接 imgs.to(device)\n",
    "        targets = targets.to(device) # 也可以不赋值，直接 targets.to(device)\n",
    "        outputs = tudui(imgs)\n",
    "        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距\n",
    "        \n",
    "        # 优化器对模型调优\n",
    "        optimizer.zero_grad()  # 梯度清零\n",
    "        loss.backward() # 反向传播，计算损失函数的梯度\n",
    "        optimizer.step()   # 根据梯度，对网络的参数进行调优\n",
    "        \n",
    "        total_train_step = total_train_step + 1\n",
    "        if total_train_step % 100 == 0:\n",
    "            end_time = time.time()\n",
    "            print(end_time - start_time) # 运行训练一百次后的时间间隔\n",
    "            print(\"训练次数：{}，Loss：{}\".format(total_train_step,loss.item()))  # 方式二：获得loss值\n",
    "            writer.add_scalar(\"train_loss\",loss.item(),total_train_step)\n",
    "    \n",
    "    # 测试步骤开始（每一轮训练后都查看在测试数据集上的loss情况）\n",
    "    tudui.eval()  # 当网络中有dropout层、batchnorm层时，这些层不能起作用\n",
    "    total_test_loss = 0\n",
    "    total_accuracy = 0\n",
    "    with torch.no_grad():  # 没有梯度了\n",
    "        for data in test_dataloader: # 测试数据集提取数据\n",
    "            imgs, targets = data # 数据放到cuda上\n",
    "            imgs = imgs.to(device) # 也可以不赋值，直接 imgs.to(device)\n",
    "            targets = targets.to(device) # 也可以不赋值，直接 targets.to(device)\n",
    "            outputs = tudui(imgs)\n",
    "            loss = loss_fn(outputs, targets) # 仅data数据在网络模型上的损失\n",
    "            total_test_loss = total_test_loss + loss.item() # 所有loss\n",
    "            accuracy = (outputs.argmax(1) == targets).sum()\n",
    "            total_accuracy = total_accuracy + accuracy\n",
    "            \n",
    "    print(\"整体测试集上的Loss：{}\".format(total_test_loss))\n",
    "    print(\"整体测试集上的正确率：{}\".format(total_accuracy/test_data_size))\n",
    "    writer.add_scalar(\"test_loss\",total_test_loss,total_test_step)\n",
    "    writer.add_scalar(\"test_accuracy\",total_accuracy/test_data_size,total_test_step)  \n",
    "    total_test_step = total_test_step + 1\n",
    "    \n",
    "    torch.save(tudui, \"./model/tudui_{}.pth\".format(i)) # 保存每一轮训练后的结果\n",
    "    #torch.save(tudui.state_dict(),\"tudui_{}.path\".format(i)) # 保存方式二         \n",
    "    print(\"模型已保存\")\n",
    "    \n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 运行Terminal语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 运行terminal上运行的命令，可以在代码块中输入语句，在语句前加一个感叹号。\n",
    "\n",
    "② 输入 !nvidia-smi，可以查看显卡配置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thu Mar 31 17:24:49 2022       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 471.35       Driver Version: 471.35       CUDA Version: 11.4     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ... WDDM  | 00000000:01:00.0  On |                  N/A |\n",
      "| N/A   61C    P0    47W /  N/A |   2913MiB / 16384MiB |     10%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1868    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A     14152    C+G   ...4__htrsf667h5kn2\\AWCC.exe    N/A      |\n",
      "|    0   N/A  N/A     14904    C+G   ...2\\extracted\\WeChatApp.exe    N/A      |\n",
      "|    0   N/A  N/A     19304    C+G   ...y\\AccountsControlHost.exe    N/A      |\n",
      "|    0   N/A  N/A     21816    C+G   ...5n1h2txyewy\\SearchApp.exe    N/A      |\n",
      "|    0   N/A  N/A     23044    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A     23480    C+G   ...2txyewy\\TextInputHost.exe    N/A      |\n",
      "|    0   N/A  N/A     24180    C+G   ...tracted\\WechatBrowser.exe    N/A      |\n",
      "|    0   N/A  N/A     24376    C+G   ...erver\\YourPhoneServer.exe    N/A      |\n",
      "|    0   N/A  N/A     24912    C+G   ...kzcwy\\mcafee-security.exe    N/A      |\n",
      "|    0   N/A  N/A     25524    C+G   ...me\\Application\\chrome.exe    N/A      |\n",
      "|    0   N/A  N/A     27768    C+G   ...cw5n1h2txyewy\\LockApp.exe    N/A      |\n",
      "|    0   N/A  N/A     27788      C   ...a\\envs\\py3.6.3\\python.exe    N/A      |\n",
      "|    0   N/A  N/A     27960    C+G   ...y\\ShellExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     31320    C+G   C:\\Windows\\explorer.exe         N/A      |\n",
      "|    0   N/A  N/A     32796    C+G   ...e\\StoreExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     35728    C+G   ...artMenuExperienceHost.exe    N/A      |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.3",
   "language": "python",
   "name": "python3.6.3"
  },
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "350px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}