『pytorch』四：自定义模型

最新推荐文章于 2023-07-27 14:28:49 发布
最新推荐文章于 2023-07-27 14:28:49 发布
阅读量3.6k 收藏 27
点赞数 8
分类专栏： 编程语言 文章标签： 深度学习 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/olizxq/article/details/118057627
版权

1、nn.Module

pytorch里面一切自定义操作基本上都是继承nn.Module类来实现的，因此首先要看一下nn.Module类的定义。

nn.Module类

1.1 类方法

class Module(object):
    def __init__(self):
    # 核心功能
    def forward(self, *input):
        # 每次运行时都会执行的步骤，所有自定义的module都要重写这个函数
    def add_module(self, name, module):
        # 将子模块加入当前的模块中，被添加的模块可以name来获取
    def state_dict(destionation=None):
        # 返回一个字典，保存module的所有状态
    def load_state_dict(state_dict):
        # 用来加载模型参数
    
    # 查看模块
    def parameters(self, recurse=True):
        # 返回一个包含模型所有参数的迭代器，一般用作optimizer参数
    def named_parameters(self, prefix='', recurse=True):
        # 返回一个包含模型所有参数的迭代器，yield 参数名字和参数本身
    def children(self):
        # 返回包含模型当前子模块的迭代器
    def named_children(self):
        # 返回包含模型当前子模块的迭代器，yield 模块名字和模块本身
    def modules(self):  
        # 返回一个包含当前模型所有模块的迭代器
    def named_modules(self, memo=None, prefix=''):
        # 返回一个包含当前模型所有模块的迭代器, yield 模块名和模块本身
    
    # 类型转换
    def cpu(self):
        # 将所有的模型参数(parameters)和buffers复制到CPU
    def cuda(self, device=None):
        # 将所有的模型参数(parameters)和buffers赋值GPU
    def double(self):
        # 将parameters和buffers的数据类型转换成double
    def float(self):
        # 将parameters和buffers的数据类型转换成float
    def half():
        # 将parameters和buffers的数据类型转换成half
    
    # 运行模式设置
    def train(self, mode=True):
        # 将module设置为training mode，只影响dropout和batchNorm
    def eval(self):
        # 将模型设置成evaluation模式，只影响dropout和batchNorm
    def zero_grad(self):
    	# 将module中的所有模型的梯度设置为0
    
    # 注册功能
    def register_parameter(name, param):
        # 向module添加parameter，可以通过name获取
	def register_forward_hook(hook):
    	# 在module上注册一个forward hook，每次调用forward()计算输出的时候，这个hook就会被调用　
	def register_backward_hook(hook):
    	# 在module上注册一个bachward hook，每次计算module的inputs的梯度的时候，这个hook会被调用
	def register_buffer(name, tensor):
    	# 给module添加一个persistent buffer，通常用来保存一个不需要看成模型参数的状态

在自定义网络时，需要继承nn.Module类，并重新实现构造函数__init__和forward两个方法。这里有一些注意事项：

（1）一般把网络中具有可学习参数的层（如全连接层、卷积层等）放在构造函数__init__()中，当然也可以把不具有参数的层也放在里面；

（2）不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中，也可不放在构造函数中，如果不放在构造函数__init__里面，则在forward方法里面可以使用nn.functional来代替；

（3）forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心。

1.2 方法介绍

Sequenrial类实现了整数索引，故而可以使用model[index] 这样的方式获取一个层，但是Module类并没有实现整数索引，不能够通过整数索引来获得层，但是它提供了下面几个方法来操作：

def children(self): 
def named_children(self): 
def modules(self):
def named_modules(self, memo=None, prefix=''):
'''注意：这几个方法返回的都是一个Iterator迭代器，故而通过for循环访问，当然也可以通过next'''

（1）model.children()方法

import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block=torch.nn.Sequential()
        self.conv_block.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
        self.conv_block.add_module("relu1",torch.nn.ReLU())
        self.conv_block.add_module("pool1",torch.nn.MaxPool2d(2))
 
        self.dense_block = torch.nn.Sequential()
        self.dense_block.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
        self.dense_block.add_module("relu2",torch.nn.ReLU())
        self.dense_block.add_module("dense2",torch.nn.Linear(128, 10))
 
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
 
for i in model.children():
    print(i)
    print(type(i)) # 查看每一次迭代的元素到底是什么类型，实际上是 Sequential 类型,所以有可以使用下标index索引来获取每一个Sequenrial 里面的具体层
 
'''运行结果为：
Sequential(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu1): ReLU()
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
<class 'torch.nn.modules.container.Sequential'>
Sequential(
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (relu2): ReLU()
  (dense2): Linear(in_features=128, out_features=10, bias=True)
)
<class 'torch.nn.modules.container.Sequential'>
'''

（2）model.named_children()方法

for i in model.named_children():
    print(i)
    print(type(i)) # 查看每一次迭代的元素到底是什么类型，实际上是 返回一个tuple,tuple 的第一个元素是
 
'''运行结果为：
('conv_block', Sequential(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu1): ReLU()
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
))
<class 'tuple'>
('dense_block', Sequential(
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (relu2): ReLU()
  (dense2): Linear(in_features=128, out_features=10, bias=True)
))
<class 'tuple'>
'''

总结：

（1）model.children()和model.named_children()方法返回的是迭代器iterator；

（2）model.children()：每一次迭代返回的元素实际上是 Sequential 类型，而Sequential类型又可以使用下标index索引来获取每一个Sequenrial 里面的具体层，比如conv层、dense层等；

（3）model.named_children()：每一次迭代返回的元素实际上是一个元组类型，元组的第一个元素是名称，第二个元素就是对应的层或者是Sequential。

（3）model.modules()方法

for i in model.modules():
    print(i)
    print("==================================================")
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
)
==================================================
Sequential(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu1): ReLU()
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
==================================================
Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
==================================================
ReLU()
==================================================
MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
==================================================
Sequential(
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (relu2): ReLU()
  (dense2): Linear(in_features=128, out_features=10, bias=True)
)
==================================================
Linear(in_features=288, out_features=128, bias=True)
==================================================
ReLU()
==================================================
Linear(in_features=128, out_features=10, bias=True)
==================================================
'''

（4）model.named_modules()方法

for i in model.named_modules():
    print(i)
    print("==================================================")
'''运行结果是：
('', MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
))
==================================================
('conv_block', Sequential(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu1): ReLU()
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
))
==================================================
('conv_block.conv1', Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)))
==================================================
('conv_block.relu1', ReLU())
==================================================
('conv_block.pool1', MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))
==================================================
('dense_block', Sequential(
  (dense1): Linear(in_features=288, out_features=128, bias=True)
  (relu2): ReLU()
  (dense2): Linear(in_features=128, out_features=10, bias=True)
))
==================================================
('dense_block.dense1', Linear(in_features=288, out_features=128, bias=True))
==================================================
('dense_block.relu2', ReLU())
==================================================
('dense_block.dense2', Linear(in_features=128, out_features=10, bias=True))
==================================================
'''

总结：

（1）model.modules()和model.named_modules()方法返回的是迭代器iterator；

（2）model的modules()方法和named_modules()方法都会将整个模型的所有构成（包括包装层、单独的层、自定义层等）由浅入深依次遍历出来，只不过modules()返回的每一个元素是直接返回的层对象本身，而named_modules()返回的每一个元素是一个元组，第一个元素是名称，第二个元素才是层对象本身。

（3）如何理解children和modules之间的这种差异性。注意pytorch里面不管是模型、层、激活函数、损失函数都可以当成是nn.Module的拓展，所以modules和named_modules会层层迭代，由浅入深，将每一个自定义块block、以及block里面的每一个层都当成是module来迭代。而children就比较直观，表示的是所谓的“孩子”，所以没有层层迭代深入。

2、模型构造

2.1 继承Module类

将所有层都放在构造函数__init__里，在forward里实现所有层的连接关系：

class MLP(nn.Module):
    # 声明带有模型参数的层，这里声明了两个全连接层
    def __init__(self, **kwargs):
        # 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数参数
        super(MLP, self).__init__(**kwargs)
        self.hidden = nn.Linear(784, 256) # 隐藏层
        self.act = nn.ReLU()
        self.output = nn.Linear(256, 10)  # 输出层
         
    # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
    def forward(self, x):
        a = self.act(self.hidden(x))
        return self.output(a)

将没有训练参数的层不放在构造函数里面，所以这些层就不会出现在model里，但是运行关系在forward里面通过functional的方法实现：

import torch.nn as nn
import torch.nn.functional as F

class MLP(nn.Module):
    def __init__(self, **kwargs):
        super(MLP, self).__init__(**kwargs)
        self.hidden = nn.Linear(784, 256)
        self.output = nn.Linear(256, 10)
        
    def forward(self, x):
        a = F.relu(self.hidden(x))
        return self.output(a)

所有放在构造函数__init__里面的层都是这个模型的“固有属性”。

2.2 Module子类

Module子类非常灵活，有多种实现方式：

2.2.1 Sequential类

方式一：直接使用层

import torch.nn as nn
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block = nn.Sequential(
            nn.Conv2d(3, 32, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2))
        self.dense_block = nn.Sequential(
            nn.Linear(32 * 3 * 3, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    # 在这里实现层之间的连接关系，其实就是所谓的前向传播
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (0): Linear(in_features=288, out_features=128, bias=True)
    (1): ReLU()
    (2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''

方式二：使用OrderedDict

import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block = nn.Sequential(
            OrderedDict(
                [
                    ("conv1", nn.Conv2d(3, 32, 3, 1, 1)),
                    ("relu1", nn.ReLU()),
                    ("pool", nn.MaxPool2d(2))
                ]
            ))
 
        self.dense_block = nn.Sequential(
            OrderedDict([
                ("dense1", nn.Linear(32 * 3 * 3, 128)),
                ("relu2", nn.ReLU()),
                ("dense2", nn.Linear(128, 10))
            ])
        )
 
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''

方式三：使用add_module

import torch.nn as nn
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.conv_block=torch.nn.Sequential()
        self.conv_block.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
        self.conv_block.add_module("relu1",torch.nn.ReLU())
        self.conv_block.add_module("pool1",torch.nn.MaxPool2d(2))
 
        self.dense_block = torch.nn.Sequential()
        self.dense_block.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
        self.dense_block.add_module("relu2",torch.nn.ReLU())
        self.dense_block.add_module("dense2",torch.nn.Linear(128, 10))
 
    def forward(self, x):
        conv_out = self.conv_block(x)
        res = conv_out.view(conv_out.size(0), -1)
        out = self.dense_block(res)
        return out
 
model = MyNet()
print(model)
'''运行结果为：
MyNet(
  (conv_block): Sequential(
    (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu1): ReLU()
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense_block): Sequential(
    (dense1): Linear(in_features=288, out_features=128, bias=True)
    (relu2): ReLU()
    (dense2): Linear(in_features=128, out_features=10, bias=True)
  )
)
'''
2.2.2 ModuleList类
net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1])  # 类似List的索引访问
print(net)

# Linear(in_features=256, out_features=10, bias=True)
# ModuleList(
#   (0): Linear(in_features=784, out_features=256, bias=True)
#   (1): ReLU()
#   (2): Linear(in_features=256, out_features=10, bias=True)
# )
2.2.3 ModuleDict类
net = nn.ModuleDict({
    'linear': nn.Linear(784, 256),
    'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output)
print(net)

# Linear(in_features=784, out_features=256, bias=True)
# Linear(in_features=256, out_features=10, bias=True)
# ModuleDict(
#   (act): ReLU()
#   (linear): Linear(in_features=784, out_features=256, bias=True)
#   (output): Linear(in_features=256, out_features=10, bias=True)
# )

2.3 构造复杂模型

class FancyMLP(nn.Module):
    def __init__(self, **kwargs):
        super(FancyMLP, self).__init__(**kwargs)
        # 不可训练参数（常数参数）
        self.rand_weight = torch.rand((20, 20), requires_grad=False) 
        self.linear = nn.Linear(20, 20)

    def forward(self, x):
        x = self.linear(x)
        # 使用创建的常数参数，以及nn.functional中的relu函数和mm函数
        x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
        
        # 复用全连接层。等价于两个全连接层共享参数
        x = self.linear(x)
        # 控制流，这里我们需要调用item函数来返回标量进行比较
        while x.norm().item() > 1:
            x /= 2
        if x.norm().item() < 0.8:
            x *= 10
        return x.sum()

class NestMLP(nn.Module):
    def __init__(self, **kwargs):
        super(NestMLP, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU()) 

    def forward(self, x):
        return self.net(x)

net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())

X = torch.rand(2, 40)
print(net)
net(X)

# Sequential(
#   (0): NestMLP(
#     (net): Sequential(
#       (0): Linear(in_features=40, out_features=30, bias=True)
#       (1): ReLU()
#     )
#   )
#   (1): Linear(in_features=30, out_features=20, bias=True)
#   (2): FancyMLP(
#     (linear): Linear(in_features=20, out_features=20, bias=True)
#   )
# )
# tensor(-0.4605, grad_fn=<SumBackward0>)

3、参数

3.1 访问模型参数

print(type(net.named_parameters()))
for name, param in net.named_parameters():
    print(name, param.size())
# <class 'generator'>
# 0.weight torch.Size([3, 4])
# 0.bias torch.Size([3])
# 2.weight torch.Size([1, 3])
# 2.bias torch.Size([1])

3.2 初始化模型参数

for name, param in net.named_parameters():
    if 'weight' in name:
        init.normal_(param, mean=0, std=0.01)
        print(name, param.data)
# 0.weight tensor([[ 0.0030,  0.0094,  0.0070, -0.0010],
#         [ 0.0001,  0.0039,  0.0105, -0.0126],
#         [ 0.0105, -0.0135, -0.0047, -0.0006]])
# 2.weight tensor([[-0.0074,  0.0051,  0.0066]])

for name, param in net.named_parameters():
    if 'bias' in name:
        init.constant_(param, val=0)
        print(name, param.data)
# 0.bias tensor([0., 0., 0.])
# 2.bias tensor([0.])

3.3 自定义初始化方法

def init_weight_(tensor):
    with torch.no_grad():
        tensor.uniform_(-10, 10)
        tensor *= (tensor.abs() >= 5).float()

for name, param in net.named_parameters():
    if 'weight' in name:
        init_weight_(param)
        print(name, param.data)
# 0.weight tensor([[ 7.0403,  0.0000, -9.4569,  7.0111],
#         [-0.0000, -0.0000,  0.0000,  0.0000],
#         [ 9.8063, -0.0000,  0.0000, -9.7993]])
# 2.weight tensor([[-5.8198,  7.7558, -5.0293]])

for name, param in net.named_parameters():
    if 'bias' in name:
        param.data += 1
        print(name, param.data)
# 0.bias tensor([1., 1., 1.])
# 2.bias tensor([1.])

3.4 共享模型参数

linear = nn.Linear(1, 1, bias=False)
net = nn.Sequential(linear, linear) 
print(net)
# Sequential(
#   (0): Linear(in_features=1, out_features=1, bias=False)
#   (1): Linear(in_features=1, out_features=1, bias=False)
# )

for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)
# 0.weight tensor([[3.]])

print(id(net[0]) == id(net[1]))
print(id(net[0].weight) == id(net[1].weight))
# True
# True

4、自定义层

4.1 不含模型参数

class CenteredLayer(nn.Module):
    def __init__(self, **kwargs):
        super(CenteredLayer, self).__init__(**kwargs)
    def forward(self, x):
        return x - x.mean()
    
layer = CenteredLayer()
layer(torch.tensor([1, 2, 3, 4, 5], dtype=torch.float))
# tensor([-2., -1.,  0.,  1.,  2.])

4.2 含模型参数

class MyDictDense(nn.Module):
    def __init__(self):
        super(MyDictDense, self).__init__()
        self.params = nn.ParameterDict({
                'linear1': nn.Parameter(torch.randn(4, 4)),
                'linear2': nn.Parameter(torch.randn(4, 1))
        })
        self.params.update({'linear3': nn.Parameter(torch.randn(4, 2))}) # 新增

    def forward(self, x, choice='linear1'):
        return torch.mm(x, self.params[choice])

net = MyDictDense()
print(net)
# MyDictDense(
#   (params): ParameterDict(
#       (linear1): Parameter containing: [torch.FloatTensor of size 4x4]
#       (linear2): Parameter containing: [torch.FloatTensor of size 4x1]
#       (linear3): Parameter containing: [torch.FloatTensor of size 4x2]
#   )
# )

x = torch.ones(1, 4)
print(net(x, 'linear1'))
print(net(x, 'linear2'))
print(net(x, 'linear3'))
# tensor([[1.5082, 1.5574, 2.1651, 1.2409]], grad_fn=<MmBackward>)
# tensor([[-0.8783]], grad_fn=<MmBackward>)
# tensor([[ 2.2193, -1.6539]], grad_fn=<MmBackward>)
深度学习——01pytorch自定义网络模型
weixin_48501651的博客
05-15 541
深度学习，自定义网络模型
一、定义Pytorch模型
wszfe的博客
03-14 2112
定义Pytorch模型
Pytorch学习笔记2--模型定义
小熊猫的博客
11-30 1131
保存模型的推荐方法 这主要有两种方法序列化和恢复模型。 第一种（推荐）只保存和加载模型参数： torch.save(the_model.state_dict(), PATH) 然后： the_model = TheModelClass(*args, **kwargs) the_model.load_state_dict(torch.load(PATH)) 第二种保存和加载整个模...
【Pytorch】自定义模型、自定义损失函数及模型删除修改层的常用操作
AIGC | 智能洞察，创造未来
06-07 1312
自定义模型、自定义损失函数及模型删除修改层的常用操作
【PyTorch】PyTorch模型定义
Katniss的Blog
09-18 1017
Direct List：直接列出Ordered Dict：有序字典（Python中的字典无序，但网络是有序的，因此用Ordered Dict）用OrderedDict可以实现层的命名。注意：ModuleList定义后并没有形成网络，只是将不同的模块存储到一起，因此不能直接输入数据，因此还需要定义forward()。同样地，ModuleDict并没有定义一个网络，它只是将不同的模块储存在一起。此处应报错。正确使用方式同上。
Pytorch学习日记02-自定义模型及卷积操作
qq_43617906的博客
07-27 657
最简单的方式了解Pytorch中的卷积过程。了解每一个参数每一个结果的图像化展示。
Pytorch入门教程学习笔记（四）自定义模型、模型读取和存储、GPU计算
Younguys
04-24 578
目录4.4 自定义Layer4.4.1 不含参数的自定义4.4.2 含参数的自定义层4.5读取和存储4.5.1 读写Tensor4.5.2 读写Model4.5.2.1 state_dict4.5.2.2 保存和加载模型4.6 GPU计算4.6.1 计算设备4.6.2 Tensor的GPU计算4.6.3 Model的GPU计算说明 4.4 自定义Layer 本节将介绍如何使用Module来自定义层，从而可以被重复调用。 4.4.1 不含参数的自定义 自定义的CenteredLayer类通过继承Module类
Pytorch: 自定义网络层实例
09-18
在PyTorch中，自定义网络层是一项重要的功能，它允许开发者根据特定需求构建个性化的神经网络模型。本篇文章将详细讲解如何在PyTorch中实现自定义的网络层，特别是利用自动微分机制来简化复杂的计算过程。 首先，让...
pytorch中的自定义反向传播,求导实例
09-18
但是，在某些情况下，我们可能需要使用自定义的算法来处理特定任务，这时就需要手动实现反向传播求导，以便将这些算法融入到PyTorch的自动微分系统中。 在PyTorch中，可以继承`torch.autograd.Function`类并实现`...
自定义力量：在PyTorch中构建自定义层与模块的艺术
07-19
通过上述示例，我们可以看到，在 PyTorch 中构建自定义层不仅简单易行，而且可以极大地提高模型的灵活性和性能。这种自定义能力是 PyTorch 成为深度学习领域最受欢迎的框架之一的重要原因之一。无论是在学术研究还是...
pytorch：pytorch模型训练的主要步骤
最新发布
07-27
代码中主要包含pytorch模型训练的主要步骤，可以根据需要自定义模型、数据集，并进行训练。
PyTorch Lightning：简化深度学习训练的革命
07-19
`LightningModule` 是 PyTorch Lightning 中的一个核心类，所有的自定义模型都需要继承这个类。通过实现特定的方法，可以轻松地定义模型的前向传播、训练步骤、验证步骤和测试步骤。 例如，下面展示了一个简单的...
PyTorch 自定义model简单示例
伍文君的博客
02-09 1490
PyTorch 自定义model简单示例 环境：python3.8 Pytorch介绍 Pytorch中文文档 import torch import numpy as np def test(): x_data = torch.Tensor([[2,2,1],[1,1,2],[-1,0,1],[-1,1,-1]]) y_data = torch.Tensor([[5,1],[4,2],[0,0],[-1,-3]]) # 对应关系为x [[1,1], #
pytorch基本使用——定义模型
weixin_51691064的博客
04-12 1104
我们通过继承torch.nn.Module来实现自己的类，其中__init__和forward__init__：初始化模型forward：向前传播，输入转输出结果Net(上面代码，当执行net=Net()时，__init__就初始化了两个卷积。之后我们会输出数据x，当我们执行net(x)时进行forward正向传播，计算得到最终的结果。
自定义模型
SarKerson的博客
11-24 1036
custom modelwe need to use tf.estimator.Estimator. tf.estimator.LinearRegressor is actually a sub-class of tf.estimator.Estimator. Instead of sub-classing Estimator, we simply provide Estimator a funct
PyTorch：模型定义
uncle_ll的博客
03-16 2801
Pytorch模型定义的方式 模型在深度学习中扮演着重要的角色，好的模型极大地促进了深度学习的发展进步，比如CNN的提出解决了图像、视频处理中的诸多问题，RNN/LSTM模型解决了序列数据处理的问题，GNN在图模型上发挥着重要的作用。当我们在向他人介绍一项深度学习工作的时候，对方可能首先要问的就是使用了哪些模型。因此，在PyTorch进阶操作的第一部分中，首先来学习PyTorch模型相关的内容。 在第一部分课程中，已经学习了模型中的“层“是如何定义的，以及基础的模型是如何构建的。这里来更为系统地学习PyTo
SCNN-pytorch:PyTorch中的空间CNN模型使用Cityscapes-dataset
03-18
pytorch-SCNN **于2018/12/15更新。 去做 支持不同的骨干网 支持城市景观 单GPU训练 介绍 这是的PyTorch（0.4.1）实现。它可以使用Modified Aligned ResNet...请按照以下步骤训练您的模型： 输入参数：（通过python tr
PyTorch Geometric自定义模型
cobracanary的博客
10-01 184
这块的内容介绍相当的少，官网给出的doc也描述的没有非常清晰，以至于我刚开始学的时候非常云里雾里。后来慢慢明白了之后，才慢慢看懂官网的doc。 首先给出官网的doc： 这一块我们要注意几个点：方块代表的是聚合邻居信息的操作，比方说sum,mean,max，γ代表的是结合上一跳邻居信息和节点信息的更新操作，φ代表的是接受邻居信息的操作。 了解了这些知识，再看PyG的注解就容易了，我们需要实现的是这几个函数，就可以自定义GNN的一层： 总结下来就这几点： MessagePassing定义邻居信息的聚合器，
pytorch 学习笔记之自定义 Module
热门推荐
丁丁的博客
04-22 1万+
pytorch 是一个基于 python 的深度学习库。pytorch 源码库的抽象层次少，结构清晰，代码量适中。相比于非常工程化的 tensorflow，pytorch 是一个更易入手的，非常棒的深度学习框架。 对于系统学习 pytorch，官方提供了非常好的入门教程 ，同时还提供了面向深度学习的示例，同时热心网友分享了更简洁的示例。 1. overview 不同于 theano，te...
pytorch自定义模型执行过程
约定的博客
04-23 515
使用pytorch定义自己的模型是继承nn.Module实现的。在__init__方法中定义需要初始化的参数，一般把网络中具有可学习参数的层放在这里定义。forward方法实现模型的功能，实现各个层之间的连接关系的核心。backward函数就会被自动实现(利用Autograd)。 class WordAveragingModel(nn.Module): def __init__(self, vocab_size: int, embed_dim: int, embed_dropout: float
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值