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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 关于神经网络的理论知识(包括卷积神经网络)\n",
    "参考：https://nndl.github.io/nndl-book.pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 导入需要的内容\n",
    "import torch\n",
    "from torch import nn, optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import mnist\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import transforms\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2 图像预处理\n",
    "data_tf = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize([0.5], [0.5])]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 创建模型：4个卷积层+2个全连接\n",
    "# 使用了批标准化和dropout，relu激活\n",
    "class SelfMadeNN(nn.Module):\n",
    "    def __init__(self, n_hidden_1, n_hidden_2, out_dim):\n",
    "        super(SelfMadeNN, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            # (28-3)/1 +1 = 26\n",
    "            nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3),\n",
    "            nn.BatchNorm2d(16),  # 批标准化放在全连接层后面，激活层前面\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.layer2 = nn.Sequential(\n",
    "            # (26-3)/1 +1 = 24\n",
    "            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3),\n",
    "            nn.BatchNorm2d(32),  # 批标准化放在全连接层后面，激活层前面\n",
    "            nn.ReLU(inplace=True),\n",
    "            # (24-2)/2 +1 = 12\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "        self.layer3 = nn.Sequential(\n",
    "            # (12-3)/1 +1 = 10\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3),\n",
    "            nn.BatchNorm2d(64),  # 批标准化放在全连接层后面，激活层前面\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.layer4 = nn.Sequential(\n",
    "            # (10-3)/1 +1 = 8\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3),\n",
    "            nn.BatchNorm2d(128),  # 批标准化放在全连接层后面，激活层前面\n",
    "            nn.ReLU(inplace=True),\n",
    "            # (8-2)/2 +1 = 4\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        )\n",
    "\n",
    "        self.layer5 = nn.Sequential(\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(4 * 4 * 128, n_hidden_1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            \n",
    "            nn.Dropout(),\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",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.layer5(x)\n",
    "        \n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4 设置参数\n",
    "batch_size = 64\n",
    "learning_rate = 0.001\n",
    "momentum = 0.9\n",
    "num_epoch = 10\n",
    "\n",
    "hidden1_nodes = 100\n",
    "hidden2_nodes = 200\n",
    "output_nodes = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SelfMadeNN(\n",
       "  (layer1): Sequential(\n",
       "    (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (layer2): Sequential(\n",
       "    (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (layer3): Sequential(\n",
       "    (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (layer4): Sequential(\n",
       "    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (layer5): Sequential(\n",
       "    (0): Dropout(p=0.5, inplace=False)\n",
       "    (1): Linear(in_features=2048, out_features=100, bias=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Dropout(p=0.5, inplace=False)\n",
       "    (4): Linear(in_features=100, out_features=200, bias=True)\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): Linear(in_features=200, out_features=10, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SelfMadeNN(hidden1_nodes, hidden2_nodes, output_nodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 画图\n",
    "def plot_image(acces, eval_losses, eval_acces):\n",
    "    plt.plot(np.arange(len(acces)), acces)\n",
    "    plt.title('train acc')\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(np.arange(len(eval_losses)), eval_losses)\n",
    "    plt.title('test loss')\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(np.arange(len(eval_acces)), eval_acces)\n",
    "    plt.title('test acc')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_and_test():\n",
    "    # 1 设置参数\n",
    "    batch_size = 64\n",
    "    learning_rate = 0.001\n",
    "    momentum = 0.9\n",
    "    num_epoch = 10\n",
    "\n",
    "    hidden1_nodes = 100\n",
    "    hidden2_nodes = 200\n",
    "    output_nodes = 10\n",
    "\n",
    "    # 2 准备数据集\n",
    "    # 2.1 下载数据集\n",
    "    train_set = mnist.MNIST('./data', train=True, transform=data_tf, download=True)\n",
    "    test_set = mnist.MNIST('./data', train=False, transform=data_tf, download=True)\n",
    "    print(train_set[0][0].shape)\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 创建模型\n",
    "    model = SelfMadeNN(hidden1_nodes, hidden2_nodes, output_nodes)\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",
    "    losses = []\n",
    "    acces = []\n",
    "    eval_losses = []\n",
    "    eval_acces = []\n",
    "\n",
    "    for e in range(num_epoch):\n",
    "        train_loss = 0\n",
    "        train_acc = 0\n",
    "        model.train()\n",
    "        for im, label in train_data:\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",
    "        losses.append(train_loss / len(train_data))\n",
    "        acces.append(train_acc / len(train_data))\n",
    "\n",
    "        # 在测试集上检验效果\n",
    "        eval_loss = 0\n",
    "        eval_acc = 0\n",
    "        model.eval()  # 将模型改为预测模式\n",
    "        for im, label in test_data:\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",
    "        eval_losses.append(eval_loss / len(test_data))\n",
    "        eval_acces.append(eval_acc / len(test_data))\n",
    "        print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'\n",
    "              .format(e, 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",
    "    plot_image(acces, eval_losses, eval_acces)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 由于运行比较慢，下图结果是使用Google colab运行的\n",
    "![jupyter](./demo30.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
}