🤵 Author ：Horizon Max

✨ 编程技巧篇：各种操作小结

🎇 机器视觉篇：会变魔术 OpenCV

💥 深度学习篇：简单入门 PyTorch

🏆 神经网络篇：经典网络模型

💻 算法篇：再忙也别忘了 LeetCode

视频链接：Lecture 10 Basic_CNN
文档资料：

//Here is the link:
课件链接：https://pan.baidu.com/s/1vZ27gKp8Pl-qICn_p2PaSw
提取码：cxe4

Basic_CNN

概述

卷积神经网络 CNN（Convolutional Neural Network）

最重要的是卷积（convolution）操作，用于提取图像特征（Feature maps）

一般是由 输入层、卷积层、激活函数、池化层、全连接层 组成

全连接层的权重参数量最大

卷积层

卷积层（Convolutional layer） ：由若干卷积单元组成，每个卷积单元的参数都是通过反向传播算法最佳化得到的；

卷积运算的目的是提取输入的不同特征，第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级，更多层的网路能从低级特征中迭代提取更复杂的特征。

感受野： 卷积神经网络每一层输出的特征图（feature map）上的像素点在输入图片上映射的区域大小；

Kernel（卷积核）： 卷积操作的感受野，本质是一个滤波矩阵，图示卷积核大小为3×3；

Stride（步长）： 卷积核遍历特征图时每步移动的像素值，图示卷积核大小为3×3、步长为2；

Padding（填充）： 对特征图边界进行填充，一般有两种，这样可以使原始特征图在进行卷积操作时每个像素值所占的权重相同，图示卷积核大小为3×3、步长为2、填充为1；

Channel（通道）： 卷积层的通道数（层数）；

卷积层中的每个滤波器都只输出一个通道，然后将每个通道处理的结果汇在一起形成一个通道。

卷积过程小结：

激活函数

激活函数（Activation functions） ：它们将非线性特性引入到我们的网络中，

如果不用激活函数，每一层输出都是上层输入的线性函数，无论神经网络有多少层，输出都是输入的线性组合，这种情况就是最原始的 感知机 （Perceptron）；

如果使用的话，激活函数给神经元引入了非线性因素，使得神经网络可以 任意逼近 任何非线性函数；

这样神经网络就可以应用到众多的 非线性模型 中。

常用 ReLU 作为激活函数：

函数表达式为：

函数图像为：

激活函数 相关的查看：Lecture06 Logistic_Regression

池化层

池化层（Pooling layers） ：主要有两个作用，

一是对卷积层所提取的信息 做更一步降维，减少计算量 ；

二是加强图像特征的 不变性 ，使之增加图像的偏移、旋转等方面的 鲁棒性 。

最大池化（MaxPooling）：即选取池化区域的 最大值 作为输出值；

平均池化（MeanPooling）：即选取池化区域的 平均值 作为输出值；

全连接层

全连接层（Fully Connected layers） ：每一个结点都与上一层的所有结点相连，用来把前边提取到的特征综合起来，它可以整合卷积层或者池化层中具有类别区分性的局部信息，然后经过分类输出，类似于“分类器”的作用。

以下图为例：

Code

用PyTorch实现以上网络架构：

# Here is the code :

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt


# 1 prepare dataset

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])

train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)


# 2 design model using class

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)    # 卷积层，卷积核大小：5 X 5
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(2)     # 池化层，最大池化，池化区域：2 X 2
        self.fc = torch.nn.Linear(320, 10)       # 全连接层，将320维度转换为10个维度对应 0~9 数字

    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)      # -1 自动计算 batch_size = 320
        x = self.fc(x)

        return x


model = Net()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")      # 使用 GPU 训练
model.to(device)


# 3 construct loss and optimizer

criterion = torch.nn.CrossEntropyLoss()      # 使用 softmax 分类器
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# 4 training cycle

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()

        outputs = model(inputs)     # forward, backward, update
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %d %% ' % (100 * correct / total))
    return correct / total


if __name__ == '__main__':
    epoch_list = []
    acc_list = []

    for epoch in range(10):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)

    plt.plot(epoch_list, acc_list)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.show()

运行结果

附录：相关文档资料

PyTorch 官方文档： PyTorch Documentation
PyTorch 中文手册： PyTorch Handbook

《PyTorch深度学习实践》系列链接：

  Lecture01 Overview
  Lecture02 Linear_Model
  Lecture03 Gradient_Descent
  Lecture04 Back_Propagation
  Lecture05 Linear_Regression_with_PyTorch
  Lecture06 Logistic_Regression
  Lecture07 Multiple_Dimension_Input
  Lecture08 Dataset_and_Dataloader
  Lecture09 Softmax_Classifier
  Lecture10 Basic_CNN
  Lecture11 Advanced_CNN
  Lecture12 Basic_RNN
  Lecture13 RNN_Classifier