用pytorch实现神经网络

已于 2022-11-01 10:58:19 修改
阅读量1w 收藏 94
点赞数 11
分类专栏： python AI-CV 文章标签： pytorch 神经网络 深度学习
于 2022-08-15 18:31:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42295969/article/details/126352278
版权
python 同时被 2 个专栏收录
23 篇文章 0 订阅
订阅专栏
AI-CV
15 篇文章 3 订阅
订阅专栏

章节设置：
一、实现自带数据并自定义神经网络进行训练
二、使用自带的模型进行训练以及测试
三、用自己定义神经网络

全局设定，指定了设备

事实证明，即使是1650这样的显卡也会比cpu运行得快很多，只要运行的时候显存够就行，在使用的时候有两种方式(注意——还有其他指定显卡的方式，比如cuda()，只是这种更通用，更熟悉而已)：

  1. model.to(device)
  2. tensor变量.to(device)
# 如果显卡可用，则用显卡进行训练
device = "cuda" if torch.cuda.is_available() else "cpu"
# device='cpu'
print(f"Using {device} device")

全局设定GPU的设备使用

一、实现官方数据集并自定义神经网络进行训练

放在这个示例的理解：获得dataset数据–>利用加载器进行数据加载–>设计神经网络的结构–>定义优化器以及损失函数–>遍历数据进行梯度下降迭代求解最佳的梯度值–>用模型进行预测得到预测值
通用理解：数据加载–>设计网络结构–>遍历数据进行梯度下降求解到损失值的最小值或者指定次数–>保存对应的梯度参数或者直接计算test情况
通过pytorch设计网络结构，需要完成以下几点：

  1. 定义网络结构，初始化函数init
  2. 定义网络节点连接方式forward函数

1. 获得dataset数据

通过从内置的数据集中获取数据，和之前的方式一样，只不过内置的给你写好了torchvision.datasets.mnist.MNIST.py，以下解释相关变量的定义

解释torchvision.datasets.mnist.MNIST.init.data相关定义以及是怎么来的

test_data = torchvision.datasets.MNIST('./mnist',train=False)
# test_x= Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)[:2000]/255.
# 压缩纬度，将第一个纬度给压没了（可以理解为x的纬度）
test_x = torch.unsqueeze(test_data.data, dim=1).type(torch.FloatTensor)[:2000] / 255. #取前2000个数据

对于这里面的test_data.data的理解，torchvision.datasets.mnist.MNIST.__init__.data可以看他们的调用关系，它其实是通过MNIST类的__init__进行对象的建立，所以获得的是最终的对象，如下所示：

对象=torchvision.datasets.mnist.MNIST.__init__()
对象具有data属性，所以就可以调用对象.data
综合起来就是: torchvision.datasets.mnist.MNIST.__init__.data

在python的类只要函数里面调用了self.属性=相关定义赋值，那么之后python的类就具有这样的功能。

之所以要进行维度的拓展就是因为cnn的输入是1*28*28，所以数据需要转换为batch_size*1*28*28，而扩展纬度就是通过unsqueeze,而有时候需要进行维度的统一就是通过unsqueeze以及expand，所以下面对unsqueeze以及expand的使用方法进行探究

  • unsqueeze可以增加一个纬度，但是维度的siz只是1而已，而expand就可以将数据进行复制，将数据变为n
import torch
# 获得一开始的初始化数值：tensor([[a1,a2,a3]])
nn1=torch.rand(1,3)
print(nn1)
# unsqueeze是解压的意思，在第i个维度上进行扩展，将其扩展为tensor([[[a1,a2,a3]]])
nn1=nn1.unsqueeze(0)
print("*"*100)
print(nn1)
#利用expand对数据进行扩展
nn1=nn1.expand(1,3,3)
print("*"*100)
print(nn1)

扩展维度输出的结果

2. 利用加载器进行数据加载

分为训练数据以及测试，由于训练数据需要分批次以及打乱操作等。所以加载方式会有所不同，或者可以可以测试数据的加载更加简单粗暴一些：

  1. 训练集数据的加载：通过dataset加载数据集–>将数据集加载进加载器中（加载中可以设置一批次迭代的次数还有是否打乱）
  2. 测试集数据的加载：可以直接加载数据以及对应的目标值就行
# 1. 训练数据的加载
train_data=torchvision.datasets.MNIST(
    root='./mnist',
    train=True,
    transform=torchvision.transforms.ToTensor(),#从下载数据改变数据形式 #(0,1)   (0,255)
    download=DOWNLOAD_MNIST
)
train_loader=Data.DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True,num_workers=0) 

# 2. 测试数据的加载
#test不用像train一样分批次加载，同时也不用需要打乱，所以直接获得相关数据就行
test_data = torchvision.datasets.MNIST('./mnist',train=False)
# 压缩纬度，将第一个纬度给压没了（可以理解为x的纬度）
test_x = torch.unsqueeze(test_data.data, dim=1).type(torch.FloatTensor)[:2000] / 255. #取前2000个数据 转换为batch_size*1*28*28
test_y=test_data.targets[:2000]

3. 设计神经网络的结构

将神经网络中核心函数init()以及forward()函数实现就行

  1. init()是实现网络中有哪些层的；
  2. forward()是实现网络中不同连接的层的连接关系的；
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(#(1*28*28) #这里的1表示通道
                in_channels=1,
                out_channels=16,
                kernel_size=5,
                stride=1,
                padding=2, #如果 stride=1，padding=(kernel_size-1)/2=(5-1)/2
            ),# -->(16,28*28)
            nn.ReLU(),# -->(16,28*28)
            nn.MaxPool2d(kernel_size=2),# -->(16,14*14)
        )
        self.conv2=nn.Sequential(# (16,14*14)
            nn.Conv2d(16,32,5,1,2),#加工32层-->(32 14*14)
            nn.ReLU(),#-->(32 14*14)
            nn.MaxPool2d(2),#-->(32 7*7)
        )
        self.out=nn.Linear(32*7*7,10) #把前面的纬度32*7*7变成10

    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)  #(batch, 32 ,7,7)
        x=x.view(x.size(0),-1)  #(batch,32*7*7)
        output=self.out(x)
        return output

4. 定义优化器以及损失函数

optimizer = torch.optim.Adam(cnn.parameters(),lr=LR) #Adam是梯度下降的一种方法，将神经网络的参数以及传播率传进去
print(cnn.parameters())
loss_func = nn.CrossEntropyLoss()  #损失函数的定义

5. 遍历数据进行梯度下降

梯度下降+每到50次进行相关信息的输出或者一些处理

梯度下降
  1. 确定函数中优化器以及损失函数都已经设置好了
  2. 损失函数定义以及调用loss = loss_func(output, y)
  3. 优化器的置零：optimizer.zero_grad()
  4. 反向传播：loss.backward()
  5. 梯度迭代更新：optimizer.step()
批量输出相关信息或者批量处理数据

批量处理数据，也就是epoch=50，这里没有设置相关的变量而是用if step % 50 == 0:#表示已经进行了50的倍数了进行判断了，并且这里只做了相关的输出，并没有其他的操作（比如有时候可以对方差做一个汇总使得信息的整体性更强）

for epoch in range(EPOCH):
    for step, (x, y) in enumerate(train_loader):
        # 50*10  最后输出是分类的概率大小
        output = cnn(x)  # 得到网络中的输出数据
        loss = loss_func(output, y)  # 计算每一个网络的损失值
        optimizer.zero_grad()  # 在下一次求导之前将保留的grad清空
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()  # 应用求导到优化器上去

        if step % 50 == 0:#表示已经进行了50的倍数了
            test_output = cnn(test_x)
            # 在分类问题中，通常需要使用max()函数对softmax函数的输出值进行操作，求出预测值索引，然后与标签进行比对，计算准确率。其中1表示纬度
            # 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引。我们需要的是第二个的索引，本来是tensor的格式，这里需要化为numpy格式
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            # size()考虑到可能大小也是有纬度的，所以取的是第一个纬度
            # 这里的loss.data.numpy()和accuracy都是一纬的,如果是数组就直接把数据给输出了，这里也是可以的
            accuracy = sum(pred_y == test_y.data.numpy()) / test_y.size(0)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)

6. 用模型进行预测得到预测值

torch.max的使用见：https://blog.csdn.net/weixin_42295969/article/details/126352240?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22126352240%22%2C%22source%22%3A%22weixin_42295969%22%7D

# 从测试数据中计算10个预测,[:10]表示列表中第一项到第10项
test_output = cnn(test_x[:10])
# 这里为什么是max从而获得预测值
pred_y = torch.max(test_output, 1)[1].data.numpy() #返回的是最大值的索引,最大的概率值
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

代码：
链接：https://pan.baidu.com/s/1m6GE2Qkx6YZEYUcCnHn0ow?pwd=cu0s
提取码：cu0s

二、使用自带的模型进行训练以及测试

备注：与《一》使用相同的数据，代码在代码
与前面的对比（括号内是这个进行的改动）：1、获得dataset数据–>2、利用加载器进行数据加载–>3、设计神经网络的结构（直接导入已有的神经网络结构）–>4、定义优化器以及损失函数–>5、遍历数据进行梯度下降求解–>6、用模型进行预测得到预测值
注意：核心关注3，这是与前面不同的地方，并且增加了6预测的对比，如果对预测感兴趣，可以参考6(文中已高亮标记)

1-2 获得dataset数据–>利用加载器进行数据加载

与之前的一样进行加载数据

3. 神经网络的设计

可以直接导入自带的神经网络，这里以导入ResNet网络为例：

'''
    随着模型的加深，需要训练的模型参数量增加，相同的训练次数下模型训练准确率起来得更慢
'''

# model = alexnet(pretrained=False, num_classes=5).to(device) # 29.3%

'''        VGG系列    '''
# model = vgg11(pretrained=False, num_classes=5).to(device)   #  23.1%
# model = vgg13(pretrained=False, num_classes=5).to(device)   # 30.0%
# model = vgg16(pretrained=False, num_classes=5).to(device)


'''        ResNet系列    '''
# model = resnet18(pretrained=False, num_classes=5).to(device)    # 43.6%
# model = resnet34(pretrained=False, num_classes=5).to(device)
# model = resnet50(pretrained= False, num_classes=5).to(device)
model = resnet101(pretrained=False, num_classes=5).to(device)   #  26.2%
# model = resnet152(pretrained=False, num_classes=5).to(device)

示例说明

from torchvision.models import resnet18, resnet34,resnet50, resnet101, resnet152    # ResNet系列
model = resnet101(pretrained=False, num_classes=5).to(device)   #  26.2%
print(model)

模型输出结果

4、定义优化器以及损失函数

与前面一样的定义方法，先定义后调用

5、遍历数据进行梯度下降求解

迭代进行训练以及测试，其中训练的函数train里就保存了进行梯度下降求解的方法

包含梯度下降求解法的train

这里就将所有的数据训练了一轮就行,复杂的就会涉及到epoch以及batch_size的概念

  • 当一个完整的数据集通过了神经网络一次并且返回了一次，这个过程称为一个 epoch。
  • 在不能将数据一次性通过神经网络的时候，就需要将数据集分成几个 batch，所以下面的batch仅仅只是表示批次。
# 定义训练函数，需要
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    # 从数据加载器中读取batch（一次读取多少张，即批次数），X(图片数据)，y（图片真实标签）。
    for batch, (X, y) in enumerate(dataloader):
        # 将数据存到显卡
        X, y = X.to(device), y.to(device)

        # 得到预测的结果pred
        pred = model(X)

        # 计算预测的误差
        # print(pred,y)
        loss = loss_fn(pred, y)

        # 反向传播，更新模型参数
        optimizer.zero_grad() #梯度清零
        loss.backward() #反向传播
        optimizer.step() #更新参数

        # 每训练10次，输出一次当前信息
        if batch % 10 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

6、用模型进行预测得到预测值

设置为测试模型并设置不计算梯度，进行测试数据集的加载，判断预测值与实际标签是否一致，统一正确信息个数

设置为测试模型并设置不计算梯度

# 将模型转为验证模式
model.eval()
# 测试时模型参数不用更新，所以no_gard()
with torch.no_grad():
    # 加载数据加载器，得到里面的X（图片数据）和y(真实标签）
    for X, y in dataloader:
        加载数据
        pred = model(X)#进行预测
        # 预测值pred和真实值y的对比
        test_loss += loss_fn(pred, y).item()
        # 统计预测正确的个数
        correct += (pred.argmax(1) == y).type(torch.float).sum().item()#返回相应维度的最大值的索引
test_loss /= size
correct /= size
print(f"correct = {correct}, Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

7. 保存好训练好的模型

torch.save(model.state_dict(), "model_resnet101.pth")
print("Saved PyTorch Model Success!")

pth文件保存
代码：https://gitee.com/sxh_and_ll/AI-CV/tree/master/proj/%E4%BD%BF%E7%94%A8pytorch%E8%87%AA%E5%B8%A6%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83%E4%BB%A5%E5%8F%8A%E6%B5%8B%E8%AF%95

三、使用自己定义神经网络

使用自己定义的神经网络仅仅只是要写神经网络结构就是，只需要将模型继承nn.moudle类，另外实现init以及forward方法就行

徽先生
关注
  • 11
    点赞
  • 踩
  • 94
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
pytorch从零开始搭建神经网络
sinat_38007523的博客
11-11 4522
pytorch教程之nn.Sequential类详解——使用Sequential类来自定义顺序连接模型_LoveMIss-Y的博客-CSDN博客_sequential类pytorch教程之nn.Module类详解——使用Module类来自定义模型_LoveMIss-Y的博客-CSDN博客_torch.nn.module对应Sequential的三种包装方式，Module有三种写法。
【全网最详细】使用PyTorch实现循环神经网络
m0_61789994的博客
02-23 3214
循环神经网络（RNN）是一种用于序列数据的神经网络，常用于语言建模、翻译和音乐生成等任务。RNN是基于前一个时间步的输入和当前时间步的状态来预测下一个时间步的输出。这使得RNN在处理连续数据时非常有效，因为它可以利用上一个时间步的信息来更新其状态并生成新的输出。RNN模型的核心是“循环”结构。在传统的神经网络中，每个输入都是独立地处理的，而在RNN中，每个输入都与前一个时间步的输出相关联。在每个时间步，RNN将当前输入和前一个时间步的输出传递到一个称为“隐藏状态”的向量中。
物理知情神经网络（PINN）的简易PyTorch实现：打破传统解方程的方式
最新发布
gitblog_00037的博客
06-05 986
物理知情神经网络（PINN）的简易PyTorch实现：打破传统解方程的方式 项目地址:https://gitcode.com/nanditadoloi/PINN 在深度学习的浪潮中，物理知情神经网络（Physics-Informed Neural Networks, 简称PINNs）作为一种革命性的方法脱颖而出，它将物理定律与神经网络的力量相结合，开启了解决复杂科学问题的新纪元。今天，我们要向您推...
Pytorch深度学习之神经网络入门详解
qq_43649937的博客
05-29 2639
python
神经网络相关知识回顾（PyTorch篇）
weixin_43421371的博客
04-14 1084
一、常见概念 1、Batch（批量） （1）如果是模型训练方法，batch指将所有数据处理完以后一次性更新权重或参数的估计； （2）如果是模型训练中的数据，batch是一次输入供模型计算用的数据量。 基于批量的模型训练步骤： a) 初始化参数 b) 重复以下步骤：处理所有数据，更新参数 与其对应的是递增算法，步骤如下： a) 初始化参数 b) 重复以下步骤：处理一个或者一组数据点，更新参数 （BP算法中，“处理”的具体操作是计算损失函数的梯度变化曲线。对于批量算法——计算平均或者总体损失函数的梯度变化曲线；
十分钟掌握Pytorch搭建神经网络的流程
热门推荐
微鉴道长的博客
03-11 2万+
最近发现身边的一些初学者朋友捧着各种pytorch指南一边看一边敲代码，到最后反而变成了打字员。 敲完代码一运行，出来结果和书上一对比，哦，是书上的结果，就翻到下一章。半天就能把一本书都打完，但是合上书好像什么都不记得。有的甚至看了两三遍，都搭不出一个简单的网络来，这种学习方式很不可取。如果你刚好是这种情况，这篇文章应该能给你一些帮助。如果你已经是进阶的水平了，就直接关掉页面就好了。 pyto...
如何用PyTorch实现递归神经网络？
02-25
这些模型大多数将语言视为单调的单词或字符序列，并使用一种称为循环神经网络（recurrentneuralnetwork/RNN）的模型来处理该序列。但是许多语言学家认为语言最好被理解为具有树形结构的层次化词组，一种被称为递归...
PyTorch | 从NumPy到PyTorch实现神经网络
01-06
用NumPy实现两层神经网络 一个全连接ReLU神经网络，一个隐藏层，没有bias。用来从x预测y，使用Square Loss。 这一实现完全使用NumPy来计算前向神经网络，loss，和反向传播算法。 N—样本数据的大小 DinD_{in}Din​...
pytorch实现前馈神经网络实验（torch实现）
10-31
在PyTorch中实现前馈神经网络（Feedforward Neural Network，FNN）是深度学习的基础操作，本实验将深入探讨如何使用PyTorch库来构建和训练这样的模型。前馈神经网络是一种简单的神经网络结构，其中信息从输入层单向...
Pytorch实现神经网络的分类方式
09-18
今天小编就为大家分享一篇Pytorch实现神经网络的分类方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
pytorch 自动构建任意层的深度神经网络(DNN)
夜晓岚的博客
06-28 4077
根据可变参数自动构建深度神经网络
PyTorch上搭建简单神经网络实现回归和分类的示例
09-20
本篇文章主要介绍了PyTorch上搭建简单神经网络实现回归和分类的示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
用Pytorch构建第一个神经网络模型（附案例实战）
zxb_1222的博客
03-14 1万+
PyTorch是一个基于python的科学计算包，主要针对两类人群：作为NumPy的替代品，可以利用GPU的性能进行计算作为一个高灵活性、速度快的深度学习平台在PyTorch中搭建神经网络并使用真实的天气信息预测明天是否会下雨。预处理 CSV 文件并将数据转换为张量使用 PyTorch 构建神经网络模型使用损失函数和优化器来训练模型评估模型并了解分类不平衡的危害在开始构建神经网络之前，首先了解一下几个重要概念。
Pytorch:手把手教你搭建简单的全连接网络
qq_43397591的博客
10-13 8839
利用pytorch搭建简单全连接网络的步骤，适合初学者快速上手
PyTorch深度学习笔记之五（使用神经网络拟合数据）
FinixLei的专栏 (https://github.com/FinixLei)
11-30 4654
本文首先介绍了神经网络和神经元的基本概念，然后构建了一个3层的神经网络以解决温度计问题。
pytorch 神经网络
weixin_45360119的博客
02-09 825
pytorch深度学习 RNN循环神经网络pytorch RNN 后面的神经网络会基于前面神经网络的贡献 可以接受更广泛的时间序列结构输入 LSTM RNN long short-term memory（长短期记忆） 普通rnn会出现最初始的信息被忽略，在反向传播的时候减小最开始时候的信息。 而造成梯度消失，也叫做梯度弥散 也有可能造成一开始的梯度改变之后无穷大，称为梯度爆炸 因此，普通rnn无法解决轴点记忆的问题 lstm rnn中多了输入，输出，忘记控制器 根据输入输出程度的重要性，加入循环神经网络中
用PyTorch搭建卷积神经网络
juhanishen的博客
03-13 2万+
用PyTorch搭建卷积神经网络 本篇文章是一篇基础向的PyTorch教程，适合有一定的机器学习，深度学习和神经网络理论基础，接触过卷积神经网络，缺没有用过PyTorch搭建神经网络的同学。本文会分成以下几个部分： 基础卷积知识 PyTorch基础教程 用Pytorch搭建CNN 优化CNN模型 0. 基础图像卷积知识 这部分参考MIT的卷积图像课程，讲的非常清楚。 图像卷积是处理图像的一种方式。首先一个图像是用 M乘N 个像素来储存的，也是一个 M乘N 的矩阵。而卷积的过程就是将一个卷积核（convo
pytorch 搭建自己的卷积神经网络CNN
xiexu911的博客
07-16 8729
import torch import torchvision import torch.nn as nn import torch.nn.functional as F import matplotlib.pyplot as plt import numpy as np # data loading and transforming from torchvision.datasets impo...
利用pytorch框架搭建神经网络的两种方法
yuekangwei的博客
11-29 1938
搭建神经网络的方法有很多种,本人常用的有两种方法,特地进行总结,每个会分别对应一个小例子演示如何搭建神经网络 方法一: 利用前馈神经网络方式搭建 class Net(torch.nn.Module): def __init__(self, n_feature, n_hidden, n_output): super(Net, self).__init__() self.hidden1 = torch.nn.Linear(n_feature, n_hidden)
PyTorch实现神经网络分类器
04-06
以下是使用PyTorch实现神经网络分类器的基本步骤： 1. 准备数据集：首先需要准备好数据集，包括训练集、验证集和测试集。可以使用PyTorch内置的数据集，例如MNIST手写数字数据集。 2. 定义模型：定义神经网络模型，包括输入层、隐藏层和输出层。可以使用PyTorch内置的模型，如nn.Sequential()，也可以自定义模型。 3. 定义损失函数：选择适当的损失函数，例如交叉熵损失函数。 4. 定义优化器：选择适当的优化器，例如随机梯度下降（SGD）。 5. 训练模型：使用训练集训练模型，通过反向传播优化模型参数。 6. 验证模型：使用验证集验证模型的性能。 7. 测试模型：使用测试集测试模型的性能，计算模型的准确率、精度、召回率等指标。 下面是一个简单的PyTorch代码示例，实现对MNIST手写数字数据集的分类： ```python import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms # 准备数据集 transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False) # 定义模型 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 4 * 4, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) x = self.pool(torch.relu(self.conv2(x))) x = x.view(-1, 16 * 4 * 4) x = torch.relu(self.fc1(x)) x = torch.relu(self.fc2(x)) x = self.fc3(x) return x net = Net() # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # 训练模型 for epoch in range(10): running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 100 == 99: print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 # 验证模型 correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total)) ``` 这段代码首先准备了MNIST数据集，并定义了一个名为Net的神经网络模型，包含两个卷积层、两个池化层和三个全连接层。接着定义了损失函数和优化器，并使用训练集对模型进行训练。最后使用测试集测试模型的性能，计算模型的准确率。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值