pytorch建立网络的四种方法

最新推荐文章于 2025-01-14 20:04:15 发布
转载 最新推荐文章于 2025-01-14 20:04:15 发布 · 411 阅读 · 3

本文介绍了使用PyTorch构建神经网络模型的四种常见方法，包括直接定义各层、利用Sequential容器、通过add_module命名各层以及使用OrderedDict进行层的有序命名。每种方法都有其特点和适用场景。
部署运行你感兴趣的模型镜像

利用pytorch来构建网络模型有很多种方法，以下简单列出其中的四种。

假设构建一个网络模型如下：

卷积层--》Relu层--》池化层--》全连接层--》Relu层--》全连接层

首先导入几种方法用到的包：

import torch
import torch.nn.functional as F
from collections import OrderedDict

 

第一种方法

复制代码

# Method 1 -----------------------------------------

class Net1(torch.nn.Module):
    def __init__(self):
        super(Net1, self).__init__()
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv(x)), 2)
        x = x.view(x.size(0), -1)
        x = F.relu(self.dense1(x))
        x = self.dense2(x)
        return x

print("Method 1:")
model1 = Net1()
print(model1)

复制代码

这种方法比较常用，早期的教程通常就是使用这种方法。

 

第二种方法

复制代码

# Method 2 ------------------------------------------
class Net2(torch.nn.Module):
    def __init__(self):
        super(Net2, self).__init__()
        self.conv = torch.nn.Sequential(
            torch.nn.Conv2d(3, 32, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2))
        self.dense = torch.nn.Sequential(
            torch.nn.Linear(32 * 3 * 3, 128),
            torch.nn.ReLU(),
            torch.nn.Linear(128, 10)
        )

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 2:")
model2 = Net2()
print(model2)

复制代码

这种方法利用torch.nn.Sequential（）容器进行快速搭建，模型的各层被顺序添加到容器中。缺点是每层的编号是默认的阿拉伯数字，不易区分。

 

第三种方法：

复制代码

# Method 3 -------------------------------
class Net3(torch.nn.Module):
    def __init__(self):
        super(Net3, self).__init__()
        self.conv=torch.nn.Sequential()
        self.conv.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
        self.conv.add_module("relu1",torch.nn.ReLU())
        self.conv.add_module("pool1",torch.nn.MaxPool2d(2))
        self.dense = torch.nn.Sequential()
        self.dense.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
        self.dense.add_module("relu2",torch.nn.ReLU())
        self.dense.add_module("dense2",torch.nn.Linear(128, 10))

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 3:")
model3 = Net3()
print(model3)

复制代码

这种方法是对第二种方法的改进：通过add_module()添加每一层，并且为每一层增加了一个单独的名字。

 

第四种方法：

复制代码

# Method 4 ------------------------------------------
class Net4(torch.nn.Module):
    def __init__(self):
        super(Net4, self).__init__()
        self.conv = torch.nn.Sequential(
            OrderedDict(
                [
                    ("conv1", torch.nn.Conv2d(3, 32, 3, 1, 1)),
                    ("relu1", torch.nn.ReLU()),
                    ("pool", torch.nn.MaxPool2d(2))
                ]
            ))

        self.dense = torch.nn.Sequential(
            OrderedDict([
                ("dense1", torch.nn.Linear(32 * 3 * 3, 128)),
                ("relu2", torch.nn.ReLU()),
                ("dense2", torch.nn.Linear(128, 10))
            ])
        )

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 4:")
model4 = Net4()
print(model4)

复制代码

是第三种方法的另外一种写法，通过字典的形式添加每一层，并且设置单独的层名称。

 

完整代码：

复制代码

import torch
import torch.nn.functional as F
from collections import OrderedDict

# Method 1 -----------------------------------------

class Net1(torch.nn.Module):
    def __init__(self):
        super(Net1, self).__init__()
        self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
        self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
        self.dense2 = torch.nn.Linear(128, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv(x)), 2)
        x = x.view(x.size(0), -1)
        x = F.relu(self.dense1(x))
        x = self.dense2()
        return x

print("Method 1:")
model1 = Net1()
print(model1)


# Method 2 ------------------------------------------
class Net2(torch.nn.Module):
    def __init__(self):
        super(Net2, self).__init__()
        self.conv = torch.nn.Sequential(
            torch.nn.Conv2d(3, 32, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2))
        self.dense = torch.nn.Sequential(
            torch.nn.Linear(32 * 3 * 3, 128),
            torch.nn.ReLU(),
            torch.nn.Linear(128, 10)
        )

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 2:")
model2 = Net2()
print(model2)


# Method 3 -------------------------------
class Net3(torch.nn.Module):
    def __init__(self):
        super(Net3, self).__init__()
        self.conv=torch.nn.Sequential()
        self.conv.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
        self.conv.add_module("relu1",torch.nn.ReLU())
        self.conv.add_module("pool1",torch.nn.MaxPool2d(2))
        self.dense = torch.nn.Sequential()
        self.dense.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
        self.dense.add_module("relu2",torch.nn.ReLU())
        self.dense.add_module("dense2",torch.nn.Linear(128, 10))

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 3:")
model3 = Net3()
print(model3)



# Method 4 ------------------------------------------
class Net4(torch.nn.Module):
    def __init__(self):
        super(Net4, self).__init__()
        self.conv = torch.nn.Sequential(
            OrderedDict(
                [
                    ("conv1", torch.nn.Conv2d(3, 32, 3, 1, 1)),
                    ("relu1", torch.nn.ReLU()),
                    ("pool", torch.nn.MaxPool2d(2))
                ]
            ))

        self.dense = torch.nn.Sequential(
            OrderedDict([
                ("dense1", torch.nn.Linear(32 * 3 * 3, 128)),
                ("relu2", torch.nn.ReLU()),
                ("dense2", torch.nn.Linear(128, 10))
            ])
        )

    def forward(self, x):
        conv_out = self.conv1(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense(res)
        return out

print("Method 4:")
model4 = Net4()
print(model4)

 

转载自：https://www.cnblogs.com/denny402/p/7593301.html

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch 2.5

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

PyTorch深度学习实战（1）——神经网络与模型训练过程详解
盼小辉丶的博客
05-28 9万+
在本节中，我们将了解传统机器学习与人工神经网络间的差异，并了解如何在实现前向传播之前连接网络的各个层，以计算与网络当前权重对应的损失值；实现反向传播以优化权重达到最小化损失值的目标。并将实现网络的所有关键组成——前向传播、激活函数、损失函数、链式法则和梯度下降，从零开始构建并训练了一个简单的神经网络。
pytorch建立线性回归神经网络
最新发布
qq_36980284的博客
03-03 500
pytorch建立线性回归神经网络。
PyTorch如何搭建一个简单的网络
09-16
主要介绍了PyTorch如何搭建一个简单的网络，帮助大家更好的理解和学习PyTorch，感兴趣的朋友可以了解下
Pytorch学习笔记（一） 使用PyTorch搭建神经网络的套路
ROM的博客
07-29 1万+
自古套路得人心！！！ PyTorch Python中的张量和动态神经网络，具有强大的GPU加速功能。 目录 自古套路得人心！！！ PyTorch 目录 常见模块的导入 构建网络模型 自定义Net类并实例化 使用顺序容器构建网络并实例化 定义训练函数 定义测试函数 常见模块的导入 import torch import torch.nn as nn...
【动手学习pytorch笔记】30.seq2seq
ymk1998的博客
04-13 1727
seq2seq 理论 编码器是一个RNN，因为任务是机器翻译，所以是双向的 解码器用另外一个RNN输出 之前看过Transformer对这个很熟悉 需要注意的一点是，在做训练和做推理的时候是有区别的 在训练时，我们是有正确的翻译的，所以解码器的每次输入都是正确的翻译 而在推理时，智能用我们预测的词当作解码器RNN下一个时间步的输入 那么现在我实在预测一个句子序列，而不是和之前一样预测一个词了，那么怎么衡量一个句子序列的好坏呢 比如p2p_2p2​，预测序列一共有AB,BB,BC,CD四种，在标签序列
Pytorch之搭建神经网络的四种方法
热门推荐
qq_37385726的博客
08-16 2万+
目录 第一种方法 第二种方法 第三种方法 第四种方法 完整代码    转载自这里 利用pytorch来构建网络模型有很多种方法，以下简单列出其中的四种。 假设构建一个网络模型如下： 卷积层--》Relu层--》池化层--》全连接层--》Relu层--》全连接层 首先导入几种方法用到的包： import torch import torch.nn.functional a...
使用pytorch深度学习框架搭建神经网络
qq_57290048的博客
08-30 2774
数据集为CIFAR10，CIFAR-10 数据集由 10 个类的 60000 张 32x32 彩色图像组成，每个类有 6000 张图像。有 50000 张训练图像和 10000 张测试图像。图像大小为3x32x32数据集分为 5 个训练批次和 1 个测试批次，每个批次有 10000 张图像。测试批次包含每个类中随机选择的 1000 张图像。训练批次包含按随机顺序排列的剩余图像，但某些训练批次可能包含来自一个类的图像多于另一个类的图像。在它们之间，训练批次正好包含来自每个类的 5000 张图像。
pytorch构建网络模型的4种方法
09-20
以下将详细介绍四种构建PyTorch网络模型的方法。 第一种方法是通过直接继承torch.nn.Module类并定义自己的网络层来构建网络。具体代码示例如下： ```python import torch import torch.nn.functional as F from ...
PyTorch DAY2: 搭建神经网络
feifeikon的博客
01-14 1264
如今，我们已经了解了 PyTorch 中张量及其运算，但这远远不够。本次实验将学会如何使用 PyTorch 方便地构建神经网络模型，以及 PyTorch 训练神经网络的步骤及方法。
精选资源
PyTorch生成对抗网络编程.docx
09-13
首先，我们将从零开始逐步讲解GAN的基本概念、模型结构、训练方法等内容，帮助读者建立完整的GAN知识体系。然后，我们将介绍GAN在计算机视觉、自然语言处理等领域的应用案例，使读者了解GAN的实际应用价值。最后，...
pytorch入门——构建神经网络
qq_53536373的博客
03-24 7461
本文介绍了基于pytorch神经网络的典型构建流程,介绍了损失函数 反向传播 更新参数等
【笔记】Pytorch-搭建一个超简单的网络
weixin_52238310的博客
12-03 806
Pytorch 神经网络搭建学习 持续更新中！！！
pytorch——搭建网络
weixin_45833008的博客
09-15 374
pytorch搭建网络 pytorch-1 简单网络搭建pytorch搭建网络import 必要的库数据集网络搭建优化器训练网络测试 import 必要的库 import torch import torch.nn as nn import numpy 数据集 x = np.mat('0 0;' '0 1;' '1 0;' '1 1') x = torch.tensor(x).float() y = np.mat('1;' '0;' '0;' '
Pytorch搭建网络
zhangyifei0115
01-21 300
用PyTorch搭建一个小网络 下面以计算两个数的和为例，x是输入数据，y是标签。 import torch import torch.nn as nn x = torch.Tensor([[0.2,0.4],[0.2,0.3],[0.3,0.4]])#数据 y = torch.Tensor([[0.6],[0.5],[0.7]])#标签 不需要求导 #定义网络 class MyNet(nn....
使用PyTorch搭建神经网络
2301_80000990的博客
08-26 414
网络构建 数据加载与处理 加载训练数据集 加载测试数据集 将模型实例化并转移到定义的设备 选择优化器和损失函数 训练过程 评估函数 调用 evaluate_model 并捕获准确率 记录训练结束时间并打印训练时间 调用 evaluate_model 并捕获准确率 记录训练结束时间并打印训练时间 参考：https://zhuanlan.zhihu.com/p/696017829
使用pytorch搭建神经网络
starvapour的博客
02-26 4344
使用pytorch进行机器学习1. Config and Seed2. Transform/Pre-processing3. Dataset4. Dataloader5. Model6. Optimizer7. Loss8. Train9. Val and Save10. Test11. Other11.1 Apex 使用pytorch搭建学习框架中用到的主要结构部分与一些代码的写法。 1. Config and Seed 2. Transform/Pre-processing 3. Dataset 4.
pytorch搭建网络结构
myc的博客
03-31 1551
记录pytorch怎么搭建网络，看起来更舒服 首先定义一个block class myBlock(nn.module): def __init__(self,in_channel,out_channel,····)： super(myBlock,self).__init__() ······· def forward(self,x): ······· 然后直接定义网络 class...
用pytorch实现神经网络
weixin_42295969的博客
08-15 1万+
放在这个示例的理解：获得dataset数据–>利用加载器进行数据加载–>设计神经网络的结构–>定义优化器以及损失函数–>遍历数据进行梯度下降求解50次–>用模型进行预测得到预测值 通用理解：数据加载–>设计网络结构–>遍历数据进行梯度下降求解到损失值的最小值或者指定次数–>保存对应的梯度参数或者直接计算test情况 ...........................
pytorch建立卷积网络
03-21
PyTorch是一个开源的深度学习框架，可以用于构建卷积神经网络（Convolutional Neural Network, CNN）。下面是使用PyTorch建立卷积网络的一般步骤： 1. 导入必要的库和模块： ```python import torch import torch.nn as nn import torch.optim as optim ``` 2. 定义卷积神经网络的结构： ```python class ConvNet(nn.Module): def __init__(self): super(ConvNet, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size) self.relu = nn.ReLU() self.pool = nn.MaxPool2d(kernel_size) self.fc = nn.Linear(in_features, out_features) def forward(self, x): x = self.conv1(x) x = self.relu(x) x = self.pool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x ``` 在这个例子中，我们定义了一个简单的卷积神经网络，包含一个卷积层、ReLU激活函数、池化层和全连接层。 3. 实例化网络模型： ```python model = ConvNet() ``` 4. 定义损失函数和优化器： ```python criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=learning_rate) ``` 这里使用交叉熵损失函数和随机梯度下降（SGD）优化器。 5. 训练网络： ```python for epoch in range(num_epochs): for images, labels in train_loader: optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() ``` 这里使用一个双层循环，外层循环控制训练的轮数，内层循环遍历训练数据集，计算损失并进行反向传播和参数更新。 6. 测试网络： ```python with torch.no_grad(): correct = 0 total = 0 for images, labels in test_loader: outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100 * correct / total print('Test Accuracy: {}%'.format(accuracy)) ``` 这里使用测试数据集对训练好的网络进行评估，并计算准确率。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值