深度学习(12)--Mnist分类任务

GodFishhh2024-02-03 7:01

一.Mnist分类任务流程详解

1.1.引入数据集

Mnist数据集是官方的数据集，比较特殊，可以直接通过**%matplotlib inline**自动下载，博主此处已经完成下载，从本地文件中引入数据集。

设置数据路径

python 复制代码 
from pathlib import Path

# 设置数据路径
# PATH = Path("data/minst")
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

# PATH.mkdir(parents=True, exist_ok=True)  # 父目录不存在时创建父目录

'''
parents：如果父目录不存在，是否创建父目录。
exist_ok：只有在目录不存在时创建目录，目录已存在时不会抛出异常。
'''

读取数据

python 复制代码 
import pickle
import gzip

# 读取数据
'''
gzip.open的作用是解压gzip文件
with gzip.open(PATH.as_posix(), "rb") as f:
    ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")
'''
# rb表示以二进制格式打开一个文件用于只读
# 打开PATH路径的文件用以接下来的操作
# 保存数据的文件类型为pickle，所以用pickle.load打开文件，文件此处设置的别名为f
with open(PATH.as_posix(), "rb") as f:
    ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

'''
as.posix()的作用：
#返回使用斜杠（/）分割路径的字符串
#将所有连续的正斜杠、反斜杠，统一修改为单个正斜杠
#相对路径 './' 替换为空，'../' 则保持不变。
'''

测试引入数据集是否成功

python 复制代码 
from matplotlib import pyplot
import numpy as np

# 测试数据集是否导入成功
pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray")
print(x_train.shape)

1.2.数据类型转换

数据需要转换成tensor类型才能参与后续建模训练

python 复制代码 
import torch

# 通过map映射，将x_train等数据全都转为torch.tensor类型。tensor类型才能参与后续建模训练
x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)

测试数据类型是否转换成功

python 复制代码 
n, c = x_train.shape
x_train, x_train.shape, y_train.min(), y_train.max()
print(x_train, y_train)
print(x_train.shape)
print(y_train.min(), y_train.max())

数据均为tensor类型，转换成功

1.3.设置损失函数

python 复制代码 
import torch.nn.functional as F

# 设置损失函数，此处使用的损失函数为交叉熵
loss_func = F.cross_entropy

测试损失函数

手动设置初始权重和偏置值进行测试，真实情况下系统会自动帮我们初始化

python 复制代码 
bs = 64
xb = x_train[0:bs]  # a mini-batch from x ，xb是x_train中0~64项的数
yb = y_train[0:bs]

# 实际操作中模型会自动定义权重参数，不用我们手动设置
# 因为输入数据是784x1个像素点，而最后得到的是十个类别，所以权重矩阵的大小为784x10。
weights = torch.randn([784, 10], dtype = torch.float,  requires_grad = True) 
bs = 64
# bias矩阵的大小取决于最后的类别数量，此处的bias矩阵为10x1
bias = torch.zeros(10, requires_grad=True)

def model(xb):
    return xb.mm(weights) + bias  # .mm()是矩阵相乘 .mul()则是对应位相乘

# 损失函数是用来度量模型的预测值f(x)与真实值Y的差异程度的运算函数，此处model(xb)得到的是经过权重计算的预测值，yb是真实值。给损失函数传入的参数即为预测值和真实值。
print(loss_func(model(xb), yb))

1.4.神经网络构造

此处所选用的是传统神经网络完成Minist分类任务

python 复制代码 
from torch import nn

# 创建一个模型类，注意一定要继承于nn.Module(取决于你要创建的网络类型)
class Mnist_NN(nn.Module):
    def __init__(self):
        # 调用父类的构造函数
        super().__init__()
        # 创建两个隐层 由784->128->256->10
        self.hidden1 = nn.Linear(784, 128)
        self.hidden2 = nn.Linear(128, 256)
        # 创建输出层，由256->10，即最后输出十个类别
        self.out  = nn.Linear(256, 10)
        self.dropout = nn.Dropout(0.5)

    # torch框架需要自己定义前向传播，反向传播由框架自己实现
    # 传入的x是一个batch x 特征值
    def forward(self, x):
        # x经过第一个隐层
        x = F.relu(self.hidden1(x))
        # x经过dropout层
        x = self.dropout(x)
        # x经过第二个隐藏
        x = F.relu(self.hidden2(x))
        # x经过dropout层
        x = self.dropout(x)
        # x经过输出层
        x = self.out(x)
        return x

测试构造的神经网络

python 复制代码 
net = Mnist_NN()
print(net)

查看网络中构建好的权重和偏置项

python 复制代码 
for name, parameter in net.named_parameters():
    print(name, parameter,parameter.size())
复制代码

1.5.使用TensorDataset和DataLoader简化数据

python 复制代码 
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader

# TensorDataset获取数据，再由DataLoader打包数据传给GPU(包的大小位batch_size)
# 训练集一般打乱顺序，验证集不打乱顺序
train_ds = TensorDataset(x_train, y_train)
train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)

valid_ds = TensorDataset(x_valid, y_valid)
valid_dl = DataLoader(valid_ds, batch_size=bs * 2)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )

1.6.模型训练

优化器设置

python 复制代码 
from torch import optim
def get_model():
    model = Mnist_NN() # 使用先前创建的类构造一个网络
    return model, optim.SGD(model.parameters(), lr=0.001) 
    # 返回值为模型和优化器
 # 优化器的设置，optim.SGD()，参数分别为：要优化的参数、学习率

def loss_batch(model, loss_func, xb, yb, opt=None):
    # 计算损失，参数为预测值和真实值
    loss = loss_func(model.forward(xb), yb)  # 预测值由定义的前向传播过程计算处

    # 如果存在优化器
    if opt is not None: 
        loss.backward()  # 反向传播，算出更新的权重参数
        opt.step()  # 执行backward()计算出的权重参数的更新
        opt.zero_grad()  # torch会进行迭代的累加，通过zero_grad()将之前的梯度清空(不同的迭代之间应当是没有关系的)

    return loss.item(), len(xb)

常用优化器：

  • 随机梯度下降(SGD, stochastic gradient descent)
  • SGDM(加入了一阶动量)
  • AdaGrad（加入了二阶动量）
  • RMSProp
  • Adam

模型训练

python 复制代码 
import numpy as np

#epoch和batch的关系，
#eg：有10000个数据，batch=100，则一个1epoch需要训练100个batch(1一个epoch就是训练整个数据一次)
# 定义训练函数，传入的参数分别为：迭代的次数、模型、损失函数、优化器、训练集、验证集
def fit(steps, model, loss_func, opt, train_dl, valid_dl):
    for step in range(steps):
        # 训练模式：
        model.train()  
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)  # 得到由loss_batch更新的权重值
        # 验证模式：
        model.eval()   
        with torch.no_grad():  # 没有梯度，即不更新权重参数
            # zip将两个矩阵配对，例如两个一维矩阵配对成一个二维矩阵，下述情况中即为一个losses对应一个nums -> [(losses,nums)]。zip*是解包操作，即将二维矩阵又拆分成一维矩阵，并返回拆分得到的一维矩阵。
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)  # 计算平均损失：对应的损失值和样本数相乘的总和 / 总样本数
        print('当前step:'+str(step), '验证集损失：'+str(val_loss))

二.完整代码

python 复制代码 
from pathlib import Path
import pickle
import gzip

from matplotlib import pyplot
import numpy as np

import torch

import torch.nn.functional as F

from torch import nn

from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader

from torch import optim

import numpy as np


# 设置数据路径
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist.pkl"

# PATH.mkdir(parents=True, exist_ok=True)

'''
parents：如果父目录不存在，是否创建父目录。
exist_ok：只有在目录不存在时创建目录，目录已存在时不会抛出异常。
'''

# 读取数据
'''
gzip.open的作用是解压gzip文件
with gzip.open(PATH.as_posix(), "rb") as f:
    ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")
'''
# rb表示以二进制格式打开一个文件用于只读
# 打开PATH路径的文件用以接下来的操作
# 保存数据的文件类型为pickle，所以用pickle.load打开文件，文件此处设置的别名为f
with open(PATH.as_posix(), "rb") as f:
    ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

'''
as.posix()的作用：
#返回使用斜杠（/）分割路径的字符串
#将所有连续的正斜杠、反斜杠，统一修改为单个正斜杠
#相对路径 './' 替换为空，'../' 则保持不变。
'''

'''
# 测试数据集是否导入成功
pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray")
print(x_train.shape)
'''

# 数据类型转换为torch

# 通过map映射，将x_train等数据全都转为torch.tensor类型。tensor类型才能参与后续建模训练
x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)



# 测试数据类型是否转换成功
'''
n, c = x_train.shape
x_train, x_train.shape, y_train.min(), y_train.max()
print(x_train, y_train)
print(x_train.shape)
print(y_train.min(), y_train.max())
'''

# 设置损失函数
loss_func = F.cross_entropy


bs = 64
xb = x_train[0:bs]  # a mini-batch from x ，xb是x_train中0~64项的数
yb = y_train[0:bs]

''' 
# 手动初始化进行测试

# 实际操作中模型会自动定义权重参数，不用我们手动设置
# 因为输入数据是784x1个像素点，而最后得到的是十个类别，所以权重矩阵的大小为784x10。
weights = torch.randn([784, 10], dtype = torch.float,  requires_grad = True)
bs = 64
# bias矩阵的大小取决于最后的类别数量，此处的bias矩阵为10x1
bias = torch.zeros(10, requires_grad=True)

def model(xb):
    return xb.mm(weights) + bias  # .mm()是矩阵相乘 .mul()则是对应位相乘

# 损失函数是用来度量模型的预测值f(x)与真实值Y的差异程度的运算函数，此处model(xb)得到的是经过权重计算的预测值，yb是真实值。给损失函数传入的参数即为预测值和真实值。
print(loss_func(model(xb), yb))
'''

# 创建一个模型类，注意一定要继承于nn.Module(取决于你要创建的网络类型)
class Mnist_NN(nn.Module):
    def __init__(self):
        # 调用父类的构造函数
        super().__init__()
        # 创建两个隐层 由784->128->256->10
        self.hidden1 = nn.Linear(784, 128)
        self.hidden2 = nn.Linear(128, 256)
        # 创建输出层，由256->10，即最后输出十个类别
        self.out = nn.Linear(256, 10)
        self.dropout = nn.Dropout(0.5)

    # torch框架需要自己定义前向传播，反向传播由框架自己实现
    # 传入的x是一个batch x 特征值
    def forward(self, x):
        # x经过第一个隐层
        x = F.relu(self.hidden1(x))
        # x经过dropout层
        x = self.dropout(x)
        # x经过第二个隐藏
        x = F.relu(self.hidden2(x))
        # x经过dropout层
        x = self.dropout(x)
        # x经过输出层
        x = self.out(x)
        return x


'''
# 测试构造的网络模型
net = Mnist_NN()
print(net)

打印权重和偏置项
for name, parameter in net.named_parameters():
    print(name, parameter,parameter.size())
'''

# TensorDataset获取数据，再由DataLoader打包数据传给GPU
# 训练集一般打乱顺序，验证集不打乱顺序
train_ds = TensorDataset(x_train, y_train)
train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True)

valid_ds = TensorDataset(x_valid, y_valid)
valid_dl = DataLoader(valid_ds, batch_size=bs * 2)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )


# 优化器设置
def get_model():
    model = Mnist_NN()
    return model, optim.SGD(model.parameters(), lr=0.001)
    # 优化器的设置，optim.SGD()，参数分别为：要优化的参数、学习率

def loss_batch(model, loss_func, xb, yb, opt=None):
    # 计算损失，参数为预测值和真实值
    loss = loss_func(model.forward(xb), yb)  # 预测值由定义的前向传播过程计算处

    # 如果存在优化器
    if opt is not None:
        loss.backward()  # 反向传播，算出更新的权重参数
        opt.step()  # 执行backward()计算出的权重参数的更新
        opt.zero_grad()  # torch会进行迭代的累加，通过zero_grad()将之前的梯度清空(不同的迭代之间应当是没有关系的)

    return loss.item(), len(xb)

# 模型训练
# epoch和batch的关系，
# eg：有10000个数据，batch=100，则一个1epoch需要训练100个batch(1一个epoch就是训练整个数据一次)
# 定义训练函数，传入的参数分别为：迭代的次数、模型、损失函数、优化器、训练集、验证集
def fit(steps, model, loss_func, opt, train_dl, valid_dl):
    for step in range(steps):
        # 训练模式：
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)  # 得到由loss_batch更新的权重值
        # 验证模式：
        model.eval()
        with torch.no_grad():  # 没有梯度，即不更新权重参数
            # zip将两个矩阵配对，例如两个一维矩阵配对成一个二维矩阵，下述情况中即为一个losses对应一个nums -> [(losses,nums)]。zip*是解包操作，即将二维矩阵又拆分成一维矩阵，并返回拆分得到的一维矩阵。
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)  # 计算平均损失：对应的损失值和样本数相乘的总和 / 总样本数
        print('当前step:'+str(step), '验证集损失：'+str(val_loss))

# 输出
train_dl, valid_dl = get_data(train_ds, valid_ds, bs)
model, opt = get_model()
fit(25, model, loss_func, opt, train_dl, valid_dl)

# 准确率的计算
correct = 0
total = 0
for xb,yb in valid_dl:
    outputs = model(xb)
    _, predicted = torch.max(outputs.data,1)  # 返回最大的值和对应的列索引(列索引在此处就是对应的类别)    (, 0)则返回行索引
    total += yb.size(0)  # yb的样本数
    correct += (predicted == yb).sum().item( ) # .sum()返回验证正确了的样本数,item()从tensor数据类型中取值，方便后续的画图等(tensor数据类型不好画图)

    print('Accuracy of the network on the 10000 test image: %d %%' %(100*correct/total))

三.输出结果

相关推荐
深度学习实战训练营28 分钟前
基于CNN-RNN的影像报告生成
人工智能·深度学习
孙同学要努力7 小时前
全连接神经网络案例——手写数字识别
人工智能·深度学习·神经网络
丕羽9 小时前
【Pytorch】基本语法
人工智能·pytorch·python
sniper_fandc9 小时前
深度学习基础—循环神经网络的梯度消失与解决
人工智能·rnn·深度学习
weixin_5182850510 小时前
深度学习笔记10-多分类
人工智能·笔记·深度学习
阿_旭11 小时前
基于YOLO11/v10/v8/v5深度学习的维修工具检测识别系统设计与实现【python源码+Pyqt5界面+数据集+训练代码】
人工智能·python·深度学习·qt·ai
YRr YRr11 小时前
深度学习：Cross-attention详解
人工智能·深度学习
阿_旭11 小时前
基于YOLO11/v10/v8/v5深度学习的煤矿传送带异物检测系统设计与实现【python源码+Pyqt5界面+数据集+训练代码】
人工智能·python·深度学习·目标检测·yolo11
算家云12 小时前
如何在算家云搭建Aatrox-Bert-VITS2（音频生成)
人工智能·深度学习·aigc·模型搭建·音频生成·算家云
小言从不摸鱼13 小时前
【NLP自然语言处理】深入解析Encoder与Decoder模块：结构、作用与深度学习应用
人工智能·深度学习·神经网络·机器学习·自然语言处理·transformer·1024程序员节
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play