CNN卷积神经网络代码实现及解析(仅全连接层)
目录
一、相关库的引入与解析
二、数据预处理—–1.图像格式转换 2.特征缩放,参数归一化
三、1、加载出MNIST数据集 2、创建数据加载器(包括训练集和测试集)
四、神经网络模型创建(类)—-包括全连接层(属性特征)和向前传播(行为)
附:softmax()与log_softmax()
五、调用神经网络,选择损失函数,优化器(min损失函数)
六、模型训练与保存
附:MNIST数据集的形成以及前面的处理操作小总结:
七、模型的评估测试
八、预测自己提供的数字(使用模型)
九、结构拼接
一、相关库的引入与解析
import matplotlib.pyplot as plt '''#2D绘图库'''
from PIL import Image '''#pillow(PIL库),用于图像处理(导入Image子类)'''
import torch '''#torch库,基于Tensor(张量)的GPU加速计算,创建神经网络'''
from torch import nn '''#torch库中nn子模块:专用于构建神经网络(全连接层、卷积层
、循环神经网络层)'''
'''
PyTorch框架中有一个重要且好用的包:torchvision,该包主要由3个子包组成,
分别是:torchvision.datasets、torchvision.models、torchvision.transforms。
'''
from torchvision import transforms '''transforms是对图像进行预处理'''
from torchvision.datasets import MNIST '''MNIST数据集:就是所谓的X→Y(问题及
答案)用来训练模型'''
from torch.utils.data import DataLoader
'''
torch.utils.data库实现自由的数据读取,
包括三个子类:.Dataset、.sampler.Sampler(data_source)、.DataLoader
'''
import os '''“os库是 Python 的标准库之一,用于与操作系统进行交互,这里用于路径操作'''
import numpy as np '''#numpy库,矩阵数组计算'''
#import
#import···as···更名操作
#from··(大库)··import··(子模块)··(from PIL import Image)
Image.open (打开图像文件)
Image.resize(调整图像大小)
Image.convert (图像格式转换(灰度图像))
二、数据预处理—–1.图像格式转换 2.特征缩放,参数归一化
(让各个参数的取值范围差不多,便于选择合适的步长,学习率)(对象MNIST)
'''example1:'''
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))])
#注意这里的逗号两个
'''example2:'''
transform = transforms.Compose([transforms.ToTensor()])
#transforms.Compose() —— 可以组合几个变换一起操作
#transforms.ToTensor() —— 将原始的PILImage格式或者numpy.array格式转为张量,并把灰度范围从0-255变换到(0,1)之间
参数是无吗
#transform.Normalize(mean所处理数据的原始平均值, std所处理数据的原始标准偏差) —–Z-score归一化,把(0,1)变换到(-1,1),经该处理后数据会变为均值为 0,标准差为 1的标准化像素值,每个值x被转换为(x – mean) / std,接下来将用于处理MNIST数据集,使数据在0附近居中,使其具有指定的平均值和标准偏差,确保数据分布会更加符合标准正态分布,可改善训练过程和收敛性,更适合于神经网络的训练。
·均值为 0,标准差为 1意义: 零中心化: 将数据的均值移动到零,这样可以更好地匹配神经网络的激活函数(如 ReLU)的工作区间。 单位标准差: 将数据缩放到标准差为 1,使得数据具有一致的尺度,防止某些特征对训练过程的影响过大。
三、1、加载出MNIST数据集 2、创建数据加载器(包括训练集和测试集)
'''example1:'''
# 训练数据集
'''加载 MNIST 数据集'''
train_data = MNIST(root='./data',train=True,transform=
transforms.ToTensor(),download=False)
'''创建一个数据加载器'''
train_loader = DataLoader(train_data,shuffle=True,batch_size=64)
# 测试数据集(结构同上)
test_data = MNIST(root='./data',train=False,transform=
transforms.ToTensor(),download=False)
test_loader = DataLoader(test_data,shuffle=False,batch_size=64)
----------------------------------------------------------------------
'''example2:'''
#整体用函数
def data_loader(train):#上方对训练集测试集的代码基本一样不一样在与train=?即作为参数
transform_tensor = transforms.Compose((transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))))#两个操作合一了,反正都是对MNIST进行操作的
dataset = torchvision.datasets.MNIST('./data', train, transform =
transform_tensor, download=True)#等于号左右有一个写上就行了
dataloader = DataLoader(dataset, shuffle=True,batch_size=15)
return dataloader
''''''主函数中使用时
train_data = data_loader(train=True)
test_data = data_loader(train=False)
用于在训练神经网络时迭代数据。
结构:MNIST(参数一:指定存储路径,参数二:加载的是否是训练集,参数三:对图像的转换操作,参数四:若数据集不存在是否从互联网下载) 参数三:应用于每个图像的转换函数。常用的转换包括将图像转换为 PyTorch 张量 (
transforms.ToTensor()
)和标准化图像(transforms.Normalize(mean, std)
)
结构:
DataLoader(
参数一:包装数据的对象,
参数二:是否打乱(
提高模型的泛化能力),
参数三: 批量操作数量)
用于包装数据集,使其可以批量加载并支持多线程加速。综上所述,这两行代码的目的是将 MNIST 训练数据集加载到内存中,并创建一个数据加载器(函数应该返回的),以便在训练神经网络时可以按批次随机抽取数据,提高训练效率。
DataLoader
训练集和测试集中都已经包含了一个手写数字和对应答案,一般训练集打乱测试集不打,都打乱也可以。(将训练数据随机打乱有助于提高模型的泛化能力,防过拟合。确保模型在每个 epoch 中看到不同顺序,这样模型在训练时不会依赖于特定的输入顺序,从而学到更通用的特征。训练集优化更新参数,测试集评估性能)
四、神经网络模型创建(类)—-包括全连接层(属性特征)和向前传播(行为)
class Model(nn.Module):'''是Module父类的子类'''
def __init__(self):
super(Model,self).__init__()'''记住'''
'''四个全连接层'''
self.layer1 = torch.nn.Linear(28*28,64)'''torch可以不用加,因为from torch import nn '''
self.layer2 = torch.nn.Linear(64, 25)
self.layer3 = torch.nn.Linear(25, 15)
self.layer4 = torch.nn.Linear(15, 10)
def forward(self, a): #向前传播,a为输入的图像(未经任何处理)
a = a.view(-1, 784)#展平
a = torch.nn.functional.relu(self.layer1(a))
a = torch.nn.functional.relu(self.layer2(a))
a = torch.nn.functional.relu(self.layer3(a))
a = torch.nn.functional.log_softmax(self.layer4(a), dim=1)
return a #别忘了这里要返回一个输出
nn.Module
是所有神经网络模块的基类,自定义的会继承。
super(当前类的名称Model,当前实例self)函数用于返回父类。当前类的名称(访问当前类的父类),当前实例对当前实例进行操作。函数中调用
super
来初始化父类确保父类中的初始化逻辑被执行,正确设置模型结构。
!注意此时的a为之前处理过一次的MNIST数据集(仍为28*28的二维图像张量(矩阵)(之前只是对数据范围进行了一些调整未改变维度))。全连接层(线性层)接收一维向量。
self.layer1 = torch.nn.Linear(输入大小,输出大小)
torch.nn.functional.relu(self.layer1(a)) ——第一层加ReLU激活函数
x=x.view(-1,28*28)
(四维展
二维)
:将输入张量 x
重新变形为大小为 (-1, 784)
的张量。-1
表示自动计算维度大小,784
表示将 28×28 的图像扁平化为 784 维。view
调整张量的形状,不改变其数据。-1
表示自动计算维度的大小,使总元素数量保持不变。这里 -1
会自动计算为 batch_size
。(batch_size, 1(通道数), 28, 28)(batch_size, 784)!!!!!!!
附:softmax()与log_softmax()
多分类任务最后一层
log_softmax():计算
softmax
后的对数,更具数值稳定性,常与 nll_loss
负对数似然损失函数 一起使用。计算交叉熵损失时,使用 log_softmax()
更方便。交叉熵损失函数通常包括一个 log
操作,因此与 log_softmax()
结合使用可以避免重复计算对数。
softmax():用于模型的输出层,将输出转换为概率分布。需要概率值的场景。
实际应用中,使用交叉熵损失函数时,通常直接使用 torch.nn.CrossEntropyLoss
,该损失函数内部已经包含了 log_softmax
和 nll_loss
的组合
使用案例一:———-(分开)
import torch.nn as nn
'''最后一层直接用log_softmax()'''
a = torch.nn.functional.log_softmax(self.layer4(a), dim=1)
'''损失函数定义为nll_loss()'''
loss = torch.nn.functional.nll_loss(output, y)
使用案例二:———-(合着)
import torch.nn as nn
···
x = torch.relu(self.linear3(x))
'''nn.CrossEntropyLoss() 是一个类而不是函数,不能直接像函数一样调用传入参数。
需要先实例化为一个对象,然后通过这个对象调用方法来计算损失。
正确的使用方式是先实例化 nn.CrossEntropyLoss(),
然后将预测值 predictions 和真实标签 targets 作为参数传递给它的实例方法来计算损失
!!!!!!!记住'''
criterion = nn.CrossEntropyLoss()
loss = criterion(predictions, targets)
log_softmax(二维张量为经过上一层后的数据,dim=)
输入张量,即模型的输出。通常是二维张量。第一维:batch size,第二维:类别数目(或者某个特征的维度)。
dim=1
表示在第一维(即类别维度)上进行 softmax 归一化操作。
在模型的前向传播过程中,当输入的特征向量经过 self.layer4
(20,10)后,输出是一个二维张量,其形状为 (batch_size, 10)
:
nll_loss(经过softmax的输出,target)
target 是每个样本真实的标签
五、调用神经网络,选择损失函数,优化器(min损失函数)
'''调用神经网络'''
model = Model()
Model()是一个通用的结构,需要进行调用产生一个实例
'''损失函数的选择'''
#example1
loss = torch.nn.functional.nll_loss(output, y)
#example2
criterion = nn.CrossEntropyLoss()
#结合以上理解
'''优化器的选择'''
#example1
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
#example2
optimizer = torch.optim.SGD(model.parameters(), lr=0.8)
torch.optim.SGD
(随机梯度下降)
基本的优化算法,每次迭代时使用当前批次数据的梯度更新模型参数。计算相对简单,适合大规模模型。可以实现更精细的控制。易陷入局部最优点,特别是对于高度非凸的损失函数。需要手动调节学习率和学习率衰减策略。
torch.optim.Adam
(自适应矩估计优化器)(默认可选)
Adam 是一种自适应学习率的优化算法,结合了动量梯度下降和 RMSProp 算法。可能需要调整默认参数(如学习率)以获得最佳性能。
使用结构:torch.optim.Adam(model.parameters(),Ir=学习率)
model.parameters()
是返回模型在训练中要更新迭代的参数
六、模型训练与保存
#写成函数
def train():
for index,data in enumerate(train_loader):
input,target = data # input为输入数据,target为标签
'''模型训练的一般步骤'''
optimizer.zero_grad() # 梯度清零
y_predict = model(input) # 模型预测
loss = criterion(y_predict,target) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新参数
'''模型训练的一般步骤'''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'''模型保存'''
'''同时保存优化器(如果仅保存模型参数而不保存优化器状态,恢复训练时优化器将没有
之前的梯度和动量信息,可能导致学习策略的不一致和效率降低)'''
if index % 100 == 0: # 每一百次保存一次模型,打印损失
torch.save(model.state_dict(),"./model/model.pkl") # 保存模型
torch.save(optimizer.state_dict(),"./model/optimizer.pkl")
print("损失值为:%.2f" % loss.item())
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
for index, data in enumerate(train_loader):
迭代数据加载器 train_loader
中的数据批次
enumerate: 内置函数:使用enumerate 遍历train_loader,
在遍历迭代对象时,同时获取当前元素的索引和值。返回的结果是一个包含索引和数据的元组。
index
是当前批次的索引,从 0 开始递增。
data
是当前批次的数据,通常是一个包含输入数据和标签的元组 (inputs, labels)
。
input, target = data
是一种常见的解构赋值(也称为拆包),用于从 data
变量中提取输入和目标张量。通常数据和标签成对地存储在数据加载器中,这种方式可以将它们分开并传递给模型进行训练和评估。
模型保存:torch.save(model.state_dict(), "./model/model.pkl")
torch.save
:是 PyTorch 中的一个函数,用于将对象序列化并保存到磁盘。可以保存各种类型的对象,如模型的 state_dict
、优化器的 state_dict
以及其他 Python 对象。
model.state_dict()
:state_dict
是一个 Python 字典对象,它将每一层的参数(如权重和偏置)映射到其名称。返回模型的所有可学习参数及其当前值,包括 nn.Module
对象的所有层的参数。这个字典包含了模型的权重、偏置等所有参数,便于保存和加载。
./model/model.pkl:"./model/"
指定了保存目录,"model.pkl"
是保存的文件名。
.pkl
扩展名是 Python 常用的 pickle 文件格式扩展名,表示这是一个序列化文件。
损失值的打印:
loss.item()
用于将损失值(loss
)从一个张量(tensor
)转换为一个标准的 Python 数值(通常是浮点数)。%.2f
表示以浮点数形式显示,并保留两位小数
#可直接写到过程中
for epoch in range(2):
for (x, y) in train_data:
'''模型训练的一般步骤'''
model.zero_grad()
output = model.forward(x.view(-1, 28 * 28))
loss = torch.nn.functional.nll_loss(output, y) # 计算损失
loss.backward() # 反向传播
optimizer.step()# 更新参数
'''模型训练的一般步骤'''
print("epoch", epoch, "accuracy:", evaluate(test_data, net))
for epoch in range(2):一个数据集用两遍。训练循环的迭代遍历次数。确保模型能充分学习数据的特征。使得模型逐步逼近最优解。
for (x, y) in train_data:由上
train_loader中包含索引和数据,所以这里直接从train_data中找,结果是一个元组。
input+ target==data......data+index==loader
(下面的x 等价于 上面的input)
—————–模型训练的一般步骤—————
# 梯度清零:optimizer.zero_grad()
和 model.zero_grad()
这两个方法用于清零梯度。每次训练迭代中,梯度是累加的。前一次计算的梯度会影响下一次计算的结果。因此,在反向传播前,需要清零梯度。
optimizer.zero_grad()(推荐),
清零所有由这个优化器管理的参数的梯度。通常在训练循环的每次迭代开始时调用,以确保优化器在进行参数更新之前,计算的是当前 batch 的梯度,而不是累积的梯度优化器可以管理多个模型或部分模型的参数,因此更灵活。
model.zero_grad(),
清零模型中所有参数的梯度。直接作用于模型参数的。比较少用。
# 模型预测: y_predict = model(input) 和output = model.forward(x.view(-1, 28 * 28))(这样的原因是forward对应的处理中没有展开这一个操作),y_predict与output等价
# 计算损失: 损失函数传入预测结果与真实结果
# 反向传播: loss.backward()
# 更新参数: optimizer.step()
附:MNIST数据集的形成以及前面的处理操作小总结:
创建数据集:
TensorDataset
将 inputs(张量)
和 labels
(标签为数字几)组合成一个数据集对象。创建数据加载器:
DataLoader
将数据集分成小批次(batch),并提供并行加载、数据打乱等功能。batch_size=10
,表示每个批次包含 10 个样本,shuffle=True
表示每个 epoch 开始时打乱数据。遍历数据加载器:
enumerate
遍历 train_loader
,每次迭代返回一个索引 index
和一个数据批次 data
。data
是一个包含当前批次输入数据和标签的元组 (inputs, labels)
。index
和 data
,对当前批次的数据进行处理(如前向传播、计算损失、反向传播等)。七、模型的评估测试
def evaluate(test_data, model):
correct = 0 #初始化清零
total = 0 #初始化清零
with torch.no_grad():
for (x, y) in test_data:
outputs = model.forward(x.view(-1, 28 * 28))
'''输出的是一系列概率10依次遍历查找最大的那个'''
for i, output in enumerate(outputs):
''
if torch.argmax(output) == y[i]:
correct += 1
''
total += 1
return correct / total
for (x, y) in test_data:(之前是for (x, y) in train_data:)
enumerate
函数从索引 0 开始遍历,所以i从零开始
torch.argmax(output)
:返回 output
张量中最大值的索引,即模型预测的类别。
def test():
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
input,target = data
output=model(input) # output输出10个预测取值,
最大的为预测的数
--------------------------------------------------------------
probability,predict=torch.max(output.data,dim=1)
total += target.size(0) # target是形状为(batch_size,1)的矩阵,
使用size(0)取出该批的大小(一次训练了一批一批有几个)
--------------------------------------------------------------
correct += (predict == target).sum().item() # predict和target均
为(batch_size,1)的矩阵,sum()求出相等的个数
--------------------------------------------------------------
print("准确率为:%.2f" % (correct / total))
评估标准:correct / total
with torch.no_grad():测试模型时,不需要计算梯度,使用
torch.no_grad()
上下文管理器,可以临时关闭自动求导功能(PyTorch中的张量默认具有自动求导功能,当你对张量进行操作时,PyTorch会自动构建一个计算图并保存梯度用于反向传播,从而实现自动求导),可节省内存并加快计算速度,不需要存储梯度信息。
———-
torch.argmax
(output)
:返回 output
张量中最大值的索引,即模型预测的类别。这里的output是十个值中的一个。
probability,predict=torch.max(output.data,dim=1) : 返回一个元组,第一个为最大概率值,第二个为最大值的下标。这里的output是十个值。
———-
# target是形状为(batch_size,1)的矩阵,使用size(0)取出该批的大小
这个函数直接返回 和 这个函数输出
八、预测自己提供的数字(使用模型)
def test_mydata():
image = Image.open('D:\\test\\test_five.png') '''# 取自定义手写图片'''
image = Image.resize((28, 28)) '''# 裁剪尺寸为28*28'''
image = Image.convert('L') '''# 转换为灰度图像'''
transform = transforms.ToTensor()
image = transform(image) '''# 转为张量'''
image = image.view(1, 1, 28, 28) '''# 调整张量的形状'''
output = net(image) '''# 调整后传入模型
probability, predict = torch.max(output.data, dim=1) '''#同前'''
print("此手写图片值为:%d" % (predict[0]))
plt.title('此手写图片值为:{}'.format((int(predict))), fontname="SimHei")
plt.imshow(image.squeeze())
plt.show()
transform = transforms.ToTensor()这句别忘了不能省以及出现过类似的多次
调整图像大小常用transforms.resize
()
或者 PIL 库的Image. resize()
方法。对PyTorch 的张量(Tensor),不能直接调用 image.resize()
改变大小,因为张量的形状是由其数据内容决定的,不是尺寸函数决定。
image.resize((28, 28))将图像调整到 28×28 像素,与 MNIST 数据集的标准图像尺寸匹配。
image = image.view(1, 1, 28, 28),图像张量调整为适合输入到 CNN 模型中的形状。
1
表示批量大小(batch size),即一次输入一张图片。1
表示通道数(channel),因为手写数字图像是灰度图像,所以通道数为 1。28, 28
表示图像的宽和高。
probability, predict = torch.max(output.data, dim=1) #同前
plt.title() 用于设置 Matplotlib 图的标题。标题将显示手写数字图像的预测值。标题使用的字体将为“SimHei”,显示中文字符。.format是 Python 字符串格式化的方法之一,用于将变量的值插入到字符串中的指定位置
( image.view() image.squeeze())!!!!!!!!!squeeze()删除一个维度
九、结构拼接
结构一:
transform = transforms.Compose({})
train_data =
train_loader =
test_data =
test_loader =
class Model(nn.Module):
model = Model()'''这里在全局中调用了,是全局变量了,所以
后续函数中使用无需作为参数传入'''
criterion =
optimizer =
def train():
# 加载模型
if os.path.exists('./model/model.pkl'):
model.load_state_dict(torch.load("./model/model.pkl")) # 加载保存模型的参数
def test():
def test_mydata():
if __name__ == '__main__':
test_mydata()
for i in range(5):
train()
test()
原代码链接:https://blog.csdn.net/IronmanJay/article/details/128434368
if __name__ == '__main__':的作用
一个python文件有两种使用方法,第一作为脚本直接执行,第二是 import 到其他的 python 脚本中被调用。 if __name__ == 'main': 下的代码在第一种情况下会被执行,而 import 到其他脚本中是不会被执行。
结构二:
def
def
''''''
def main():
''''
if __name__ == "__main__":
main()
作者:woneday嘿