深度学习(PyTorch)——卷积神经网络(CNN)基础篇

B站up主“刘二大人”视频 笔记

卷积的概念:
从单通道卷积讲起:即input图像是单通道,卷积核kernel也是单通道,那么输出必然也是单通道。这里还没有讲到扩充padding和滑动步长stride,所以只关注输入和输出矩阵的尺寸大小;

讲到这,刘老师介绍了CCD相机模型,这是一种通过光敏电阻,利用光强对电阻的阻值影响,对应地影响色彩亮度实现不同亮度等级像素采集的原件。三色图像是采用不同敏感度的光敏电阻实现的。

还介绍了矢量图像(也就是PPT里通过圆心、边、填充信息描述而来的图像,而非采集的图像);

接下来讲到三通道input图像的卷积操作:实为将三个通道的input分别与三个通道kernel对应相乘,再将对应位置相加,最后输出单通道output图像的过程;

此处的input、kernel、output的形状,以及通道数channel,是要非常注意的,我们玩卷积神经网络,其中,向的卷积层中传递的参数,与这里的参数一一对应,要非常熟悉每一个参数位置,应该是谁的channel值,后面的full connected layer也是一样,传入的是位置参数,也就是说,每一个位置必须是所需对应的参数,决不能混乱;

在后面讲了三个卷积的基本操作,扩充padding、步长stride和池化pooling:

padding是为了让源图像最外一圈或多圈像素(取决于kernel的尺寸),能够被卷积核中心取到。这里有个描述很重要:想要使源图像(1,1)的位置作为第一个与kernel中心重合,参与计算的像素,想想看padding需要扩充多少层,这样就很好计算了吧;
stride操作指的是每次kernel窗口滑动的步长,默认值当然是1了,插句话,假设不使用扩充padding,output图像的尺寸就会缩小,想要使输出的尺寸与输入尺寸保持不变,看看上一个知识点的padding描述,就很好计算需要外圈加几圈去保证输出的尺寸了吧;

只有一个地方需要特别注意的地方,就是整个网络建立完以后,是不关心输入图像的宽度和高度大小的,也就是说,无论来多大尺寸的图像,我(网络)都能处理,需要改动的仅是Fully Connected Layer(分类器)的输入,需要通过前面最后一层的计算来求得;而FC的输出,是确定的(分10类就输出10)。

程序如下:

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

# prepare dateset

batch_size = 64
transforms = transforms.Compose([transforms.ToTensor(),  # 把输入的图像转变成张量 通道*宽度*高度,取值在(0,1)
                                 transforms.Normalize((0.1307,), (0.3081,))])  # 归一化,0.1307均值和0.3081方差

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

# 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)  # 输入通道1个,输出通道10个,卷积盒的大小为5*5
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(2)  # 池化
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        # flatten data from (n,1,28,28)to(n,784)
        batch_size = x.size(0)  # x.size(0)=n
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)  # flatten 变成全连接网络所需要的输入
        x = self.fc(x)  # 用全连接层做变换
        return x


model = Net()

'''在显卡上运行'''
# device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# model.to(device)
'''在显卡上运行'''

# construct loss and optimizer
criterion = torch.nn.CrossEntropyLoss()  # 构造损失函数,交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 构造优化器 lr为学习率,momentum为冲量来优化训练过程

# training cycle forward, backward, update


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()
        # 获得模型预测的结果(64,10)
        outputs = model(inputs)
        # 交叉熵代价函数outputs(64,10),targe(64)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:  # 300次迭代输出一次loss
            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:
            inputs, labels = data

            '''在显卡上运行'''
            # inputs, target = inputs.to(device), target.to(device)
            '''在显卡上运行'''

            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, dim=1)  # dim=1 列是第0个维度,行是第1个维度,返回值是每一行最大值和每一行最大值下标
            total += labels.size(0)  # labels.size是一个(N,1)的元组,labels.size(0)=N
            correct += (predicted == labels).sum().item()  # 张量之间的比较运算,然后求和取标量
    print('accuracy on test set:%d %% ' % (100 * 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)——卷积神经网络(CNN)基础篇_第1张图片 

视频截图如下: 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第2张图片

feature extraction(特征提取层):可以通过卷积运算,从而找到输入的某些特征

卷积层可以保留输入数据的空间结构和空间信息

下采样可以减少数据量,降低运算时间和复杂度,防止过拟合

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第3张图片

单通道的卷积

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第4张图片

 3通道的卷积

输入通道数=卷积核的通道数

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第5张图片

 该种类的卷积核个数=输出通道数

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第6张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第7张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第8张图片 

 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第9张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第10张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第11张图片

 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第12张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第13张图片  

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第14张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第15张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第16张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第17张图片

 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第18张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第19张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第20张图片 

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第21张图片

 用交叉熵损失,因此最后一层不激活深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第22张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第23张图片 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第24张图片

 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第25张图片

 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第26张图片

深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第27张图片 深度学习(PyTorch)——卷积神经网络(CNN)基础篇_第28张图片

 

你可能感兴趣的:(深度学习,pytorch,cnn)