框架
让我们先看一下CNN的框架
卷积层中后是ReLu激活函数 ，然后是深化池，之后是全连接，最后进行Softmax进行归一化。
所以，我们先逐一了解一下它们各个部分
全连接层
全连接层也称感知机，BP神经网络
全连接层（fully connected layers，FC）在整个卷积神经网络中起到“分类器”的作用。如果说卷积层、池化层和激活函数等操作是将原始数据映射到隐层特征空间的话，全连接层则起到将学到的“分布式特征表示”（下面会讲到这个分布式特征）映射到样本标记空间的作用
优缺点
优点
1.能够自适应，自主学习(能够根据x得出y)
2.有着较强的非线性映射能力（在结点后增加了ReLu激活函数）
3.严谨的推导过程
4.较强的泛化能力
5.降维或升维
降维呢，也很好理解，由第一列的九维变为第二列的四维
我们再来看看缺点
缺点
1.全局感知（每一结点的值都会影响最后的w）
2.权重参数众多（4*9=36个权重）
3.学习速率慢（因为权重矩阵巨大）
代码演示
在这里，我们只定义了一层全连接层
import torch.nn
class CNNnetwork(torch.nn.Module):
self.linear1 = torch.nn.Linear(3*3, 4)
self.ReLU1 = torch.nn.ReLU()
def forward(self, x):
x = x.reshape(x.shape[0], -1)
x = self.linear1(x)
x = self.ReLU1(x)
return x前向传播是我们自己来定义的，而后向传播是自动执行的
为了解决全连接层去全局感知的问题，我们提出了一种解决方案--局部连接
局部连接
图示
0，1，3，4与w00,w10,w30,w40相乘得到a0，同理
1，2，4，5与w11,w21,w41,w51相乘得到a1
3，4，6，7与w32,w42,w62,w72相乘得到a2
4，5，7，8与w43,w53,w73,w83相乘得到a3
即以1为步长，每4个为一组，进行相乘
优点
显而易见，减少了权重
由原来的4*8=36变为了4*4=16
卷积神经网络--参数共享
局部连接的plus版
图示
以最后一部分2*2矩阵为例，与局部连接原理相同
4*w1+5*w2+7*w3+8*w4得到a4
a0,a1,a2就是同理啦
这样一来我们的权重就变为了1*4=4
权重更少了
这样就体现出来了参数共享的优点
优点
进一步减少权重
像这样输出比输入减小了，比如输入5*5，输出3*3，则称为下采样
在上图中的w1,w2,w3,w4这一堆，则称为卷积核
单通道卷积核及步长stride
卷积网络之所以工作，完全是卷积核的功劳
那么feature map是怎么计算的呢？
图中深色部分是计算部分
input image和kernel同一位置上的数相乘，最后将所有相乘的数相加，得到最终结果，也就是4
input image为输入图像，kernel为卷积核，feature map为特征映射层
步长为1 ，2
步长为1，根据步长进行滑动，先从左到右按步长1滑动，再从上到下按步长1滑动
怎么求feature map的大小呢？
i为input image的简写，k为kernel的简写
代码演示
import torch
import torch.nn.functional as F
input=torch.tensor([[1,1,1,0,0],
[0,1,1,1,0],
[0,0,1,1,1],
[0,0,1,1,0],
[0,1,1,0,0]])
kernel=torch.tensor([[1,0,1],
[0,1,0],
[1,0,1]])
print("原尺寸：")
print(input.shape)
print(kernel.shape)
# 重新定义尺寸，把尺寸改为4位数，1个batchsize，1个通道，长和宽不变
# 矩阵的个数就是通道数
input=torch.reshape(input,(1,1,5,5))
kernel=torch.reshape(kernel,(1,1,3,3))
print("修改后的尺寸：")
print(input.shape)
print(kernel.shape)
# stride=1时的输出
output1=F.conv2d(input,kernel,stride=1)
print("stride=1时的输出")
print(output1)
# stride=2时的输出
output2=F.conv2d(input,kernel,stride=2)
print("stride=2时的输出")
print(output2)torch.nn.functional.conv2d是用来进行卷积运算的，参数如下：
- input：输入特征图
- weight：卷积核
- bias：偏置参数
- stride：卷积步长
- padding：填充
- dilation：膨胀系数
- groups：分组卷积
结果
原尺寸：
torch.Size([5, 5])
torch.Size([3, 3])
修改后的尺寸：
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
stride=1时的输出
tensor([[[[4, 3, 4],
[2, 4, 3],
[2, 3, 4]]]])
stride=2时的输出
tensor([[[[4, 4],
[2, 4]]]])步长为3
当我们将步长设置为3，移动时，我们发现不能移动完，会缺失一部分，这时候，我们就需要用到padding（填充）
默认padding为VALID有效的
最终feature map的大小可以根据以上公式计算，无论有没有padding，上述公式都适用
当padding为SAME时，得到的结果的长宽与输入的长宽一致
代码演示
import torch
import torch.nn.functional as F
input=torch.tensor([[1,1,1,0,0],
[0,1,1,1,0],
[0,0,1,1,1],
[0,0,1,1,0],
[0,1,1,0,0]])
kernel=torch.tensor([[1,0,1],
[0,1,0],
[1,0,1]])
print("原尺寸：")
print(input.shape)
print(kernel.shape)
# 重新定义尺寸，把尺寸改为4位数，1个batchsize，1个通道，长和宽不变
# 矩阵的个数就是通道数
input=torch.reshape(input,(1,1,5,5))
kernel=torch.reshape(kernel,(1,1,3,3))
print("修改后的尺寸：")
print(input.shape)
print(kernel.shape)
# # stride=1时的输出
# output1=F.conv2d(input,kernel,stride=1)
# print("stride=1时的输出")
# print(output1)
# # stride=2时的输出
# output2=F.conv2d(input,kernel,stride=2)
# print("stride=2时的输出")
# print(output2)
output3=F.conv2d(input,kernel,stride=3,padding=2)
print("stride=3,padding=2")
print(output3)
output4=F.conv2d(input,kernel,stride=1,padding=1)
print("stride=1,padding=1")
print(output4)
output5=F.conv2d(input,kernel,stride=1,padding="same")
print("stride=1,padding='same'")
print(output5)结果
原尺寸：
torch.Size([5, 5])
torch.Size([3, 3])
修改后的尺寸：
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
stride=3,padding=2
tensor([[[[1, 1, 0],
[0, 4, 0],
[0, 1, 0]]]])
stride=1,padding=1
tensor([[[[2, 2, 3, 1, 1],
[1, 4, 3, 4, 1],
[1, 2, 4, 3, 3],
[1, 2, 3, 4, 1],
[0, 2, 2, 1, 1]]]])
stride=1,padding='same'
tensor([[[[2, 2, 3, 1, 1],
[1, 4, 3, 4, 1],
[1, 2, 4, 3, 3],
[1, 2, 3, 4, 1],
[0, 2, 2, 1, 1]]]])我们可以看出，output4与output5的结果相同，这就能够帮助我们更好地理解padding="same"了
多通道多卷积核
图示
我们知道，有几个矩阵就有几个通道。
通常来说，RGB图像时三通道的
卷积核的通道个数要与输入图像层的通道个数相同，而输出为对应通道在滑动窗口内卷积的和
计算过程图示
注意：
feature map的个数是根据卷积核来的，有几个卷积核就有几个feature map，
而卷积核的个数是我们自己设置的，卷积核的通道数是根据上一层的通道数确定的
池化层
经过池化层后，图像的大小变小（下采样），通道数保持不变，默认的时减小为原来的一半。
作用
对输入的特征图进行压缩
1.特征不变性，提取主要特征
2.特征降维，简化网络计算复杂度
3.减小过拟合，更方便优化
最常用的：最大池化
图示
输入层为4*4的矩阵，卷积核为2*2的矩阵，步长为2，进行最大池化
首先我们看第一组，1，3，1，3 最大值为3，那么特征图层的第一个结果就是最大值三，按步长滑动，后面同理，都是取最大值
平均池化
与最大池化同理，不同的地方是平均池化取4个数的平均值
下面让我们来看看神经元连接方式和池化后的大小计算
神经元连接方式和池化后的大小计算
图示
特征
1.没有要学习的参数：池化只是从目标区域中取最大值或平均值，所以没有必要有学习的1参数。
2.通道数不发生改变
3.它是利用图像局部相关性的原理，对图像进行子抽样，这样可以保留有用信息，对微小的位置变化具有鲁棒性（健壮性），输入数据发生微小偏差时，池化仍会返回相同的结果
代码演示
import torch
input=torch.tensor([[1,3,2,4],
[1,3,2,4],
[5,7,6,8],
[5,7,6,8]],dtype=torch.float32)
mp=torch.nn.MaxPool2d(kernel_size=2)
ap=torch.nn.AvgPool2d(kernel_size=2)
input=torch.reshape((input),(1,1,4,4))
output1=mp(input)
print(output1)
output2=ap(input)
print(output2)reshape将input的形状转化为1，1，4，4
意思是，1个矩阵，1个通道，input的形状变为4*4
mp=torch.nn.MaxPool2d(kernel_size=2) ap=torch.nn.AvgPool2d(kernel_size=2)
分别为最大池化和平均池化，卷积核大小都是2*2的
结果
tensor([[[[3., 4.],
[7., 8.]]]])
tensor([[[[2., 3.],
[6., 7.]]]])卷积神经网络框架及实战
框架在文章的最开始部分
下面是代码
代码
这个是修改了猫狗数据集的部分内容
导包
from PIL import Image # 这行代码从Pillow库中导入了Image模块，它提供了许多用于打开、操作和保存图像的函数。
import numpy as np
from torch.utils.data import Dataset # Dataset类是torch.utils.data模块中的一个抽象类，用于表示一个数据集
from torchvision import transforms
import os # os模块提供了与操作系统交互的函数，例如读取目录内容、检查文件是否存在等。
import torch
import matplotlib.pyplot as plt
import matplotlib
#设置字体为楷体
matplotlib.rcParams['font.sans-serif'] = ['KaiTi']自定义数据集
# 自定义数据集
class mydataset(Dataset):
def __init__(self,root_dir,lable_dir):
self.root_dir=root_dir # 文件主路径dataset/train
self.label_dir=lable_dir # 分路径 cat 和 dog
self.path=os.path.join(self.root_dir,self.label_dir) # 将文件路径的两部分连接起来
self.img_path=os.listdir(self.path) # 查看
self.transform = transforms.Compose([ # 包含：
transforms.Resize((224,224)), # 统一大小为224*224
transforms.ToTensor() # 转化为Tensor类型
])
def __len__(self):
ilen=len(self.img_path)
return ilen # 返回self.img_path列表的长度，即该数据集包含的图像数量。
def __getitem__(self,item):
img_name=self.img_path[item] # path路径中的第item个图像
img_item_path=os.path.join(self.path,img_name) # 该图像的路径
img=Image.open(img_item_path) # 打开并读取图像
img=self.transform(img) # 转化为（224*224）并转化为Tensor类型
if self.label_dir=="cat": # 如果是cat下的图片
label=1 # label为猫狗的二分类值，因为二分类不能用文字“猫，狗”表示，所以这里我们用1来表示猫，0来表示狗
else:
label=0
return img,label
root_dir="dataset/train"
lable_cat_dir="cat"
lable_dog_dir="dog"
cat_dataset=mydataset(root_dir,lable_cat_dir)
dog_dataset=mydataset(root_dir,lable_dog_dir)
train_dataset=cat_dataset+dog_dataset
test_dir="D:\\猫狗数据集\\PetImages\\test"
cat_test=mydataset(test_dir,lable_cat_dir)
dog_test=mydataset(test_dir,lable_dog_dir)
test_dataset=cat_test+dog_test
训练模型
class CNNnetwork(torch.nn.Module):
def __init__(self):
super(CNNnetwork, self).__init__()
self.cnn1=torch.nn.Conv2d(in_channels=3,out_channels=3,kernel_size=3)
self.relu1=torch.nn.ReLU()
self.pool1=torch.nn.MaxPool2d(kernel_size=2)
self.linear1=torch.nn.Linear(3*111*111,2)
def forward(self, x):
x=self.cnn1(x)
x=self.relu1(x)
x=self.pool1(x)
x=x.reshape(x.shape[0],-1)
x = self.linear1(x)
return x
trainloader=torch.utils.data.DataLoader(train_dataset,batch_size=4, shuffle=True)
testloader=torch.utils.data.DataLoader(test_dataset,batch_size=4, shuffle=True)
在这里，我们将BPnetwork修改为CNNnetwork
在init构造方法中，我们根据框架，先定义卷积层，在定义ReLu激活函数，在使用池化层，最后进行全连接。（这里只定义一层来进行简单的示例，当然，我们也可以定义多层卷积层和池化层）
框架中，最后要用到Softmax进行归一化处理，但是由于我们在下面会使用交叉熵损失函数，这一步就可以省略了
测试模型
model=CNNnetwork()
criterion = torch.nn.CrossEntropyLoss()
optimizer= torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
eopchs=25
for i in range(eopchs):
sumloss=0
for images, lables in trainloader:
ypre=model(images)
loss=criterion(ypre,lables)
loss.backward()
optimizer.step()
optimizer.zero_grad()
sumloss+=loss.item()
print("Epoch {}, Loss: {}".format(i+1, sumloss/len(trainloader)))
examples=enumerate(testloader)
batch,(images,lables)=next(examples)可视化
fig=plt.figure()
for i in range(4):
t=torch.unsqueeze(images[i],dim=0) # 增加一个维度，使t的形状与模型期望的形状相匹配
logps=model(t)
probab=list(logps.detach().numpy()[0])
# logps.detach()从计算图中分离出logps，确保后续的操作不会影响到模型的梯度。
# 接着，.numpy()将张量转换为NumPy数组。[0]取出第一个元素（因为t是一个批次大小为1的数据），
# 最后list()将这个元素转换为一个列表。此时，probab是一个包含所有类别概率的列表。
pred_label=probab.index(max(probab)) # 找出probab列表中概率最大的元素的索引，这个索引即代表模型预测的类别标签。
if pred_label==0:
pre="狗"
else:
pre="猫"
img=torch.squeeze(images[i]) # 移除大小为1的维度，让它回到原来的形状
img1=img.permute(1, 2, 0) # 将图像的维度从（channels, height, width）调整为（height, width, channels）
img1=img1.numpy()
plt.subplot(2,2,i+1) # 创建一个2*2的子图网格，并选择第i+1个子图作为当前绘图区域
plt.tight_layout() # 自动调整子图参数，使之填充整个图像区域并尽量减少重叠
plt.imshow(img1,cmap='gray',interpolation='none')
plt.title(f"预测值：{pre}")
plt.xticks([]) # 设置x轴和y轴的刻度标签为空
plt.yticks([])
plt.show()如果代码有不理解的地方，可以看上面的注释，或者查询
深度学习--BP实战猫狗分类数据集-CSDN博客
这篇文章，猫狗数据集的原照片的下载网址也在里面
结果
Epoch 1, Loss: 0.8405862331390381
Epoch 2, Loss: 1.250564288534224
Epoch 3, Loss: 1.7798350632190705
Epoch 4, Loss: 0.6765258073806762
Epoch 5, Loss: 0.6690190553665161
Epoch 6, Loss: 0.6570614218711853
Epoch 7, Loss: 0.6433873891830444
Epoch 8, Loss: 0.621343731880188
Epoch 9, Loss: 0.5983625173568725
Epoch 10, Loss: 0.5741375863552094
Epoch 11, Loss: 0.5408185303211213
Epoch 12, Loss: 0.5043941497802734
Epoch 13, Loss: 0.46845043897628785
Epoch 14, Loss: 0.42693803906440736
Epoch 15, Loss: 0.3808044224977493
Epoch 16, Loss: 0.34137908518314364
Epoch 17, Loss: 0.3042459607124329
Epoch 18, Loss: 0.26810121834278106
Epoch 19, Loss: 0.23699309378862382
Epoch 20, Loss: 0.21158137172460556
Epoch 21, Loss: 0.17672300338745117
Epoch 22, Loss: 0.16740593314170837
Epoch 23, Loss: 0.13847940117120744
Epoch 24, Loss: 0.12489973902702331
Epoch 25, Loss: 0.10602239817380905
完整代码
from PIL import Image # 这行代码从Pillow库中导入了Image模块，它提供了许多用于打开、操作和保存图像的函数。
import numpy as np
from torch.utils.data import Dataset # Dataset类是torch.utils.data模块中的一个抽象类，用于表示一个数据集
from torchvision import transforms
import os # os模块提供了与操作系统交互的函数，例如读取目录内容、检查文件是否存在等。
import torch
import matplotlib.pyplot as plt
import matplotlib
#设置字体为楷体
matplotlib.rcParams['font.sans-serif'] = ['KaiTi']
# 自定义数据集
class mydataset(Dataset):
def __init__(self,root_dir,lable_dir):
self.root_dir=root_dir # 文件主路径dataset/train
self.label_dir=lable_dir # 分路径 cat 和 dog
self.path=os.path.join(self.root_dir,self.label_dir) # 将文件路径的两部分连接起来
self.img_path=os.listdir(self.path) # 查看
self.transform = transforms.Compose([ # 包含：
transforms.Resize((224,224)), # 统一大小为224*224
transforms.ToTensor() # 转化为Tensor类型
])
def __len__(self):
ilen=len(self.img_path)
return ilen # 返回self.img_path列表的长度，即该数据集包含的图像数量。
def __getitem__(self,item):
img_name=self.img_path[item] # path路径中的第item个图像
img_item_path=os.path.join(self.path,img_name) # 该图像的路径
img=Image.open(img_item_path) # 打开并读取图像
img=self.transform(img) # 转化为（224*224）并转化为Tensor类型
if self.label_dir=="cat": # 如果是cat下的图片
label=1 # label为猫狗的二分类值，因为二分类不能用文字“猫，狗”表示，所以这里我们用1来表示猫，0来表示狗
else:
label=0
return img,label
root_dir="dataset/train"
lable_cat_dir="cat"
lable_dog_dir="dog"
cat_dataset=mydataset(root_dir,lable_cat_dir)
dog_dataset=mydataset(root_dir,lable_dog_dir)
train_dataset=cat_dataset+dog_dataset
test_dir="D:\\猫狗数据集\\PetImages\\test"
cat_test=mydataset(test_dir,lable_cat_dir)
dog_test=mydataset(test_dir,lable_dog_dir)
test_dataset=cat_test+dog_test
class CNNnetwork(torch.nn.Module):
def __init__(self):
super(CNNnetwork, self).__init__()
self.cnn1=torch.nn.Conv2d(in_channels=3,out_channels=3,kernel_size=3)
self.relu1=torch.nn.ReLU()
self.pool1=torch.nn.MaxPool2d(kernel_size=2)
self.linear1=torch.nn.Linear(3*111*111,2)
def forward(self, x):
x=self.cnn1(x)
x=self.relu1(x)
x=self.pool1(x)
x=x.reshape(x.shape[0],-1)
x = self.linear1(x)
return x
trainloader=torch.utils.data.DataLoader(train_dataset,batch_size=4, shuffle=True)
testloader=torch.utils.data.DataLoader(test_dataset,batch_size=4, shuffle=True)
model=CNNnetwork()
criterion = torch.nn.CrossEntropyLoss()
optimizer= torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
eopchs=25
for i in range(eopchs):
sumloss=0
for images, lables in trainloader:
ypre=model(images)
loss=criterion(ypre,lables)
loss.backward()
optimizer.step()
optimizer.zero_grad()
sumloss+=loss.item()
print("Epoch {}, Loss: {}".format(i+1, sumloss/len(trainloader)))
examples=enumerate(testloader)
batch,(images,lables)=next(examples)
fig=plt.figure()
for i in range(4):
t=torch.unsqueeze(images[i],dim=0) # 增加一个维度，使t的形状与模型期望的形状相匹配
logps=model(t)
probab=list(logps.detach().numpy()[0])
# logps.detach()从计算图中分离出logps，确保后续的操作不会影响到模型的梯度。
# 接着，.numpy()将张量转换为NumPy数组。[0]取出第一个元素（因为t是一个批次大小为1的数据），
# 最后list()将这个元素转换为一个列表。此时，probab是一个包含所有类别概率的列表。
pred_label=probab.index(max(probab)) # 找出probab列表中概率最大的元素的索引，这个索引即代表模型预测的类别标签。
if pred_label==0:
pre="狗"
else:
pre="猫"
img=torch.squeeze(images[i]) # 移除大小为1的维度，让它回到原来的形状
img1=img.permute(1, 2, 0) # 将图像的维度从（channels, height, width）调整为（height, width, channels）
img1=img1.numpy()
plt.subplot(2,2,i+1) # 创建一个2*2的子图网格，并选择第i+1个子图作为当前绘图区域
plt.tight_layout() # 自动调整子图参数，使之填充整个图像区域并尽量减少重叠
plt.imshow(img1,cmap='gray',interpolation='none')
plt.title(f"预测值：{pre}")
plt.xticks([]) # 设置x轴和y轴的刻度标签为空
plt.yticks([])
plt.show()
后面会发布另外两个卷积神经网络实战：VGG16和ResNet18 的原理和代码
