learn_pytorch_32_pytorch实战项目之自定义卷积神经网络分类cifar10数据集GPU.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "说明：   \n",
    "1   程序在Google colab上使用GPU运行  \n",
    "2   GPU与CPU代码区别，数据类型要使用cuda()函数进行转换 \n",
    "\n",
    "详细参考：  \n",
    "torch.cuda包：https://pytorch.org/docs/stable/cuda.html    \n",
    "cuda函数：Moves all model parameters and buffers to the GPU.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import mnist, cifar\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import transforms\n",
    "\n",
    "train_data_tf = transforms.Compose(\n",
    "    [\n",
    "        transforms.Resize(40),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.RandomCrop(32),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n",
    "    ]\n",
    ")\n",
    "\n",
    "test_data_tf = transforms.Compose(\n",
    "    [\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.5], [0.5])\n",
    "    ]\n",
    ")\n",
    "\n",
    "\n",
    "class SelfMadeNN(nn.Module):\n",
    "    # 4个卷积层＋2个全连接层\n",
    "    def __init__(self, n_hidden_1, n_hidden_2, out_dim):\n",
    "        super(SelfMadeNN, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            # (32-3+2*0)/1 +1 = 30\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(32),  # 批标准化放在卷积层后面，激活层前面\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.layer2 = nn.Sequential(\n",
    "            # (30-3+2*0)/1 +1 = 28\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(64),  # 批标准化放在卷积层后面，激活层前面\n",
    "            nn.ReLU(inplace=True),\n",
    "            # (28-2)/2 +1 = 14\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        self.layer3 = nn.Sequential(\n",
    "            # (14-3)/1 +1 = 12\n",
    "            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(64),  # 批标准化放在卷积层后面，激活层前面\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.layer4 = nn.Sequential(\n",
    "            # (12-3)/1 +1 = 10\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(128),  # 批标准化放在卷积层后面，激活层前面\n",
    "            nn.ReLU(inplace=True),\n",
    "            # (10-2)/2 +1 = 5\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "\n",
    "        self.layer5 = nn.Sequential(\n",
    "            nn.Dropout(p=0.5),\n",
    "            nn.Linear(5 * 5 * 128, n_hidden_1),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Dropout(p=0.5),\n",
    "            nn.Linear(n_hidden_1, n_hidden_2),\n",
    "            nn.ReLU(inplace=True),\n",
    "\n",
    "            nn.Linear(n_hidden_2, out_dim),\n",
    "\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 卷积层\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        # 全连接层\n",
    "        # 进入全连接之前要将矩阵转为向量\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.layer5(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "def train_model():\n",
    "    print(torch.cuda.is_available())\n",
    "    \n",
    "    # 1 设置参数\n",
    "    batch_size = 64\n",
    "    learning_rate = 0.001\n",
    "    momentum = 0.9\n",
    "    num_epoch = 100\n",
    "\n",
    "    hidden1_nodes = 100\n",
    "    hidden2_nodes = 200\n",
    "    output_nodes = 10\n",
    "\n",
    "    # 2 准备数据集\n",
    "    # 2.1 下载数据集\n",
    "    train_set = cifar.CIFAR10('./data', train=True, transform=train_data_tf, download=True)\n",
    "    test_set = cifar.CIFAR10('./data', train=False, transform=test_data_tf, download=True)\n",
    "\n",
    "    # 2 分成batch\n",
    "    train_data = DataLoader(train_set, batch_size=batch_size, shuffle=True)\n",
    "    test_data = DataLoader(test_set, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    # 3 创建模型:使用GPU\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "    model = SelfMadeNN(hidden1_nodes, hidden2_nodes, output_nodes)\n",
    "    model.to(device)\n",
    "\n",
    "\n",
    "    \n",
    "    # 3.1 定义 loss 函数\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # 使用随机梯度下降，学习率 0.1\n",
    "\n",
    "    # 3.2 开始训练\n",
    "    for i in range(num_epoch):\n",
    "        train_loss = 0\n",
    "        train_acc = 0\n",
    "        model.train()\n",
    "        for im, label in train_data:\n",
    "            \n",
    "            # 使用GPU数据类型\n",
    "            im = im.cuda()\n",
    "            label =label.cuda()\n",
    "\n",
    "            # 前向传播\n",
    "            out = model(im)\n",
    "            loss = criterion(out,label)\n",
    "\n",
    "            # 反向传播\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            # 记录误差\n",
    "            train_loss += loss.item()\n",
    "            # 计算分类的准确率\n",
    "            _, pred = out.max(1)\n",
    "            num_correct = (pred == label).sum().item()\n",
    "            acc = num_correct / im.shape[0]\n",
    "            train_acc += acc\n",
    "\n",
    "        # 在测试集上检验效果\n",
    "        eval_loss = 0\n",
    "        eval_acc = 0\n",
    "        model.eval()  # 将模型改为预测模式\n",
    "        for im, label in test_data:\n",
    "            \n",
    "            # 使用GPU数据类型\n",
    "            im = im.cuda()\n",
    "            label =label.cuda()\n",
    "            \n",
    "            out = model(im)\n",
    "            loss = criterion(out, label)\n",
    "            # 记录误差\n",
    "            eval_loss += loss.item()\n",
    "            # 记录准确率\n",
    "            _, pred = torch.max(out, 1)\n",
    "            num_correct = (pred == label).sum().item()\n",
    "            acc = num_correct / im.shape[0]\n",
    "            eval_acc += acc\n",
    "\n",
    "        print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'\n",
    "              .format(i, train_loss / len(train_data), train_acc / len(train_data),\n",
    "                      eval_loss / len(test_data), eval_acc / len(test_data)))\n",
    "\n",
    "    print(\"train and test-------------------Done!\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./demo32.png)"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}