【深度学习】Kaggle知识点：Pytorch基类 nn.Module（含代码）

最新推荐文章于 2024-02-05 13:55:31 发布

旅途中的宽~

最新推荐文章于 2024-02-05 13:55:31 发布

阅读量1.2k

点赞数 26

分类专栏： kaggle 深度学习笔记文章标签：深度学习 pytorch nn.Module

本文链接：https://blog.csdn.net/wzk4869/article/details/135666562

版权

深度学习笔记同时被 2 个专栏收录

82 篇文章 38 订阅

订阅专栏

kaggle

12 篇文章 6 订阅

订阅专栏

这篇文章详细介绍了如何在PyTorch中使用torch.nn.Module构建神经网络模型，包括参数管理和子模块的组织、前向传播的定义、模型的保存与加载，以及模型的训练过程。特别强调了如何利用torch.nn.Module的特性来构建和优化模型结构。

摘要由CSDN通过智能技术生成

torch.nn.Module 是 PyTorch 中一个重要的基类，用于构建神经网络模型。它提供了一种方便的方式来组织和管理模型参数、定义前向传播等功能。继承自 torch.nn.Module 的类可以被视为一个可训练的参数集合，可以包含其他模块，从而形成层次化的模型结构。

一、关键功能和属性

1.1 参数管理

torch.nn.Module 可以追踪并管理所有注册的参数。通过 parameters() 方法，可以方便地获取模型中的所有参数。

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Linear(10, 5)

model = MyModel()
print(list(model.parameters()))

1.2 子模块管理

通过将其他 torch.nn.Module 的实例注册为当前模块的属性，可以形成层次化的模型结构。这使得模型可以以更模块化的方式进行定义。

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 2)

model = MyModel()

1.3 前向传播定义

在继承 torch.nn.Module 的子类中，需要实现 forward 方法来定义模型的前向传播过程。

import torch.nn as nn
import torch

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Linear(10, 5)

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

model = MyModel()
input_data = torch.randn(3, 10)
output = model(input_data)

1.4 模型保存和加载

模型可以方便地保存到文件并在需要时加载。这是通过 torch.save 和 torch.load 函数来实现的。

torch.save(model.state_dict(), 'my_model.pth')
loaded_model = MyModel()
loaded_model.load_state_dict(torch.load('my_model.pth'))

1.5 模型训练

由于继承了 torch.nn.Module，模型可以使用 PyTorch 的优化器进行训练。

import torch.optim as optim

optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()

# 在训练循环中使用 optimizer 和 criterion

二、使用案例

2.1 定义模型

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

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

2.2 定义不更新的参数

self.register_buffer 定义一组参数，参数不会变化，只可人为地改变它们的值），但是保存模型时，该组参数又作为模型参数不可或缺的一部分被保存。

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

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        # （1）常见定义模型时的操作
        self.param_nn = nn.Sequential(OrderedDict([
            ('conv', nn.Conv2d(1, 1, 3, bias=False)),
            ('fc', nn.Linear(1, 2, bias=False))
        ]))

        # （2）使用register_buffer()定义一组参数
        self.register_buffer('param_buf', torch.randn(1, 2))

        # （3）使用形式类似的register_parameter()定义一组参数
        self.register_parameter('param_reg', nn.Parameter(torch.randn(1, 2)))

        # （4）按照类的属性形式定义一组变量
        self.param_attr = torch.randn(1, 2) 

    def forward(self, x):
        return x

net = Model()

三、内置函数

3.1 add_module

将子模块添加到当前模块。

3.2 apply

对当前模块及其所有子模块递归地应用函数 fn。

@torch.no_grad()
def init_weights(m):
    print(m)
    if type(m) == nn.Linear:
        m.weight.fill_(1.0)
        print(m.weight)
net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
net.apply(init_weights)