使用Pytorch实现手写数字识别(Mnist数据集)

最新推荐文章于 2024-08-04 16:44:00 发布
最新推荐文章于 2024-08-04 16:44:00 发布
阅读量5k 收藏 63
点赞数 6
分类专栏： pytorch 文章标签： Mnist 手写数字识别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiecheng1995/article/details/112004417
版权

目标

  1. 知道如何使用Pytorch完成神经网络的构建
  2. 知道Pytorch中激活函数的使用方法
  3. 知道Pytorch中torchvision.transforms中常见图形处理函数的使用
  4. 知道如何训练模型和如何评估模型

1. 思路和流程分析

流程：

  1. 准备数据，这些需要准备DataLoader
  2. 构建模型，这里可以使用torch构造一个深层的神经网络
  3. 模型的训练
  4. 模型的保存，保存模型，后续持续使用
  5. 模型的评估，使用测试集，观察模型的好坏

2. 准备训练集和测试集

准备数据集的方法前面已经讲过，但是通过前面的内容可知，调用MNIST返回的结果中图形数据是一个Image对象，需要对其进行处理

在这里插入图片描述
为了进行数据的处理，接下来学习torchvision.transfroms的方法

2.1 torchvision.transforms的图形数据处理方法

2.1.1 torchvision.transforms.ToTensor

把一个取值范围是[0,255]的PIL.Image或者shape为 [H,W,C] 的 numpy.ndarray，转换成形状为 [C,H,W]，取值范围是[0, 1.0]的torch.FloatTensor

其中(H,W,C)意思为(高，宽，通道数)，黑白图片的通道数只有1，其中每个像素点的取值为[0,255]，彩色图片的通道数为(R,G,B)，每个通道的每个像素点的取值为[0,255]，三个通道的颜色相互叠加，形成了各种颜色

示例如下：

from torchvision import transforms
import numpy as np
 
data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
print(img.shape)

img_tensor = transforms.ToTensor()(img) # 转换成tensor
print(img_tensor)
print(img_tensor.shape)

输出如下：

shape:(2, 2, 3)

img_tensor:tensor([[[215, 171],
                 [ 34,  12]],
 
                [[229,  87],
                 [ 15, 237]],
 
                [[ 10,  55],
                 [ 72, 204]]], dtype=torch.int32)
                 
new shape:torch.Size([3, 2, 2])

img_tensor.transpose(0,2)：交换第0轴（第一个2）和第2轴（最后那个3）
img_tensor.permute(2,0,1)：改变3个轴的位置（2轴，0轴，1轴）——相当于transforms.ToTensor()(img)操作

注意：

  • transforms.ToTensor对象中有__call__方法，所以可以对其示例能够传入数据获取结果

2.1.2 torchvision.transforms.Normalize(mean, std)

给定均值：mean，shape和图片的通道数相同(指的是每个通道的均值)，方差：std，和图片的通道数相同(指的是每个通道的方差)，将会把Tensor规范化处理。

即：Normalized_image=(image-mean)/std。

例如：

from torchvision import transforms
import numpy as np
import torchvision
 
data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
img = transforms.ToTensor()(img) # 转换成tensor
print(img)
print("*"*100)
 
norm_img = transforms.Normalize((10,10,10), (1,1,1))(img) #进行规范化处理。均值和标准差跟通道数相同。通道数为3就写3个数
 
print(norm_img)

输出如下：

tensor([[[177, 223],
         [ 71, 182]],
 
        [[153, 120],
         [173,  33]],
 
        [[162, 233],
         [194,  73]]], dtype=torch.int32)
***************************************************************************************
tensor([[[167, 213],
         [ 61, 172]],
 
        [[143, 110],
         [163,  23]],
 
        [[152, 223],
         [184,  63]]], dtype=torch.int32)

注意：在sklearn中，默认上式中的std和mean为数据每列的std和mean，sklearn会在标准化之前算出每一列的std和mean。

但是在api：Normalize中并没有帮我们计算，所以我们需要手动计算

2.1.3 torchvision.transforms.Compose(transforms)

将多个transform组合起来使用。

例如

transforms.Compose([
     torchvision.transforms.ToTensor(),  # 先转化为Tensor
     torchvision.transforms.Normalize(mean,std)  # 在进行正则化
 ])

2.2 准备MNIST数据集的Dataset和DataLoader

准备训练集(train=True)

import torchvision

#准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
#因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
dataset = torchvision.datasets.MNIST('/data', train=True, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#准备数据迭代器                          
train_dataloader = 
torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

准备测试集(train=False)

import torchvision

#准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
#因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
dataset = torchvision.datasets.MNIST('/data', train=False, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#准备数据迭代器                          
train_dataloader = 
torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

3. 构建模型

补充：全连接层：当前一层的神经元和前一层的神经元相互链接，其核心操作就是 y = w x ​ y = wx​ y=wx​，即矩阵的乘法，实现对前一层的数据的变换

模型的构建使用了一个四层的神经网络，其中包括两个全连接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果

那么在这个模型中有两个地方需要注意：

  1. 激活函数如何使用
  2. 每一层数据的形状
  3. 模型的损失函数

3.1 激活函数的使用

前面介绍了激活函数的作用，常用的激活函数为Relu激活函数，他的使用非常简单

Relu激活函数由import torch.nn.functional as F提供，F.relu(x)即可对x进行处理

例如：

In [30]: b
Out[30]: tensor([-2, -1,  0,  1,  2])

In [31]: import torch.nn.functional as F

In [32]: F.relu(b)
Out[32]: tensor([0, 0, 0, 1, 2])

3.2 模型中数据的形状（【添加形状变化图形】）

  1. 原始输入数据为的形状:[batch_size,1,28,28]
  2. 进行形状的修改：[batch_size, 28*28]，(全连接层是在进行矩阵的乘法操作)
  3. 第一个全连接层的输出形状：[batch_size, 28]，这里的28是个人设定的，你也可以设置为别的，比如128等等，表示经过第一个全连接层后的输出特征数量
  4. 激活函数不会修改数据的形状
  5. 第二个全连接层的输出形状：[batch_size,10]，因为手写数字有10个类别

构建模型的代码如下：

import torch
from torch import nn
import torch.nn.functional as F
 
class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)  #定义Linear的输入和输出的形状
        self.fc2 = nn.Linear(28,10)  #定义Linear的输入和输出的形状
 
    def forward(self,x):
        x = x.view(-1,28*28*1)  #对数据形状变形，-1表示该位置根据后面的形状自动调整
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]

可以发现：pytorch在构建模型的时候形状上并不会考虑batch_size

3.3 模型的损失函数

首先，我们需要明确，当前我们手写字体识别的问题是一个多分类的问题，所谓多分类对比的是之前学习的2分类

回顾之前的课程，我们在逻辑回归中，我们使用sigmoid进行计算对数似然损失，来定义我们的2分类的损失。

  • 在2分类中我们有正类和负类，正类的概率为 P ( x ) = 1 1 + e − x = e x 1 + e x P(x) = \frac{1}{1+e^{-x}} = \frac{e^x}{1+e^x} P(x)=1+e−x1​=1+exex​,那么负类的概率为 1 − P ( x ) ​ 1-P(x)​ 1−P(x)​
  • 将这个结果进行计算对数似然损失 − ∑ y l o g ( P ( x ) ) ​ -\sum y log(P(x))​ −∑ylog(P(x))​就可以得到最终的损失

那么在多分类的过程中我们应该怎么做呢？

  • 多分类和2分类中唯一的区别是我们不能够再使用sigmoid函数来计算当前样本属于某个类别的概率，而应该使用softmax函数。
  • softmax和sigmoid的区别在于我们需要去计算样本属于每个类别的概率，需要计算多次，而sigmoid只需要计算一次

softmax的公式如下：

在这里插入图片描述
例如下图：
在这里插入图片描述
假如softmax之前的输出结果是2.3, 4.1, 5.6,那么经过softmax之后的结果是多少呢？

在这里插入图片描述
对于这个softmax输出的结果，是在[0,1]区间，我们可以把它当做概率P

和前面2分类的损失一样，多分类的损失只需要再把这个结果进行对数似然损失的计算即可

即：
在这里插入图片描述
最后，会计算每个样本的损失，即上式的平均值

我们把softmax概率传入对数似然损失得到的损失函数称为交叉熵损失

在pytorch中有两种方法实现交叉熵损失（用哪种都可以）

第一种：

criterion = nn.CrossEntropyLoss()
loss = criterion(output,target)

第二种：

#1. 对输出值计算softmax和取对数
output = F.log_softmax(x,dim=-1)
#2. 使用torch中带权损失
loss = F.nll_loss(output,target)

带权损失定义为： l n = − ∑ w i x i l_n = -\sum w_{i} x_{i} ln​=−∑wi​xi​，其实就是把 l o g ( P ) log(P) log(P)作为 x i x_i xi​，把真实值Y作为权重

4. 模型的训练

训练的流程：

  1. 实例化模型，设置模型为训练模式
  2. 实例化优化器类，实例化损失函数
  3. 获取，遍历dataloader
  4. 梯度置为0
  5. 进行向前计算
  6. 计算损失
  7. 反向传播
  8. 更新参数
mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
def train(epoch):
    mode = True
    mnist_net.train(mode=mode) #模型设置为训练模型
 
    train_dataloader = get_dataloader(train=mode) #获取训练数据集
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad() #梯度置为0
        output = mnist_net(data) #进行向前计算
        loss = F.nll_loss(output,target) #带权损失
        loss.backward()  #进行反向传播，计算梯度
        optimizer.step() #参数更新
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

5. 模型的保存和加载

5.1 模型的保存

torch.save(mnist_net.state_dict(),"model/mnist_net.pt") #保存模型参数
torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pt') #保存优化器参数

5.2 模型的加载

mnist_net.load_state_dict(torch.load("model/mnist_net.pt"))
optimizer.load_state_dict(torch.load("results/mnist_optimizer.pt"))

6. 模型的评估

评估的过程和训练的过程相似，但是：

  • 1.不需要计算梯度
  • 2.需要收集损失和准确率，用来计算平均损失和平均准确率
  • 3.损失的计算和训练时候损失的计算方法相同
  • 4.准确率的计算：
    • 模型的输出为[batch_size,10]的形状
    • 其中最大值的位置就是其预测的目标值（预测值进行过sotfmax后为概率，sotfmax中分母都是相同的，分子越大，概率越大）
    • 最大值的位置获取的方法可以使用torch.max,返回最大值和最大值的位置
    • 返回最大值的位置后，和真实值（[batch_size]）进行对比，相同表示预测成功
def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()  #设置模型为评估模式
    test_dataloader = get_dataloader(train=False) #获取评估数据集
    with torch.no_grad(): #不计算其梯度
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()  #预测准备样本数累加
    test_loss /= len(test_dataloader.dataset) #计算平均损失
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))

7. 完整代码如下

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torchvision
 
train_batch_size = 64
test_batch_size = 1000
img_size = 28
 
def get_dataloader(train=True):
    assert isinstance(train,bool),"train 必须是bool类型"
 
    #准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
    #因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
    dataset = torchvision.datasets.MNIST('/data', train=train, download=True,
                                         transform=torchvision.transforms.Compose([
                                         torchvision.transforms.ToTensor(),
                                         torchvision.transforms.Normalize((0.1307,), (0.3081,)),]))
    #准备数据迭代器
    batch_size = train_batch_size if train else test_batch_size
    dataloader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
    return dataloader
 
class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)
        self.fc2 = nn.Linear(28,10)
 
    def forward(self,x):
        x = x.view(-1,28*28*1)
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]
        # return x
        return F.log_softmax(x,dim=-1)
 
mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
# criterion = nn.NLLLoss()
# criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_count_list = []
 
def train(epoch):
    mode = True
    mnist_net.train(mode=mode)
    train_dataloader = get_dataloader(train=mode)
    print(len(train_dataloader.dataset))
    print(len(train_dataloader))
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad()
        output = mnist_net(data)
        loss = F.nll_loss(output,target) #对数似然损失
        loss.backward()
        optimizer.step()
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))
 
            train_loss_list.append(loss.item())
            train_count_list.append(idx*train_batch_size+(epoch-1)*len(train_dataloader))
            torch.save(mnist_net.state_dict(),"model/mnist_net.pkl")
            torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pkl')
 
 
def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()
    test_dataloader = get_dataloader(train=False)
    with torch.no_grad():
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()
    test_loss /= len(test_dataloader.dataset)
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))
 
 
if __name__ == '__main__':
 
    test()  
    for i in range(5): #模型训练5轮
        train(i)
        test()

视频参考（23~27）：https://www.bilibili.com/video/BV1fA411e7ad?p=23

GitHub：https://github.com/xcalan/Handwritting-numeral-recognition

Gitee：https://gitee.com/xcalan/Handwritting-numeral-recognition

酷酷的橙007
关注
专栏目录
1057：简单计算器（C C++）
ネロ・クラウディウス
09-25 1800
【题目描述】 一个最简单的计算器，支持+, -, *, / 四种运算。仅需考虑输入输出为整数的情况，数据和运算结果不会超过int表示的范围。 1. 如果出现除数为0的情况，则输出：Divided by zero! 2. 2. 如果出现无效的操作符(即不为 +, -, *, / 之一），则输出：Invalid operator! 输入 输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,*,/）。 输出 只有一行，一个整数，为运算结果。然而： 1.如果出现除数为
TensorFlow2.x 常用知识
MyArrow的专栏
02-18 1496
1. 学习入门资源 官方教程 实验环境 Google云盘 2. 比赛 天池大赛
使用pytorch实现数字识别器
最新发布
weixin_57342469的博客
08-04 937
使用pytorch实现数字识别器
dropout层加在哪里
sun13047140038的博客
11-19 3742
在这两种情况下，Dropout层的参数是指定要关闭的神经元的概率，通常在0到1之间。它在神经网络中的位置可以有一些不同的选择，但通常是在全连接层之间或卷积层之间添加的。在全连接层之间：通常，您可以在全连接层（密集层）之后添加Dropout层。在卷积层之间：如果您正在构建卷积神经网络（CNN），则通常将Dropout层添加到卷积层之间。model.add(Dropout(0.5)) # 在全连接层后添加Dropout。model.add(Dropout(0.25)) # 在卷积层后添加Dropout。
深度学习框架Tensorflow学习与应用
学习使我快乐
09-13 324
Tensorflow学习（一） 深度学习框架Tensorflow学习与应用 通过视频学习Tensorflow的一些知识点，可能不是很系统，跟着敲了一点代码，又根据自己的理解做了一些笔记。主要是学习Tensorflow的一些用法。
Dropout 层是否有效
毛财胜的专栏
04-09 7683
之前做分类的时候，Dropout 层一般加在全连接层 防止过拟合 提升模型泛化能力。而很少见到卷积层后接Drop out （原因主要是 卷积参数少，不易过拟合），今天找了些博客，特此记录。 首先是一篇外文博客（他的一系列写的都很好）：Dropout Regularization For Neural Networks 也有中文翻译版的：基于Keras/Python的深度学习模型Dropout正...
详解PyTorch手写数字识别(MNIST数据集)
09-18
**PyTorch手写数字识别(MNIST数据集)** MNIST手写数字识别是深度学习初学者常常接触的一个经典任务，它可以帮助我们理解神经网络的基本构造和工作原理。在这个项目中，我们将使用PyTorch框架来实现这个任务。...
基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar
05-06
1、资源内容：基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、更多仿真源码和数据集...
pytorch实现手写数字识别 - MNIST数据集（全连接神经网络）.html
05-23
关于MNIST数据集 关于二分类与多分类 关于神经网络处理过程 softmax函数 关于MNIST数据集的处理举例 代码流程 关于transforms.ToTensor 关于transforms.Normalize 9.代码中transform的对应关系 关于x.view 设计模型 ...
深度学习 pytorch手写数字识别 MNIST数据集 解析+详细注释
11-01
本项目将介绍如何使用PyTorch实现手写数字识别，特别针对MNIST数据集进行解析，并提供了详细注释的源码。 MNIST数据集是深度学习入门的经典案例，由Yann LeCun等人维护，包含60,000个训练样本和10,000个测试样本的...
dropout层加在哪里_【深度学习】：一文入门Dropout层
weixin_39765100的博客
12-19 7683
Dropout层在神经网络层当中是用来干嘛的呢？它是一种可以用于减少神经网络过拟合的结构，那么它具体是怎么实现的呢？假设下图是我们用来训练的原始神经网络：一共有四个输入x_i，一个输出y。Dropout则是在每一个batch的训练当中随机减掉一些神经元，而作为编程者，我们可以设定每一层dropout(将神经元去除的的多少)的概率，在设定之后，就可以得到第一个batch进行训练的结果：从上图我们可以...
用PyTorch进行手写数字识别
Mr_不负此舟的博客
03-07 3145
目录数据准备网络模型完整实现 数据准备 torch.utils.data.Datasets是PyTorch用来表示数据集的类，它是用PyTorch进行手写数字识别的关键。 下面是加载mnist数据集并对其可视化的代码 from torchvision import datasets from torchvision.datasets import MNIST from matplotlib import pyplot as plt import numpy as np mnist = datasets.M
pytorch手写数字识别
weixin_59961223的博客
03-01 258
pytorch入门实战，手写数字识别代码，MINST数据集
TensorFlow2.x 使用之快速入门
weixin_44704538的博客
05-20 1250
文章目录1. 数据类型1.1 数值类型1.2 字符串类型1.3 布尔类型2. 数值精度2.1 读取精度2.2 类型转换3. 待优化张量4. 创建张量4.1 从数组、列表对象创建4.2 创建全0或全1张量4.3 创建自定义数值张量4.4 创建已知分布的张量4.5 创建序列5. 索引与切片5.1 索引5.2 切片6. 维度变换6.1 改变视图6.2 增删维度6.3 交换维度6.4 复制数据7. Broadcasting8. 数学运算8.1 加减乘除运算8.2 乘方运算8.3 指数和对数运算8.4 矩阵相乘运算
基于Pytorch的CNN手写数字识别
qq_46454669的博客
10-19 811
其中super().__init__()允许我们调用父类（nn.Module）的方法，对于卷积操作nn.Conv2d（输入通道数，输出通道数，卷积核尺寸，步长，padding大小）参数如此，因为输入为灰度图，则对于第一个卷积的输入通道数等于1，最后线性层会输出一个包含10个数据的变量，分别代表10个数字（类别）的概率。
【深度学习】卷积神经网络中Dropout、BatchNorm的位置选择
热门推荐
无极阁
04-28 1万+
卷积神经网络的设计自然要考虑到各层之间的顺序。这种“考虑”既有原理性的解释也有经验方面的原因。本文主要介绍一些层常见的位置选择，并对其原因进行分析，从中提取共性有利于其他模型的设计。
dropout层_机器学习：在TensorFlow（Keras）中了解和实现Dropout
weixin_39875516的博客
11-25 1076
在本文中，我们将探讨Dropout的概念，并了解如何使用TensorFlow和Keras在神经网络中实现该技术。了解Dropout神经网络在其输入和输出层之间具有隐藏层，这些隐藏层中嵌入了神经元，神经元内的权重以及神经元之间的连接使得神经网络系统能够模拟学习过程。简单神经网络一般的观点是，神经网络体系结构中的神经元和层越多，其表示能力就越强。表示能力的提高意味着神经网络可以拟合更复杂的函数，并可以...
dropout层加在哪里_CNN中dropout层的理解
weixin_36184940的博客
12-29 9187
dropout是在训练神经网络模型时，样本数据过少，防止过拟合而采用的trick。那它是怎么做到防止过拟合的呢？首先，想象我们现在只训练一个特定的网络，当迭代次数增多的时候，可能出现网络对训练集拟合的很好(在训练集上loss很小)，但是对验证集的拟合程度很差的情况。所以，我们有了这样的想法：可不可以让每次跌代随机的去更新网络参数(weights)，引入这样的随机性就可以增加网络generalize...
PyTorch 使用RNN实现MNIST手写字体识别
Coding
01-24 3997
此处使用普通的RNN 推荐一个RNN入门资料：https://zhuanlan.zhihu.com/p/28054589 28*28的图片，每个输入序列长度（seq_len）为28，每个输入的元素维度(input_size)为28，将一张图片的分为28列，为长度28的序列，序列中每个元素为28个元素（即每一列的像素）。 注意，如果batch_first设置为1，则输出维度out：   bat...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值