将（七）全连接神经网络改成卷积神经网络，正确率得到了提升。
全连接层神经网络相当于将一张2维图拆分成一行的一维形式，但却丧失了空间位置信息（例如：原来2维相邻的位置，转变成全链接时可能就分隔得很远）。而卷积神经网络却避免了这一情况。
1、假设一张图的维度是3x5x5，对应的卷积核是3x3x3，卷积后得到1x3x3：
2、对于其 n 通道的 5 x 5 图片所对应的 n 通道 3 x 3 卷积核，最后所得的卷积为：
3、对于 n 通道 width(in) x height(in) 图片，所对应 m 个 n 通道 width(in) x height(in) 卷积核，得到4维卷积【m 层、n通道、width(in) x height(in)】，然后将对全部卷积拼起来：
4、卷积层：
import torch
in_channels, out_channels = 5, 10 # s
width, height = 100, 100
kernel_size = 3
batch_size = 1
input = torch.randn(batch_size,
in_channels,
width,
height)
# 卷积层
conv_layer = torch.nn.Conv2d(in_channels, # 输入通道数量
out_channels, # 输出通道数量
kernel_size=kernel_size)
output = conv_layer(input)
print(input.shape) # 输入是5个通道，100x100
print(output.shape) # 输出是10个通道，98x98
print(conv_layer.weight.shape) # 卷积层权重形状，10个输入通道、5个输出通道、3x3卷积核大小
运行结果：
5、最大值池化：
而最大值池化即是下采样，引用博主：不堪沉沦的解析
Max Pooling层的代码：
import torch
# 输入数据
input = [3,4,6,5,
2,4,6,8,
1,6,7,8,
3,7,5,4]
# 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
input = torch.Tensor(input).view(1, 1, 4, 4)
# 最大值池化
maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)
output = maxpooling_layer(input)
print(output)
运行结果：
6、卷积代码：（将（七）博文中的程序“全连接层”转换成“卷积层”）
#############将上一个程序（04_09_Number_Detect.py）全连接层转换成卷积层###################
################################卷积模型##############################################
# import torch
# in_channels, out_channels = 5, 10 # s
# width, height = 100, 100
# kernel_size = 3
# batch_size = 1
#
# input = torch.randn(batch_size,
# in_channels,
# width,
# height)
# # 卷积层
# conv_layer = torch.nn.Conv2d(in_channels, # 输入通道数量
# out_channels, # 输出通道数量
# kernel_size=kernel_size)
#
# output = conv_layer(input)
#
# print(input.shape) # 输入是5个通道，100x100
# print(output.shape) # 输出是10个通道，98x98
# print(conv_layer.weight.shape) # 卷积层权重形状，10个输入通道、5个输出通道、3x3卷积核大小
###############################卷积##################################################
# import torch
#
# # 输入数据
# input = [3,4,6,5,7,
# 2,4,6,8,2,
# 1,6,7,8,4,
# 9,7,4,6,2,
# 3,7,5,4,1]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 5, 5)
# # 卷积层中参数：1层卷积层、1通道、卷积核大小3、滑动2格、没有加偏置
# conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride=2, padding=1, bias=False)
# # 将数据...构造一个输出通道数（1）、输入通道数（1）、3x3的卷积核，
# kernel = torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1, 1, 3, 3)
# # 把张量 kernel的.data 赋予给卷积层的权重的 .data
# conv_layer.weight.data = kernel.data
#
# output = conv_layer(input)
# print(output)
############################池化处理#####################################################
# import torch
#
# # 输入数据
# input = [3,4,6,5,
# 2,4,6,8,
# 1,6,7,8,
# 3,7,5,4]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 4, 4)
# # 最大值池化
# maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)
#
# output = maxpooling_layer(input)
# print(output)
#############将上一个程序（04_09_Number_Detect.py）全连接层转换成卷积层###################
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
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(), # 将PIL格式图像转换成Tensor矩阵向量（维度28x28转换成1x28x28，1：为RGB通道）【 [0...255]--->[0,1] 】
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)
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5) # 卷积层：1-->10
self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5) # 卷积层：10-->20
self.pooling = torch.nn.MaxPool2d(2) # 池化层层：1-->10
self.fc = torch.nn.Linear(320, 10) # 全连接层，320--10
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) # .view：将数据变成全连接网络（-1：自动检测矩阵有有多少行，列指定为784）
x = self.fc(x)
return x
# 想使用模型，就实例化即可，可以直接调用
model = Net()
# 将模型放到GPU上运行，需要加如下两行代码（训练集、测试集中的输入值、实际值也需要加载到GPU上）
# 若有多个显卡，同时想跑多个模型，则可以把不同的模型分配到不同的GPU来跑
# device = torch.device("cude:0" if torch.cuda.is_available() else "cpu")
# model.to(device)
###################3 构建损失函数、优化器###############################
criterion = torch.nn.CrossEntropyLoss() # 交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) # 参数优化
#####################4 循环训练 #########################
def train(epoch):
running_loss = 0.0
for batch_idx, data in enumerate(train_loader, 0):
# 准备数据（input：输入，target：实际值）
inputs, target = data
# 将输入、实际值加载到GPU
# inputs, target = inputs.to(device), target.to(device)
# 梯度清0
optimizer.zero_grad()
# 前向传播
outputs = model(inputs)
# 交叉熵损失函数计算
loss = criterion(outputs, target)
# 反向传播
loss.backward()
# 参数优化
optimizer.step()
# 累计loss
running_loss += loss.item()
# 数据集一共有batch_idx个数据，每隔300个打印一次平均损失函数值
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（矩阵形式）,以及样品数据的标签(矩阵形式)
# 将输入、实际值加载到GPU中
# inputs, target = inputs.to(device), target.to(device)
outputs = model(images) # 根据样品数据做预测，得到一个矩阵
_, predicted = torch.max(outputs.data, dim=1) # _:每一行的最大值是多少；predicted：每一行最大值的下标；（dim=0:以列方向找，dim=1:以行方向找）
total += labels.size(0) # 获取一共的lables标签数量
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
test()
运行结果：
内容主要参考了b站up主：刘二大人。