零基础学习人工智能—Python—Pytorch学习（八）
前言
本文介绍卷积神经网络的上半部分。
其实，学习还是需要老师的，因为我自己写文章的时候，就会想当然，比如下面的滑动窗口，我就会想当然的认为所有人都能理解，而实际上，我们在学习的过程中之所以卡顿的点多，就是因为学习资源中想当然的地方太多了。
概念
卷积神经网络，简称CNN， 即Convolutional Neural Network的缩写。
滤波器/卷积核（Filter/Kernels）
卷积核是一个小矩阵（通常是3x3、5x5等），它在输入图像上滑动（即移动），并与图像的局部区域进行矩阵乘法（点积）操作。结果是一个单值，这个值代表了该局部区域的某种特征。
点积就是内积，就是np.dot函数，内积是个值，就是两个矩阵对应项相乘，在相加
例如。a=[2,3] 和 b=[4,5]，它们的点积是a⋅b=(2×4)+(3×5)=8+15=23
点积的意义是a⋅b=∥a∥∥b∥cosθ，意思是说，点积等于a向量的模乘以b向量的模乘以ab的夹角θ的cos的值
向量的模就是向量的长度，v=[3,4]，因为勾股定理，c²=a²+b²,所以∥v∥=c=根号下a²+b²=根号下9+16=根号下25=5
例。rgb图，是3通道，卷积核会在3个通道上都进行卷积操作，最后形成一个特征图。
卷积核的尺寸
如果尺寸是 5×5，那么滑动窗口的大小也是 5×5。
特征图（Feature Map）
当一个卷积核（或滤波器）滑动在输入图像上时，它会在每一个位置计算卷积核与输入图像区域的点积，结果是一个标量。通过滑动整个图像，得到一组标量值，这些值构成了一个新的二维矩阵，这个矩阵就是特征图。
在CNN中，使用越多的卷积核，意味着提取的特征图越多，因此卷积核越大就可以得到的越丰富的特征。
更多的卷积核意味着更多的计算和内存消耗。因此，在选择卷积核数量时，也要考虑硬件资源的限制。
最大池化层（Max Pooling Layer）
是卷积神经网络（CNN）中常用的下采样（或降采样）技术。它用于减小特征图的尺寸，从而减少计算量，并有助于控制模型的复杂度（防止过拟合）。
最大池化操作使用一个固定大小的窗口（通常是2x2或3x3），在特征图上滑动。
在窗口覆盖的区域内，最大池化层会选择该区域的最大值作为输出。
步幅决定了池化窗口在特征图上滑动的步长。步幅为2意味着窗口每次移动2个像素。
每次池化操作生成的特征图尺寸会比输入特征图小。池化操作会减少特征图的宽度和高度，但保持深度（通道数）不变。
例，4x4 的输入特征图如下
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
使用 2x2 的最大池化窗口和步幅为 2，池化过程如下：
池化窗口覆盖 1 2 5 6，最大值为 6
池化窗口覆盖 3 4 7 8，最大值为 8
池化窗口覆盖 9 10 13 14，最大值为 14
池化窗口覆盖 11 12 15 16，最大值为 16
得到的输出特征图为：
6 8
14 16
结合代码理解
结合下面的代码理解上面的概念。
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
# device config
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# hyper parameters
batch_size = 4
learning_rate = 0.001
num_epochs = 0
# dataset has PILImage images of range [0, 1].# We transform them to Tensors of normalized range [-1, 1]
# transforms.ToTensor()：将PIL图像或numpy数组转换为PyTorch张量，并将值范围从[0,1]变为[0,255]。
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))：对图像进行归一化处理，将图像的像素值调整到[-1,1]范围。
transform = transforms.Compose(
[transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
train_dataset = torchvision.datasets.CIFAR10(
root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.CIFAR10(
root='./data', train=False, download=True, transform=transform)
train_loader = torch.utils. data.DataLoader(
dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
dataset=test_dataset, batch_size=batch_size, shuffle=False)
print('每份100个，被分成多了份', len(train_loader))
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# get some random training images
dataiter = iter(train_loader)
images, labels = dataiter.__next__()
# show images
imshow(torchvision.utils.make_grid(images))
# nn.Conv2d 是 PyTorch 用于定义二维卷积层的类
# 三个参数分别为 in_channels、out_channels 和 kernel_size
# in_channels (输入通道数)：
# 值=3 这是输入图像的通道数。对于彩色图像，通常有3个通道（对应于RGB），因此这里的值为3。如果输入的是灰度图像，通常只有1个通道。
# 对于彩色图像（RGB），输入图像有3个通道。卷积核对每个通道独立进行操作，然后将这些结果相加，得到输出特征图。
# 输出特征图的数量由卷积核的数量决定。如果你有多个卷积核，它们会捕捉输入图像中的不同特征，每个卷积核生成一个特征图
# out_channels (输出通道数)：
# 值=6 这是卷积层输出的通道数，也称为卷积核的数量。这个参数决定了卷积操作后生成多少个不同的特征图。在本例中，卷积层会生成6个特征图，也就是说会有6个不同的卷积核应用于输入图像。
# kernel_size (卷积核大小)：
# 值=5 这是卷积核的尺寸，表示卷积核的宽度和高度。这里使用的是 5x5 的卷积核。这意味着每个卷积核会查看输入图像的 5x5 像素区域，并通过滑动窗口方式在整个图像上进行卷积操作。
# conv1：第一个卷积层，将输入的3通道图像（RGB）通过一个5x5的卷积核，生成6个输出通道。这里，卷积层使用 6 个卷积核，每个卷积核会生成一个特征图。因此，该卷积层的输出是 6 个特征图，特征图的深度（通道数）为 6。
conv1 = nn.Conv2d(3, 6, 5)
# pool：最大池化层，将特征图的尺寸缩小一半。
# 第一个参数 (2): 池化窗口的大小。这表示池化操作将应用于一个 2x2 的窗口上。池化窗口决定了在特征图上进行池化操作的区域大小。
# 第二个参数 (2): 池化的步幅（stride）。步幅决定了池化窗口在特征图上滑动的步长。步幅为 2 意味着池化窗口每次移动 2 个像素。
pool = nn.MaxPool2d(2, 2)
# conv2：第二个卷积层，将6个通道的输入特征图通过一个5x5的卷积核，生成16个输出通道。
conv2 = nn.Conv2d(6, 16, 5)
# torch.Size([4, 3, 32, 32]) 一个批次是4个图像，一个图像3个通道，一个通道行32个点，一个通道列32个点
print(images.shape)
x = conv1(images)
# torch.Size([4, 6, 28, 28]) 一个批次是4个图像，输出了6个特征图，一个特征图行28个点，一个特征图列28个点
# 公式是（w-f+2p）/s+1 w是图像的宽 f是卷积的宽 p是padding s是stride步幅
# 步幅（stride, s）: 默认为 1，意味着卷积核在图像上每次移动一个像素。
# 填充（padding, p）: 默认为 0，意味着没有额外的像素填充在图像的边界。
print(x.shape)
x = pool(x)
# torch.Size([4, 6, 14, 14]) pooling layer 定义的是2*2 所以这个正好变成14行 14列
# print(x.shape)
x = conv2(x)
# torch.Size([4, 16, 10, 10]) （w-f+2p）/s+1=（14-5+2*0）/1+1=9+1=10
print(x.shape)
x = pool(x)
# torch.Size([4, 16, 5, 5]) pooling layer 定义的是2*2 所以这个正好变成5行 5列
print(x.shape)
传送门：
零基础学习人工智能—Python—Pytorch学习—全集
注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！
若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！
