目录
[1. 卷积层](#1. 卷积层)
[2. 池化层](#2. 池化层)
[3. 激活函数](#3. 激活函数)
[4. 全连接层](#4. 全连接层)
一、什么是卷积？
对图像 （不同的数据窗口数据）和卷积核 （一组固定的权重：因为每个神经元的多个权重固定，所以又可以看做一个恒定的滤波器filter）做内积 （逐个元素相乘再求和）的操作就是所谓的**『卷积』**操作，也是卷积神经网络的名字来源。
二、卷积神经网络的组成
1. 卷积层
- 功能 ：通过卷积操作提取特征 。卷积核（滤波器）在输入图像上滑动，计算局部区域的加权和，生成特征图。
- 参数：卷积核的大小（如3x3、5x5）、步幅（每次滑动的像素数）和填充（为避免信息损失，通常在图像边缘添加零）。
2. 池化层
- 功能 ：降低特征图 的空间维度 ，减少计算量和参数数量，防止过拟合。
- 类型 ：
- 最大池化：在每个窗口中取最大值。
- 平均池化：在每个窗口中取平均值。
- 参数：池化窗口的大小和步幅。
3. 激活函数
- 功能：引入非线性，帮助模型捕捉复杂的模式。
- 常用类型 ：
- ReLU（修正线性单元）：输出为输入的正部分，负部分输出为0。
- Sigmoid：将输出限制在0到1之间，适用于二分类问题。
- Softmax：将输出转化为概率分布，适用于多分类问题。
4. 全连接层
- 功能：将卷积层和池化层提取的特征进行整合，用于最终的分类或回归。
- 结构：每个神经元与前一层的所有神经元相连接。
三、卷积神经网络的构造
- 输入层--卷积层--池化层--全连接层--输出层
四、代码实现
1.数据预处理
- 从本地读取图片数据并打包
- 将其裁剪成256*256大小并转换成tensor类型数据
- 将对应图片标签也转换成tensor类型数据
python
import torch
import numpy as np
from torch.utils.data import DataLoader, Dataset # 数据包管理工具,打包数据,
from torchvision import transforms
from PIL import Image
class food_dataset(Dataset):
def __init__(self, file_path, transform=None): # 类的初始化,解析数据文件txt
self.file_path = file_path
self.imgs = []
self.labels = []
self.transform = transform
with open(self.file_path) as f: # 是把train.txt文件中图片的路径保存在 self.imgs,train.txt文件中标签保存在self.label里
samples = [x.strip().split(' ') for x in f.readlines()] # 去掉首尾空格 再按空格分成两个元素
for img_path, label in samples:
self.imgs.append(img_path) # 图像的路径
self.labels.append(label) # 标签,还不是tensor
# 初始化:把图片目录加载到self
def __len__(self): # 类实例化对象后,可以使用len函数测量对象的个数
return len(self.imgs)
def __getitem__(self, idx): # 关键,可通过索引的形式获取每一个图片数据及标签
image = Image.open(self.imgs[idx]) # 读取到图片数据,还不是tensor
if self.transform:
# 将pil图像数据转换为tensor
image = self.transform(image) # 图像处理为256x256,转换为tenor
label = self.labels[idx] # label还不是tensor
label = torch.from_numpy(np.array(label, dtype=np.int64)) # label也转换为tensor
return image, label
data_transforms = {
'train':
transforms.Compose([
transforms.Resize([256, 256]),
transforms.ToTensor()
]),
'test':
transforms.Compose([
transforms.Resize([256, 256]),
transforms.ToTensor()
])
}
train_data = food_dataset(file_path=r'.\train.txt', transform=data_transforms['train']) # 64张图片为一个包 训练集60000张图片 打包成了938个包
test_data = food_dataset(file_path=r'.\test.txt', transform=data_transforms['test'])
train_dataloader = DataLoader(train_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)
for x, y in test_dataloader:
print(f"shape of x [N ,C,H,W]:{x.shape}")
print(f"shape of y :{y.shape} {y.dtype}")
break2.创建卷积神经网络
python
from torch import nn # 导入神经网络模块
class CNN(nn.Module): # Convolutional Neural Network
def __init__(self):
super(CNN, self).__init__()
self.conv1 = nn.Sequential( # 将多个层组合成一起。
nn.Conv2d( # 2d一般用于图像,3d用于视频数据(多一个时间维度),1d一般用于结构化的序列数据
in_channels=3, # 图像通道个数,1表示灰度图(确定了卷积核 组中的个数),
out_channels=16, # 要得到几多少个特征图,卷积核的个数
kernel_size=5, # 卷积核大小,5*5
stride=1, # 步长
padding=2 # 一般希望卷积核处理后的结果大小与处理前的数据大小相同,效果会比较好。那pading改如何设计呢?建议stride为1
),
nn.ReLU(), # relu层,不会改变特征图的大小
nn.MaxPool2d(kernel_size=2), # 进行池化操作(2x2 区域) 最大值池化
)
self.conv2 = nn.Sequential( # 但整个 nn.Sequential 可以视为一个卷积模块
nn.Conv2d(16, 32, 5, 1, 2),
nn.ReLU(),
nn.Conv2d(32, 32, 5, 1, 2),
nn.ReLU(),
nn.MaxPool2d(2)
)
self.conv3 = nn.Sequential(
nn.Conv2d(32, 128, 5, 1, 2),
nn.ReLU()
)
self.out = nn.Linear(128 * 64 * 64, 20) # 全连接层得到的结果
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = self.conv3(x)
x = x.view(x.size(0), -1)
output = self.out(x)
return output
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_avaibale() else 'cpu'
model = CNN().to(device) # 把刚刚创建的模型传入到GPU
print(model)输出：
- 可以看到该卷积神经网络有三个卷积模块
- 最后通过全连接层输出预测结果
python
CNN(
(conv1): Sequential(
(0): Conv2d(3, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(1): ReLU()
(2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(conv2): Sequential(
(0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(1): ReLU()
(2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(3): ReLU()
(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(conv3): Sequential(
(0): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(1): ReLU()
)
(out): Linear(in_features=524288, out_features=20, bias=True)
)3.创建训练集和测试集函数
python
def train(dataloader, model, loss_fn, optimizer):
model.train() # 告诉模型,我要开始训练,模型中w进行随机化操作,已经更新w.在训练过程中,w会被修改的
# pytorch提供2种方式来切换训练和测试的模式,分别是:model.train()和 model.eval().
# 一般用法是: 在训练开始之前写上model.trian(),在测试时写上model.eval().
batch_size_num = 1
for x, y in dataloader: #
x, y = x.to(device), y.to(device) # 把训练数据集和标签传入CPU或GPU
pred = model.forward(x) # 向前传播
loss = loss_fn(pred, y) # 通过交叉熵损失函数计算损失值loss
optimizer.zero_grad() # 梯度值清零
loss.backward() # 反向传播计算得到每个参数的梯度值w
optimizer.step() # 根据梯度更新网络w参数
loss_value = loss.item() # 从tensor数据中提取数据出来,tensor获取损失值
if batch_size_num % 2 == 0:
print(f"loss:{loss_value:>7f} [number:{batch_size_num}]")
batch_size_num += 1
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset)
num_batches = len(dataloader)
model.eval() # 测试,w就不能再更新。
test_loss, correct = 0, 0
with torch.no_grad(): # 一个上下文管理器,关闭梯度计算。当你确认不会调用Tensor.backward()的时候。这可以减少计算所占用的消耗
for x, y in dataloader:
x, y = x.to(device), y.to(device)
pred = model.forward(x)
test_loss += loss_fn(pred, y).item() # test loss是会自动累加每一个批次的损失值
correct += (pred.argmax(1) == y).type(torch.float).sum().item()
a = (pred.argmax(1) == y) # dim=1表示每一行中的最大值对应的索引号,dim=0表示每一列中的最大值对应的索引号
b = (pred.argmax(1) == y).type(torch.float)
test_loss /= num_batches # 能来衡量模型测试的好坏。
correct /= size # 平均的正确率
print(f"Test result: \n Accuracy: {(100 * correct)}%, Avg loss: {test_loss}")4.创建损失函数和优化器并进行训练
- 创建处理多分类的损失函数
- 使用Adam优化器
python
loss_fn = nn.CrossEntropyLoss() # 处理多分类
optimizer = torch.optim.Adam(model.parameters(), lr=0.0002)
epochs = 20 # 到底选择多少呢?
for t in range(epochs):
print(f"Epoch {t + 1}\n--------------")
train(train_dataloader, model, loss_fn, optimizer)
print("Done!")
test(test_dataloader, model, loss_fn)输出：
python
Epoch 20
--------------
loss:0.002920 [number:2]
loss:0.003376 [number:4]
Done!
Test result:
Accuracy: 41.02564102564102%, Avg loss: 5.77920389175415