CNN卷积神经网络代码实现及解析（仅全连接层）

woneday嘿

已于 2024-07-10 13:17:35 修改

阅读量2.1k

点赞数 58

文章标签：深度学习人工智能 python 神经网络卷积神经网络学习

于 2024-07-09 22:26:02 首次发布

本文链接：https://blog.csdn.net/2301_80397661/article/details/140271630

版权

一、相关库的引入与解析

二、数据预处理-----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意义： $\cdot$ $\cdot$ 零中心化: 将数据的均值移动到零，这样可以更好地匹配神经网络的激活函数（如 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)

用于在训练神经网络时迭代数据。

$\star$ 结构：MNIST(参数一：指定存储路径，参数二：加载的是否是训练集，参数三：对图像的转换操作，参数四：若数据集不存在是否从互联网下载) 参数三：应用于每个图像的转换函数。常用的转换包括将图像转换为 PyTorch 张量（transforms.ToTensor()）和标准化图像（transforms.Normalize(mean, std)）

$\star$ 结构：DataLoader(参数一：包装数据的对象, 参数二：是否打乱（提高模型的泛化能力）,参数三： 批量操作数量) DataLoader 用于包装数据集，使其可以批量加载并支持多线程加速。综上所述，这两行代码的目的是将 MNIST 训练数据集加载到内存中，并创建一个数据加载器（函数应该返回的），以便在训练神经网络时可以按批次随机抽取数据，提高训练效率。

训练集和测试集中都已经包含了一个手写数字和对应答案，一般训练集打乱测试集不打，都打乱也可以。（将训练数据随机打乱有助于提高模型的泛化能力，防过拟合。确保模型在每个 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 #别忘了这里要返回一个输出

$\star$ nn.Module 是所有神经网络模块的基类，自定义的会继承。

$\star$ super（当前类的名称Model，当前实例self）函数用于返回父类。当前类的名称（访问当前类的父类）,当前实例对当前实例进行操作。函数中调用 super 来初始化父类确保父类中的初始化逻辑被执行，正确设置模型结构。

！注意此时的a为之前处理过一次的MNIST数据集（仍为28*28的二维图像张量（矩阵）（之前只是对数据范围进行了一些调整未改变维度））。全连接层（线性层）接收一维向量。

$\star$ self.layer1 = torch.nn.Linear(输入大小,输出大小)

$\star$ torch.nn.functional.relu(self.layer1(a)) ------第一层加ReLU激活函数

$\star$ x=x.view(-1,28*28)（四维展二维）：将输入张量 x 重新变形为大小为 (-1, 784) 的张量。-1 表示自动计算维度大小，784 表示将 28x28 的图像扁平化为 784 维。view 调整张量的形状，不改变其数据。-1 表示自动计算维度的大小，使总元素数量保持不变。这里 -1 会自动计算为 batch_size。(batch_size, 1（通道数）, 28, 28) $\Rightarrow$ (batch_size, 784)！！！！！！！

附：softmax()与log_softmax()

$\star$ 多分类任务最后一层

$\bullet$ log_softmax()：计算 softmax 后的对数，更具数值稳定性，常与 nll_loss负对数似然损失函数 一起使用。计算交叉熵损失时，使用 log_softmax() 更方便。交叉熵损失函数通常包括一个 log 操作，因此与 log_softmax() 结合使用可以避免重复计算对数。

$\bullet$ 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)

$\bullet$ log_softmax(二维张量为经过上一层后的数据，dim=)

输入张量，即模型的输出。通常是二维张量。第一维：batch size，第二维：类别数目（或者某个特征的维度）。

dim=1 表示在第一维（即类别维度）上进行 softmax 归一化操作。

在模型的前向传播过程中，当输入的特征向量经过 self.layer4 (20,10)后，输出是一个二维张量，其形状为 (batch_size, 10)：

$\bullet$ 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)

$\star$ torch.optim.SGD（随机梯度下降）

基本的优化算法，每次迭代时使用当前批次数据的梯度更新模型参数。计算相对简单，适合大规模模型。可以实现更精细的控制。易陷入局部最优点，特别是对于高度非凸的损失函数。需要手动调节学习率和学习率衰减策略。

$\star$ 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())
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

$\star$ for index, data in enumerate(train_loader): 迭代数据加载器 train_loader中的数据批次

enumerate: 内置函数：使用enumerate 遍历train_loader，在遍历迭代对象时，同时获取当前元素的索引和值。返回的结果是一个包含索引和数据的元组。

index 是当前批次的索引，从 0 开始递增。

data 是当前批次的数据，通常是一个包含输入数据和标签的元组 (inputs, labels)。

$\star$ input, target = data 是一种常见的解构赋值（也称为拆包），用于从 data 变量中提取输入和目标张量。通常数据和标签成对地存储在数据加载器中，这种方式可以将它们分开并传递给模型进行训练和评估。

$\star$ 模型保存：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 文件格式扩展名，表示这是一个序列化文件。

$\star$ 损失值的打印：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))

$\star$ for epoch in range(2):一个数据集用两遍。训练循环的迭代遍历次数。确保模型能充分学习数据的特征。使得模型逐步逼近最优解。

$\star$ 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

$\star$ with torch.no_grad():测试模型时，不需要计算梯度，使用 torch.no_grad() 上下文管理器，可以临时关闭自动求导功能（PyTorch中的张量默认具有自动求导功能，当你对张量进行操作时，PyTorch会自动构建一个计算图并保存梯度用于反向传播，从而实现自动求导），可节省内存并加快计算速度，不需要存储梯度信息。

----------

$\star$ torch.argmax(output) ：返回 output 张量中最大值的索引，即模型预测的类别。这里的output是十个值中的一个。

$\star$ 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()

$\star$ transform = transforms.ToTensor()这句别忘了不能省以及出现过类似的多次

$\star$ 调整图像大小常用transforms.resize() 或者 PIL 库的Image. resize() 方法。对PyTorch 的张量（Tensor），不能直接调用 image.resize() 改变大小，因为张量的形状是由其数据内容决定的，不是尺寸函数决定。

$\star$ image.resize((28, 28))将图像调整到 28x28 像素，与 MNIST 数据集的标准图像尺寸匹配。

$\star$ image = image.view(1, 1, 28, 28)，图像张量调整为适合输入到 CNN 模型中的形状。1 表示批量大小（batch size），即一次输入一张图片。1 表示通道数（channel），因为手写数字图像是灰度图像，所以通道数为 1。28, 28 表示图像的宽和高。

$\star$ probability, predict = torch.max(output.data, dim=1) #同前

$\star$ 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嘿

关注

58
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫