VGG16.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4481a6a2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:24:57.932127Z",
     "start_time": "2021-07-27T07:24:56.767191Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn.functional as F\n",
    "from torchsummary import summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da17b484",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:05.839085Z",
     "start_time": "2021-07-27T07:24:57.934070Z"
    }
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 忽略低级别的警告\n",
    "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
    "config = tf.compat.v1.ConfigProto()\n",
    "config.gpu_options.per_process_gpu_memory_fraction = 0.9\n",
    "session = tf.compat.v1.Session(config=config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51c85684",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:05.854890Z",
     "start_time": "2021-07-27T07:25:05.840926Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义图像转换操作的组合\n",
    "transform = transforms.Compose([\n",
    "    transforms.RandomHorizontalFlip(),  # 随机水平翻转\n",
    "    transforms.RandomRotation(15),  # 随机旋转，角度范围为[-15, 15]\n",
    "    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),  # 随机颜色调整\n",
    "    transforms.ToTensor(),  # 转换为张量\n",
    "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])  # 标准化操作，使用给定的均值和标准差\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c8ded94",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:05.870889Z",
     "start_time": "2021-07-27T07:25:05.856885Z"
    }
   },
   "outputs": [],
   "source": [
    "Batch_Size = 512"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9addcf45",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:07.596267Z",
     "start_time": "2021-07-27T07:25:05.873839Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 定义 CIFAR-10 数据集的训练集和测试集，并应用之前定义的图像转换操作\n",
    "trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
    "testset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n",
    "\n",
    "# 创建用于训练和测试的数据加载器，设置批次大小、是否随机洗牌和工作线程数\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=Batch_Size, shuffle=True, num_workers=8)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=Batch_Size, shuffle=True, num_workers=8)\n",
    "\n",
    "# 定义 CIFAR-10 数据集的类别标签\n",
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7bfbd76",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:07.612225Z",
     "start_time": "2021-07-27T07:25:07.597230Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "classes = trainset.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e8d69a9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:22.800574Z",
     "start_time": "2021-07-27T07:25:07.663055Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(trainset.data[0])\n",
    "im,label = next(iter(trainloader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ee8cb8b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:22.816533Z",
     "start_time": "2021-07-27T07:25:22.802570Z"
    }
   },
   "outputs": [],
   "source": [
    "def imshow(img):\n",
    "    img = img / 2 + 0.5\n",
    "    img = np.transpose(img.numpy(),(1,2,0))\n",
    "    plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aaff9cf",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:23.317232Z",
     "start_time": "2021-07-27T07:25:23.003035Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "imshow(im[0])\n",
    "plt.figure(figsize=(8,12))\n",
    "imshow(torchvision.utils.make_grid(im[:32]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e21e565",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:23.444854Z",
     "start_time": "2021-07-27T07:25:23.319188Z"
    }
   },
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu' # 判断是否用GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e6edd12",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:23.459814Z",
     "start_time": "2021-07-27T07:25:23.448844Z"
    }
   },
   "outputs": [],
   "source": [
    "cfg = {\n",
    "    'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n",
    "    'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n",
    "    'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],\n",
    "    'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "461dc769",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:27.119059Z",
     "start_time": "2021-07-27T07:25:23.464800Z"
    }
   },
   "outputs": [],
   "source": [
    "class VGG(nn.Module):\n",
    "    \n",
    "    def __init__(self, vgg_name):\n",
    "        super(VGG, self).__init__()\n",
    "        \n",
    "        # 定义网络结构的特征提取部分\n",
    "        self.features = self._make_layers(cfg[vgg_name])\n",
    "        \n",
    "        # 定义分类器部分\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(True),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(True),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(512, 10),\n",
    "        )\n",
    "\n",
    "        # 初始化权重\n",
    "        self._initialize_weight()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 前向传播过程\n",
    "        out = self.features(x)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        out = self.classifier(out)\n",
    "        return out\n",
    "    \n",
    "    # 创建网络层\n",
    "    def _make_layers(self, cfg):\n",
    "        layers = []\n",
    "        in_channels = 3  # RGB 初始通道为3\n",
    "        for x in cfg:\n",
    "            if x == 'M':\n",
    "                layers += [nn.MaxPool2d(kernel_size=2, stride=2)] \n",
    "            else:\n",
    "                layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1), \n",
    "                           nn.BatchNorm2d(x),\n",
    "                           nn.ReLU(inplace=True)]  \n",
    "                in_channels = x  \n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    # 初始化参数\n",
    "    def _initialize_weight(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.xavier_normal_(m.weight.data)\n",
    "                if m.bias is not None:\n",
    "                    m.bias.data.zero_()\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                m.weight.data.normal_(0, 0.01)\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "# 创建VGG模型实例并将其移动到指定的设备上\n",
    "net = VGG('VGG16').to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ed27711",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:29.080782Z",
     "start_time": "2021-07-27T07:25:27.121025Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "summary(net,(3,32,32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16ed4288",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:29.127662Z",
     "start_time": "2021-07-27T07:25:29.100730Z"
    }
   },
   "outputs": [],
   "source": [
    "x = torch.randn(2,3,32,32).to(device)\n",
    "y = net(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd286de2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:29.391985Z",
     "start_time": "2021-07-27T07:25:29.131646Z"
    }
   },
   "outputs": [],
   "source": [
    "net = VGG('VGG16').to(device)\n",
    "if device == 'cuda':\n",
    "    net = nn.DataParallel(net)\n",
    "    torch.backends.cudnn.benchmark = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb7f33f1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:29.407906Z",
     "start_time": "2021-07-27T07:25:29.393944Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义优化器，损失函数和学习率调度器\n",
    "optimizer = optim.SGD(net.parameters(), lr=1e-1, momentum=0.9, weight_decay=5e-4)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', factor=0.5, verbose=True, patience=5, min_lr=0.000001)  # 动态更新学习率\n",
    "\n",
    "# 导入时间库\n",
    "import time\n",
    "\n",
    "# 设置训练的总轮数\n",
    "epoch = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0e286c7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:25:29.423863Z",
     "start_time": "2021-07-27T07:25:29.412893Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "if not os.path.exists('./model'):\n",
    "    os.makedirs('./model')\n",
    "else:\n",
    "    print('文件已存在')\n",
    "save_path = './model/VGG16.pth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12d44d4d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:54:26.440693Z",
     "start_time": "2021-07-27T07:25:29.426857Z"
    }
   },
   "outputs": [],
   "source": [
    "from utils import train\n",
    "from utils import plot_history\n",
    "Acc, Loss, Lr = train(net, trainloader, testloader, epoch, optimizer, criterion, scheduler, save_path, verbose = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3592c7c2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:54:29.337645Z",
     "start_time": "2021-07-27T07:54:26.460382Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plot_history(epoch ,Acc, Loss, Lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f76c2fd5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T09:19:45.638467Z",
     "start_time": "2021-07-27T09:19:11.069302Z"
    }
   },
   "outputs": [],
   "source": [
    "# 测试模型性能\n",
    "correct = 0   # 正确分类的样本数\n",
    "total = 0    # 总共的样本数\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=True, num_workers=0)\n",
    "net.eval()  # 将模型设置为评估模式\n",
    "for data in testloader:  # 遍历测试集\n",
    "    images, labels = data\n",
    "    images = images.to(device)\n",
    "    labels = labels.to(device)\n",
    "    net.eval()  # 再次确保模型处于评估模式\n",
    "    if hasattr(torch.cuda, 'empty_cache'):\n",
    "        torch.cuda.empty_cache()\n",
    "    outputs = net(images)  # 获取模型输出\n",
    "    \n",
    "    _, predicted = torch.max(outputs.data, 1)\n",
    "    total += labels.size(0)          # 更新总样本数\n",
    "    correct += (predicted == labels).sum()  # 更新正确分类的样本数\n",
    "\n",
    "# 计算并打印模型在测试集上的准确率\n",
    "print('Accuracy of the network on the 10000 test images: %.2f %%' % (100 * correct / total))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88c118ca",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T09:20:29.373094Z",
     "start_time": "2021-07-27T09:19:45.644410Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义两个列表，用于存储每个类别中测试正确的样本数量和总样本数量，初始化为0\n",
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "\n",
    "# 将模型设置为评估模式，并在不计算梯度的情况下进行测试\n",
    "net.eval()\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        if hasattr(torch.cuda, 'empty_cache'):\n",
    "            torch.cuda.empty_cache()\n",
    "        outputs = net(images)\n",
    "\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        c = (predicted == labels).squeeze()\n",
    "        for i in range(len(images)):\n",
    "            label = labels[i]\n",
    "            class_correct[label] += c[i].item()\n",
    "            class_total[label] += 1\n",
    "\n",
    "# 打印每个类别的准确率\n",
    "for i in range(10):\n",
    "    print('Accuracy of %5s : %.2f %%' % (classes[i], 100 * class_correct[i] / class_total[i]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7ae6086",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T07:54:53.742778Z",
     "start_time": "2021-07-27T07:54:29.349624Z"
    }
   },
   "outputs": [],
   "source": [
    "# 从测试数据加载器中获取一个批次的数据\n",
    "dataiter = iter(testloader)\n",
    "images, labels = next(dataiter)\n",
    "images_ = images\n",
    "images_ = images_.to(device)\n",
    "labels = labels.to(device)\n",
    "\n",
    "# 在模型上进行推理\n",
    "val_output = net(images_)\n",
    "_, val_preds = torch.max(val_output, 1)\n",
    "\n",
    "# 计算准确率\n",
    "correct = torch.sum(val_preds == labels.data).item()\n",
    "\n",
    "# 将预测结果和标签从GPU移动到CPU\n",
    "val_preds = val_preds.cpu()\n",
    "labels = labels.cpu()\n",
    "\n",
    "# 打印准确率\n",
    "print(\"Accuracy Rate = {}%\".format(correct/len(images) * 100))\n",
    "\n",
    "# 可视化预测结果和标签\n",
    "fig = plt.figure(figsize=(25, 25))\n",
    "for idx in np.arange(64):    \n",
    "    ax = fig.add_subplot(8, 8, idx+1, xticks=[], yticks=[])\n",
    "    imshow(images[idx])\n",
    "    ax.set_title(\"{}, ({})\".format(classes[val_preds[idx].item()], classes[labels[idx].item()]), \n",
    "                 color=(\"green\" if val_preds[idx].item() == labels[idx].item() else \"red\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e847551",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-27T09:20:29.511722Z",
     "start_time": "2021-07-27T09:20:29.376115Z"
    }
   },
   "outputs": [],
   "source": [
    "torch.save(net,save_path[:-4]+str(epoch)+'.pth')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}