深度学习 Day12——P1实现mnist手写数字识别

mac air深度学习 Day1—— 第P1周:实现mnist手写数字识别题】 model.eval()是保证BN层能够用全部训练数据的均值和方差,即测试过程中要保证BN层的均值和方差不变。● transform (callable, optional ):这里的参数选择一个你想要的数据转化函数,直接完成数据转化(ToTensor 就是将输入的张量初始化为0到1之间,就是常见的归一化数据处理,不管是对于输入的数据是0-255的图像还是其他数据都具有很高的普适性)在model(test)之前,需要加上model.eval(),否则的话,有输入数据,即使不训练,它也会改变权值。 阅读详情


前言

本文将采用pytorch框架创建CNN网络,实现简单实现mnist手写数字识别。讲述实现代码与执行结果,并浅谈涉及知识点。
关键字:MNIST手写数字数据集介绍,Torch.NN简介,Pytorch】model.train() 和 model.eval() 原理与用法。

1 我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:
    torch == 1.9.1+cu111
    torchvision == 0.10.1+cu111
  • 显卡:NVIDIA GeForce RTX 4070

2 代码实现与执行结果

2.1 前期准备

2.1.1 引入库

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率
import torchvision
import numpy as np
from torchinfo import summary
import torch.nn.functional as F
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.1.2 设置GPU(如果设备上支持GPU就使用GPU,否则使用CPU)

"""前期准备-设置GPU-"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

输出

cuda

2.1.3 导入数据

'''前期工作-导入数据'''
train_ds = torchvision.datasets.MNIST('data', 
                                      train=True, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.MNIST('data', 
                                      train=False, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_ds, 
                                       batch_size=batch_size, 
                                       shuffle=True)

test_dl  = torch.utils.data.DataLoader(test_ds, 
                                       batch_size=batch_size)

2.1.4 查看数据

'''前期工作-查看数据'''                                       
# 取一个批次查看数据格式
# 数据的shape为:[batch_size, channel, height, weight]
# 其中batch_size为自己设定,channel,height和weight分别是图片的通道数,高度和宽度。
imgs, labels = next(iter(train_dl))  # 通过 iter(train_dl) 创建一个数据迭代器,然后使用 next(train_dl) 从训练数据加载一个批次的图像和对应的标签。
# images包含了一批图像,labels 包含了这些图像的类别标签。
print(imgs.shape)

输出

torch.Size([32, 1, 28, 28])

2.1.5.数据可视化

'''前期工作-数据可视化'''
# 指定图片大小,图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5))
for i, img in enumerate(imgs[:20]):
    # 维度缩减,去除所有维度为1的维度
    npimg = np.squeeze(img.numpy())
    # 将整个figure分成2行10列,绘制第i+1个子图。
    plt.subplot(2, 10, i + 1)
    plt.imshow(npimg, cmap=plt.cm.binary)  # 使用matlablib库cm子库中的binary颜色映射,讲图像渲染维黑白色
    plt.axis('off')  # 取消坐标轴显示
plt.show()  # 如果你使用的是Pycharm编译器,请加上这行代码

在这里插入图片描述

2.2 构建CNN网络模型

在这里插入图片描述

"""构建CNN网络"""
num_classes = 10  # 图片的类别数


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        # 特征提取网络
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(2)  # 设置池化层,池化核大小为2*2
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)  # 第二层卷积,卷积核大小为3*3
        self.pool2 = nn.MaxPool2d(2)

        # 分类网络
        self.fc1 = nn.Linear(1600, 64)
        self.fc2 = nn.Linear(64, num_classes)

    # 前向传播
    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2(x)))

        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)

        return x


# 将模型转移到GPU中(我们模型运行均在GPU中进行)
model = Model().to(device)
summary(model)

输出

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            320
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            18,496
├─MaxPool2d: 1-4                         --
├─Linear: 1-5                            102,464
├─Linear: 1-6                            650
=================================================================
Total params: 121,930
Trainable params: 121,930
Non-trainable params: 0
=================================================================

2.3 训练模型

2.3.1 训练模型

"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-2  # 学习率
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)  # 作用是定义优化器,用来训练时候优化模型参数;其中,SGD表示随机梯度下降,用于控制实际输出y与真实y之间的相差有多大

2.3.2 编写训练函数

"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小,一共60000张图片
    num_batches = len(dataloader)  # 批次数目,1875(60000/32)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 加载数据加载器,得到里面的 X(图片数据)和 y(真实标签)
        X, y = X.to(device), y.to(device) # 用于将数据存到显卡

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距,targets为真实值,计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()  # 反向传播,计算当前梯度
        optimizer.step()  # 根据梯度更新网络参数

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.3.3 编写测试函数

"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小,一共10000张图片
    num_batches = len(dataloader)  # 批次数目,313(10000/32=312.5,向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时,停止梯度更新,节省计算内存消耗
    with torch.no_grad(): # 测试时模型参数不用更新,所以 no_grad,整个模型参数正向推就ok,不反向更新参数
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

2.3.4 正式训练

"""训练模型--正式训练"""
epochs = 5
train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}')
    print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
print('Done')

输出

Epoch: 1, Train_acc:79.5%, Train_loss:0.709, Test_acc:92.7%,Test_loss:0.243
Epoch: 2, Train_acc:94.3%, Train_loss:0.188, Test_acc:96.2%,Test_loss:0.125
Epoch: 3, Train_acc:96.4%, Train_loss:0.121, Test_acc:97.3%,Test_loss:0.088
Epoch: 4, Train_acc:97.2%, Train_loss:0.093, Test_acc:97.6%,Test_loss:0.077
Epoch: 5, Train_acc:97.6%, Train_loss:0.078, Test_acc:98.0%,Test_loss:0.064
Done

2.4 结果可视化

"""训练模型--结果可视化"""
epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

3 知识点详解

3.1 MNIST手写数字数据集介绍

MNIST手写数字数据集来源于是美国国家标准与技术研究所,是著名的公开数据集之一。数据集中的数字图片是由250个不同职业的人纯手写绘制,数据集获取的网址为:http://yann.lecun.com/exdb/mnist/(下载后需解压)。我们一般会采用(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()这行代码直接调用,这样就比较简单MNIST手写数字数据集中包含了70000张图片,其中60000张为训练数据,10000为测试数据,70000张图片均是2828,如果我们把每一张图片中的像素转换为向量,则得到长度为2828=784的向量。因此我们可以把训练集看成是一个[60000,784]的张量,第一个维度表示图片的索引,第二个维度表示每张图片中的像素点。而图片里的每个像素点的值介于0-1之间。
在pytorch下可以直接调用torchvision.datasets里面的MNIST数据集(这是官方写好的数据集类)

train = torchvision.datasets.MNIST(root='./data/',train=True, transform= transforms.ToTensor())

作用
从 torchvision 中加载 MNIST 数据集的训练集
参数

  • root=‘./data’: 数据集将被下载并保存在当前工作目录下的 ‘data’ 子目录中
  • train=True: 加载训练集
  • download=True: 如果数据集不存在,则下载数据集
  • transform=transforms.ToTensor(): #接收PIL图片并返回转换后版本图片的转换函数,这里为将图像转换为 PyTorch 的 Tensor 格式
    返回值为一个元组(train_data,train_target)(这个类使用的时候也有坑,必须用train[i]索引才能使用 transform功能),一般是与torch.utils.data.DataLoader配合使用
dataloader = DataLoader(train, batch_size=50,shuffle=True, num_workers=4)
for step, (x, y) in enumerate(dataloader):
 b_x = x.shape
 b_y = y.shape
 print 'Step: ', step, '| train_data的维度' ,b_x,'| train_target的维度',b_y

作用
创建一个 DataLoader 对象,用于对数据进行批量加载和处理
参数

  • trainset: 要加载的数据集
  • batch_size=4: 每个批次包含的图像样本数量
  • shuffle=True: 打乱数据,以便在每个 epoch 中随机访问样本
  • num_workers=4:并行处理数

3.2 Torch.NN简介

torch.nn 是 PyTorch 中用于构建神经网络的模块。它提供了一组类和函数,用于定义、训练和评估神经网络模型。
torch.nn 模块的核心是 nn.Module 类,它是所有神经网络模型的基类。在Containers中通过继承 nn.Module 类,您可以创建自己的神经网络模型,并定义模型的结构和操作。
以下是 torch.nn 模块中常用的一些类和函数:

  • nn.Linear: 线性层,用于定义全连接层,可以起到特征提取器的作用,最后一层的全连接层也可以认为是输出层,传入参数为输入特征数和输出特征数(输入特征数由特征提取网络计算得到,如果不会计算可以直接运行网络,报错中会提示输入特征数的大小,下方网络中第一个全连接层的输入特征数为1600。
  • nn.Conv2d: 二维卷积层,用于处理图像数据。
  • nn.ReLU: ReLU 激活函数。
  • nn.Sigmoid: Sigmoid 激活函数。
  • nn.Dropout: Dropout 层,用于正则化和防止过拟合。
  • nn.CrossEntropyLoss: 交叉熵损失函数,通常用于多类别分类问题。
  • nn.MSELoss: 均方误差损失函数,通常用于回归问题。
  • nn.Sequential: 顺序容器,用于按顺序组合多个层,在初始化阶段就设定好网络结构,不需要在前向传播中重新写一遍。
    使用 torch.nn 模块,您可以创建自定义的神经网络模型,并使用 PyTorch 提供的优化器(如 torch.optim)和损失函数来训练和优化模型。

3.2.1nn.Module模块概述

nn.Module类的基本定义
在定义自已的网络的时候,需要继承nn.Module类,并重新实现构造函数__init__()和forward这两个方法。在构造函数__init__()中使用super(Model, self).init()来调用父类的构造函数,forward方法是必须要重写的,它是实现模型的功能,实现各个层之间的连接关系的核心。
1.一般把网络中具有可学习参数的层(如全连接层、卷积层)放在构造函数__init__()中。
2.一般把不具有可学习参数的层(如ReLU、dropout)可放在构造函数中,也可不放在构造函数中(在forward中使用nn.functional来调用)。
示例1:将具有可学习参数层和不具有可学习参数层均放在构造函数中

import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()   # 调用父类的构造函数
        self.con2v = nn.Conv2d(1, 3, 3, 1)
        self.relu = nn.ReLU()
        self.max_pooling = nn.MaxPool2d(2, 1)
    def forward(self, x):
        x = self.con2v(x)
        x = self.relu(x)
        x = self.max_pooling(x)
        return x
model = Model()
print(model)
'''  可看到输出的模型结构
Model(
  (con2v): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
  (relu): ReLU()
  (max_pooling): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
)
'''

示例2:把不具有可学习参数的层不放在构造函数中(在forward中使用nn.functional调用)

import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()   # 调用父类的构造函数
        self.con2v = nn.Conv2d(1, 3, 3, 1)
        self.max_pooling = nn.MaxPool2d(2, 1)
    def forward(self, x):
        x = self.con2v(x)
        x = F.relu(x)
        x = self.max_pooling(x)
        return x
model = Model()
print(model)
''' 可看到输出的模型结构
Model(
  (con2v): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
  (max_pooling): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
)
'''

由此可看出不具有可学习参数层没有放在构造函数里面,那么这些层就不会出现在model中。
也就是在构造函数__init__()中只是定义了模型的结构,而在forward方法中实现了模型中的所有层的连接。
3.只要在nn.Module中定义了forward函数,backward函数就会被自动实现(利用Autograd)。而且一般不是显式的调用forward(layer.forward), 而是layer(input), 会自执行forward()。

3.2.2 Sequential类的概述

nn.Sequential的定义:一个有顺序容器,神经网络模块将按照构造函数中传递的顺序添加到该容器中。此外,也可以传入一个有序的模块字典。

Sequenrial类实现了整数索引,每一个层是没有名称的,默认是以0、1、2…这样的index来命名,可以使用model[index]这样的方式获取一个层,并不能够通过名称(如model[“Conv2d”])来获取层。
示例如下:

import torch.nn as nn
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()   # 调用父类的构造函数
        self.model1= nn.Sequential(
            nn.Conv2d(1, 3, 3, 1),
            nn.ReLU(),
            nn.Conv2d(3, 9, 3, 1),
            nn.MaxPool2d(2, 1)
        )
    def forward(self, x):
        x = self.struct(x)
        return x
model = Model()
print(model)
print(model.model1[2])  # 通过索引获取第几个层

'''  输出结果
Model(
  (model1): Sequential(
    (0): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
    (1): ReLU()
    (2): Conv2d(3, 9, kernel_size=(3, 3), stride=(1, 1))
    (3): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
  )
)
Conv2d(3, 9, kernel_size=(3, 3), stride=(1, 1))
'''

Sequential的三种包装方式
示例如下:

import torch.nn as nn
from collections import OrderedDict
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()   # 调用父类的构造函数
        self.model1 = nn.Sequential(    # 方式一
            nn.Conv2d(1, 3, 3, 1),
            nn.ReLU()
        )
        self.model2 = nn.Sequential(   # 方式二
            OrderedDict([
                ('conv1', nn.Conv2d(1, 3, 3, 1)),
                ('relu1', nn.ReLU())
            ])
        )
        self.model3 = nn.Sequential()  # 方式三
        self.model3.add_module('conv1', nn.Conv2d(1, 3, 3, 1)),
        self.model3.add_module('relu1', nn.ReLU())
    def forward(self, x):
        x = self.model1(x)
        x = self.model2(x)
        x = self.model3(x)
        return x
model = Model()
print(model)

'''  输出结果
Model(
  (model1): Sequential(
    (0): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
    (1): ReLU()
  )
  (model2): Sequential(
    (conv1): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
    (relu1): ReLU()
  )
  (model3): Sequential(
    (conv1): Conv2d(1, 3, kernel_size=(3, 3), stride=(1, 1))
    (relu1): ReLU()
  )
)
'''

参考链接:
nn.Module模块概述
神经网络的基本框架的搭建-nn.Module

3.3【Pytorch】model.train() 和 model.eval() 原理与用法

3.3.1 两种模式

pytorch可以给我们提供两种方式来切换训练和评估(推断)的模式,分别是:model.train() 和 model.eval()。
一般用法是:在训练开始之前写上 model.trian() ,在测试时写上 model.eval() 。

3.3.2功能

1. model.train()
在使用 pytorch 构建神经网络的时候,训练过程中会在程序上方添加一句model.train(),作用是 启用 batch normalization 和 dropout 。
如果模型中有BN层(Batch Normalization)和 Dropout ,需要在 训练时 添加 model.train()。
model.train() 是保证 BN 层能够用到 每一批数据 的均值和方差。对于 Dropout,model.train() 是 随机取一部分 网络连接来训练更新参数。

2. model.eval()
model.eval()的作用是 不启用 Batch Normalization 和 Dropout。
如果模型中有 BN 层(Batch Normalization)和 Dropout,在 测试时 添加 model.eval()。
model.eval() 是保证 BN 层能够用 全部训练数据 的均值和方差,即测试过程中要保证 BN 层的均值和方差不变。对于 Dropout,model.eval() 是利用到了 所有 网络连接,即不进行随机舍弃神经元。

为什么测试时要用 model.eval() ?
训练完 train 样本后,生成的模型 model 要用来测试样本了。在 model(test) 之前,需要加上model.eval(),否则的话,有输入数据,即使不训练,它也会改变权值。这是 model 中含有 BN 层和 Dropout 所带来的的性质。

eval() 时,pytorch 会自动把 BN 和 DropOut 固定住,不会取平均,而是用训练好的值。
不然的话,一旦 test 的 batch_size 过小,很容易就会被 BN 层导致生成图片颜色失真极大。
eval() 在非训练的时候是需要加的,没有这句代码,一些网络层的值会发生变动,不会固定,你神经网络每一次生成的结果也是不固定的,生成质量可能好也可能不好。

也就是说,测试过程中使用model.eval(),这时神经网络会 沿用 batch normalization 的值,而并不使用 dropout。

3.3.3 总结与对比

如果模型中有 BN 层(Batch Normalization)和 Dropout,需要在训练时添加 model.train(),在测试时添加 model.eval()。
其中 model.train() 是保证 BN 层用每一批数据的均值和方差,而 model.eval() 是保证 BN 用全部训练数据的均值和方差;
而对于 Dropout,model.train() 是随机取一部分网络连接来训练更新参数,而 model.eval() 是利用到了所有网络连接。

参考链接:【Pytorch】model.train() 和 model.eval() 原理与用法

总结

通过本文的学习,了解了pytorch网络模型如何创建、训练与测试。

nature子刊:MCNN基于电池故障诊断的模型约束的深度学习方法 本研究提出了一种基于模型约束神经网络(MCNN)的锂离子电池在线故障诊断方法,整合物理模型与深度学习,有效解决了随机工况下传统方法诊断精度低、依赖故障样本等问题。通过统计修正电池包模型和双向LSTM网络,实现了电池状态的高精度预测(平均RMSE 3.9%),并设计模型耦合自动编码器提取可解释特征。在包含18.2百万条真实车辆数据的验证中,该方法故障检测TPR在FPR=0.1时达85%,较基准方法提升超46.5%,且能提前30分钟预警内部短路等故障。研究还展示了算法在跨电池包结构迁移中的优越性,为工业应用提供 阅读详情

相关推荐

从GAN生成失败案例出发:为什么你的AI画不准位置?CoordConv保姆级解决方案

本文深入探讨了GAN生成图像时位置偏移问题的根源,并提供了CoordConv的保姆级解决方案。通过分析传统CNN在空间坐标建模上的缺陷,详细介绍了CoordConv的原理、实现步骤及在StyleGAN2等模型中的实战应用,显著提升了医学图像生成等任务的定位精度。

pp12345的博客 206

深度学习 Day24——使用Pytorch环境实现mnist手写数字识别

365天深度学习训练营 [第十四周]——本期博客我们将首先学习如何使用Anaconda下载Pytorch,然后使用我们的Pytorch环境搭建一个简单的CNN网络实现mnist手写数字的识别。

北天的博客 7112

AI Agent在智能投研中的实战:多智能体信息整合与策略生成

那么,什么是AI Agent?简单来说,AI Agent是一种能够感知环境、做出决策并采取行动的自主系统。自主性:能够在没有人类直接干预的情况下运行,对自己的行为和内部状态有一定的控制权。反应性:能够感知环境的变化,并及时做出反应。主动性:不仅能够对环境变化做出反应,还能够主动地设定目标并采取行动实现这些目标。社会性:能够与其他Agent(包括人类和人工智能)进行交互、协作和竞争。它们可以全天候不间断地监控和处理海量信息,大大提升信息处理能力;

AI大模型应用之禅 194

深度学习day04-MNIST手写数字识别与模型使用

手写数字识别原理(不强相关)、具体代码实现(算上import和空行一共50行代码不到)、训练出来的模型怎么使用

引用原创内容标明出处即可 2万+

分布式存储系统关于GDPR条例中的数据清除原则

文章目录前言HDFS存储系统数据的完全删除基于加解密的输入输出流的数据保护方案 前言 关于GDPR是什么,可能许多同学之前并不太了解,至少笔者在之前也是不清楚的。GDPR全称为通用数据保护条例,General Data Protection Regulation。它是一项来自欧盟的关于计算机数据保护相关的条约,旨在规范系统如何收集,管控用户私人数据的种种行为。但是当前的一些存储系统并没有完全符合...

走在前往架构师的路上 3629

第五节 Amesim《直动型溢流阀HCD建模》HCD5 学习资料

利用HCD原则创建直动型溢流阀的界面。这可能包括图形化表示直动型溢流阀的工作原理、操作方式和调节方法。这样的界面应当直观且易于理解,使用户能够轻松了解阀门的功能和使用方法。

m0_58052642的博客 1330

深度学习 Day 12——利用卷神经网络实现MNIST手写数字的识别

365天深度学习训练营 [第二周]——继续学习利用卷神经网络(CNN)实现MNIST手写数字的识别。

北天的博客 1268

Python 爬虫教程:金融数据定向抓取(银行 + 投资网站数据结构化提取)

在当今数字化时代,金融数据的获取和分析对于投资者、分析师以及金融机构来说至关重要。Python 爬虫技术可以帮助我们高效地从各种网站上抓取金融数据,从而为投资决策、风险评估和市场分析提供支持。本文将详细介绍如何使用 Python 爬虫技术来定向抓取银行和投资网站的数据,并将其结构化提取,以便进一步分析和使用。

u014481728的博客 885

深度学习(鱼书)day04--手写数字识别项目实战

鱼书的相关源代码下载:点击链接:http://www.ituring.com.cn/book/1921点击“随书下载”第三项就是源代码:解压后,在pycharm(或其它IDE)中打开此文件夹查看或运行即可。(红框内是本人自建的文件)

weixin_66162442的博客 2661

ubuntu系统禁止/开启内核自动更新

内核自动更新会导致驱动和内核版本不对应,导致驱动无法使用,所以需要禁止自动更新内核。本文介绍ubuntu系统禁止/开启内核更新的方法。

m0_50105717的博客 5290

YOLOv8改进策略【YOLO和Mamba】| 2024 VM-UNet,高效的特征提取模块VSS block 二次创新提高精度

VM-UNet模型设计的出发点是解决现有CNN-based和模型在医学图像分割中的局限性,利用(SSMs)的优势,提出一种更有效的医学图像分割模型。具体来说,CNN-based模型在捕捉长距离信息方面存在不足,而模型由于自注意力机制的二次复杂度导致计算负担较重。SSMs模型如Mamba不仅在建模长距离依赖方面表现出色,还具有线性计算复杂度,这为VM-UNet的设计提供了理论基础。

Limiiiing的博客 631

深度学习day1|用pytorch框架实现手写数字识别

本文介绍了如何使用PyTorch进行手写数字识别,构建了LeNet-5模型并进行训练,展示了训练过程和结果可视化。

weixin_53754431的博客 1725

面向精准医疗的多模态影像融合:实现前列腺MRI与大病理切片的三维配准与空间重建研究

亲爱的同学,当你能完整实现“前列腺MRI与大病理组织学图像的3D配准及体素重建”,你会发现医学影像交叉领域的毕设课题充满挑战与乐趣。我们将从临床需求出发,拆解3D配准与体素重建的核心技术,带你从原理到代码实现完整流程,让你的毕设不仅能顺利完成,更能体现临床应用价值。,让MRI和病理图像在同一空间对齐,能实现“术前影像-术后病理”的精准关联,为前列腺癌的精准诊疗、预后评估提供关键依据——这一课题既有技术挑战性,又有临床意义,是毕设的优质选择。(如NCC、Dice、配准时间),用数据证明方法的优越性。

m0_71589036的博客 4718

深度学习 Day1——T1实现mnist手写数字识别

MNIST手写数字数据集介绍,神经网络程序调用顺序,CNN网络模型结构,CNN网络--卷积层,池化层,全连接层,激活函数,以及预测结果为何出现负数

LittleRuby的博客 500

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

【深度学习】【PaddlePaddle】DAY 4 - 图像分类问题:手写数字识别案例(一)

深度学习课程 DAY 3 - 图像分类问题:手写数字识别案例Chapter 2 图像分类问题1 手写数字识别任务(1)数字识别概述(2)MNIST数据集2 构建手写数字识别任务的神经网络模型1)数据处理 Chapter 2 图像分类问题 1 手写数字识别任务 (1)数字识别概述 数字识别是计算机从纸质文档、照片或其他来源接收、理解并识别可读的数字的能力,目前比较受关注的是手写数字识别。手写数字识别是一个典型的图像分类问题,已经被广泛应用于汇款单号识别、手写邮政编码识别等领域,大大缩短了业务处理时间,提升了工

Venistar的博客 2118

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

深度学习实战(一)——识别手写数字

这里的实战是根据Neural Networks and Deep Learning的前两章整理出来的。用了它提供的数据集以及一些代码。然后自己修改了他的一些代码,使得更加容易理解。 一、任务及数据 就是自己写一个神经网络来实现对于MNIST数据集的手写体分类任务。这里使用随机梯度下降算法和MNIST训练数据。首先获取MNIST 数据。如果你是一个 git用户,那么你能够通过克隆这本书的代码仓库...

qq_37764129的博客 3464

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

【神经网络与深度学习day10-基于torch使用Lenet实现手写数字识别】

神经网络与深度学习day10:Lenet实现MNIST

ABU366的博客 3278

深度学习项目练习(算法方向练习)- CNN 实现 mnist 手写数字识别 - Day 1【超适合小白!每一步的详解和注释+每一步图解!】

本文介绍了使用PyTorch实现MNIST手写数字识别的CNN模型构建过程。首先配置了Python 3.9.7环境和PyTorch 2.2.2(CPU版),通过设置随机种子确保实验可重复性。接着完成MNIST数据集的加载和预处理,包括归一化和标准化操作。然后构建了一个进阶CNN模型,包含3层卷积、批量归一化、ReLU激活和池化层,以及全连接分类器。最后验证了模型结构正确性,输入输出形状符合预期。该项目完整展示了从环境配置到模型构建的深度学习流程,适用于初学者理解CNN在图像分类任务中的应用。

2401_87569451的博客 1197

Week T1:MNIST手写数字识别(CNN)

🍨 本文为🔗365天深度学习训练营内部限免文章(版权归K同学啊所有)🔗深度学习100例-卷积神经网络(CNN)实现mnist手写数字识别 | 第1天K同学啊 | 接辅导、项目定制K同学的学习圈子。

qq_40724911的博客 472

深度学习DAY1——实现mnist手写数字识别

灰度图像是单一采样色的,它的采样色素值从0到255之间,即黑白之间,0为最黑,255为最白,介于之间的就称为灰色。所有图像都是28×28的。为了与接下来的卷积神经网络输入数据格式相匹配,将训练集和测试集的图像数据从原来的三维形状。对于灰度图像,通道数为1,而对于彩色图像,通道数为3(分别表示红、绿、蓝通道)。把数据都化到(0,1)的区间内;与标准化不同,标准化是将数据按照比例缩放到一个较小的区间。从知乎上找到的各层次结构的作用介绍,看着很清晰。在积神经网络中,数据的格式通常是一个维张量,即。

qq_58687413的博客 159

深度学习入门day4--手写数字识别初探

手写数字识别

basai123的博客 579

python 手写数字识别 封装GUI,手写板获取鼠标写字轨迹信息

python 手写数字识别知识不用多说,本文只要讲解在手写数字识别开发过程中所遇到的坑。 1、训练模型 通过keras训练模型,并保存该模型 import numpy from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense from keras....

July_whj 8469

每天30分钟轻松掌握Pytorch:Day 3 手写数字识别实践

每天30分钟轻松掌握Pytorch:Day 3 手写数字识别实践!如果文章对你有帮助,还请给个三连好评,感谢感谢!

weixin_40780178的博客 1236

深度学习 Day1—— 第P1周:实现mnist手写数字识别

函数会遍历模型的所有参数,通过内置方法截断反向传播的梯度流,再将每个参数的梯度值设为0,即上一次的梯度记录被清空。)是通过autograd包来实现的,autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。,否则的话,有输入数据,即使不训练,它也会改变权值。保证BN层能够用全部训练数据的均值和方差,即测试过程中要保证BN层的均值和方差不变。step()函数的作用是执行一次优化步骤,通过梯度下降法来更新参数的值。使用dataloader加载数据,并设置好基本的batch_size。

Leebit_1207的博客 232

DAY1-深度学习100例-卷积神经网络(CNN)实现mnist手写数字识别

Mnist数据集分为两部分,分别含有60000张训练图片和10000张测试图片。每一张图片包含28*28个像素。Mnist数据集把代表一张图片的二维数据转换成一个向量,长度为28 * 28=784。因此在Mnist的训练数据集中mnist.train.images是一个形状为[60000, 784]的张量,第一个维度数字用来索引图片,第二个维度数字用来索引每张图片中的像素点,图片里的某个像素的强度值介于0-1之间。...

weixin_44336912的博客 767

DAY2 深度学习之卷积神经网络实现手写数字识别(MINIST)的收获

DAY2 深度学习之卷积神经网络实现手写数字识别(MINIST)的收获 导入相关包的理解 import matplotlib.pyplot as plt用来处理图像,from torch.utils.data import DataLoader用来下载数据集。 超参数的理解 用一个super_param这样一个字典来存储超参数,其中batch_size代表一次训练所选取的样本数,device代表是用CPU还是使用CUDA(GPU),epoch是训练的次数,lr代表学习率。然后采取EasyDict,即sup

qq_41034212的博客 578
上一篇: 深度学习 Day11——T11优化器对比实验
下一篇: 深度学习 Day13——P2彩色图片分类
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值