pytorch中的面向对象编程方法

🕗 发布于 2024-07-24 11:29 pytorch 人工智能 python

一、xxx形式的魔法方法

我们可以经常在python代码片段中看到类的定义，其中第一个被定义的方法往往是__init__，如下所示：

class Accumulator:  
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
    def reset(self):
        self.data = [0.0] * len(self.data)
    def __getitem__(self, idx):
        return self.data[idx]

我们知道__init__显然是类的构造函数，但为什么要在前后都加上双下划线呢？

原来这是python设计的一种特殊方法，它别称为魔法方法，它可以被运算符隐式调用，下面给出示例：

import torch
class Accumulator:  #@save
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
    def reset(self):
        self.data = [0.0] * len(self.data)
    def __getitem__(self, idx):
        return self.data[idx]
    
test=Accumulator(3)
test.add(0,1,2)
print(test.__getitem__(2)) #打印2.0
print(test[2])             #打印2.0

可以发现，所谓魔法方法，实质上实现的就是c++中运算符重载的功能。它让test.__getitem__(2)和test[2]这两种语法都能调用该方法！

对于更多的python的魔法方法，可以看看下面这一篇文章：

Python 中的 `__xxx__` 特殊方法：介绍与使用-CSDN博客

其中，与pytorch紧密相关的一个方法比较重要，这便是__call__方法，它能通过以下方式被直接调用：

test=Accumulator(3)
test.__call__(param)
test(param)
'''两者等价'''

示例如下：

import torch
class Accumulator:  #@save
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
    def reset(self):
        self.data = [0.0] * len(self.data)
    def __call__(self, idx):
        return self.data[idx]
    
test=Accumulator(3)
test.add(0,1,2)
print(test.__call__(2))    #打印2.0
print(test(2))             #打印2.0

二、nn.Module类的使用以及其重要的两个类方法

神经网络较为复杂，可以被分为块和层。用类去分别定义神经网络的一个层、一个块会更为清晰。而nn.Module便是pytorch设计者为块类和层类设计的父类，如nn.Linear、nn.Flatten和nn.ReLU这样描述层的类，便是继承自nn.Module类。我们也可以继承nn.Module类，编写我们所需要的层和类。

nn.Module类有一个非常非常重要的特征，那便是其__call__函数里调用了forward方法。所以，在继承nn.Module类时，需要为子类写好forward方法，这样才能按照pytorch的习惯发挥子类作为神经网络中层和类的功能！

例如，我现在写一个类用来描述多层感知机这个块，那么，我需要写好forward和__init__两个方法

import torch
from torch import nn
from torch.nn import functional as func

class MulLayerPerceptron(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden=nn.Linear(20,256)
        self.output=nn.Linear(256,10)

    def forward(self,X):
        return self.output(func.relu(self.hidden(X)))
    
net=MulLayerPerceptron()
X=torch.arange(20.0)
print(net(X))

这样，在实例化这个类的对象net后，就可以直接使用net(X)这个函数调用forward方法！

三、Sequential子类

torch框架本省就提供了一个nn.Module的子类——Sequential，这是一个包含多个层的类，可以按顺序执行一系列函数

如上的多层感知机，我就可以这样定义：

net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
X=torch.arange(20.0)
print(net(X))

事实上，其源码的形式如下所示：

class MySequential(nn.Module):
    def __init__(self,*args):
        super().__init__()
        self.layers=[]
        for layer in args:
            self.layers.append(layer)
    
    def forward(self,X):
        for layer in self.layers:
            X=layer(X)
        return X

net=MySequential(nn.Linear(20,256),nn.Linear(256,10))
X=torch.arange(20.0)
print(net(X))

当然，实际上Sequential类会更加复杂。

使用对net使用add_module方法可以为为Sequential块类添加层，其中第一个参数是层的名称，第二个参数是层的类型。

net=nn.Sequential(nn.Linear(20,256))
net.add_module("mylayer",nn.Linear(256,10))

直接打印net可以查看整个Sequential块的组成情况：

print(net)

Sequential(
(0): Linear(in_features=20, out_features=256, bias=True)
(mylayer): Linear(in_features=256, out_features=10, bias=True)
)

可以看出，Sequential的层默认按照数字命名，我们添加的层是自主命名的！

四、参数访问

1、简单结构

对于Sequential类，可以使用类似数组下标访问的方法来访问其每一层：

net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
X=torch.arange(20.0)
print(net[0])
print(net[1])

Linear(in_features=20, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)

可以用state_dict方法看看net[X]中的各个参数：

net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
print(net[0].state_dict())

一般，nn.Linear结构中的参数包括weight和bias，即权重和偏置，可以用.运算符访问：

net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
print(net[0].weight)
print(net[0].bias)

其中，weight和bias都分别包含tensor数组（可用data属性访问）和控制是否求梯度的bool变量requires_grad，可以如下进行访问和设置

net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
print(net[0].weight.data[0])
net[0].weight.requires_grad=True

事实上，net[X]返回了nn库自定义的Parameter类型。

2、嵌套结构

block=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
net=nn.Sequential(block,nn.Linear(10,5))
X=torch.arange(20.0)
print(net(X))
print(net)
print(net[0][0])

运行结果：

tensor([ 1.9557, -2.0318, -1.2498, -0.1433, -0.3641], grad_fn=<ViewBackward0>)
Sequential(
(0): Sequential(
(0): Linear(in_features=20, out_features=256, bias=True)
(1): Linear(in_features=256, out_features=10, bias=True)
)
(1): Linear(in_features=10, out_features=5, bias=True)
)
Linear(in_features=20, out_features=256, bias=True)

如上所示，Sequential类可以进行嵌套。嵌套后，我们使用类似多维数组的方式访问。

五、参数初始化

对于如nn.Linear这样的层，可以使用nn.init下带有的方法将参数初始化。

def init_normal(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight,mean=0.0,std=0.01)
        nn.init.zeros_(m.bias)

如代码所示，nn.Linear作为参数m传入，那么调用nn.init.normal_可以使weight向量得以初始化。第一个参数使所需要初始化的向量，mean参数规定平均值，std参数规定方差。

nn.init.zeros_方法用于将参数置于0，nn.init.constant_方法可以将参数置为某个常数。

nn.init.zeros_(m.weight)
nn.init.constant_(m.weight,1.0) #将weight向量全置为1

而nn.init.uniform_方法，可以使参数均匀分布。其第一个参数还是需要初始化的tensor向量，a代表均匀分布的下界（默认为0.0），b代表上界（默认为1.0）

nn.init.uniform_(m.weight,a=0.0,b=2.0)

对块net使用apply方法，可以让自定义初始化函数在所有层上作用一遍。

block=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
net=nn.Sequential(block,nn.Linear(10,5))
X=torch.arange(20.0)

def init_normal(m):
    if type(m)==nn.Linear:
        print("init")
        nn.init.normal_(m.weight,mean=0.0,std=0.01)
        nn.init.zeros_(m.bias)

net.apply(init_normal)

init

init

init

注意，apply非常智能。纵使Sequential中出现嵌套，也可以层层访问，把所有的nn.Linear结构都进行初始化。

这是因为apply函数会把net的所有结构都访问一遍，打印m，就可以知晓其运作的规律：

block=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
net=nn.Sequential(block,nn.Linear(10,5))
X=torch.arange(20.0)

def init_normal(m):
    print(m)
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight,mean=0.0,std=0.01)
        nn.init.zeros_(m.bias)

net.apply(init_normal)

Linear(in_features=20, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
Sequential(
(0): Linear(in_features=20, out_features=256, bias=True)
(1): Linear(in_features=256, out_features=10, bias=True)
)
Linear(in_features=10, out_features=5, bias=True)
Sequential(
(0): Sequential(
(0): Linear(in_features=20, out_features=256, bias=True)
(1): Linear(in_features=256, out_features=10, bias=True)
)
(1): Linear(in_features=10, out_features=5, bias=True)
)

原文地址：https://blog.csdn.net/BUAAer_xuyang/article/details/140642822

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Stable Diffusion基本原理通俗讲解
下一篇：运筹学：决策优化的艺术

Java项目:校园宿舍管理系统(优质版)(Springboot3+Maven+Mybatis Plus+Vue3+ Element Plus+Mysql)
Springboot3+Maven+Mybatis Plus+Vue3+ Element Plus+Mysql 开发的前后端分离的校园宿舍管理系统。
阅读更多2024-11-16
IntelliJ IDEA新建项目或导入未识别为maven解决
1.首先，我的情况是我新建了一个springboot项目，然后选择类型是Maven但是建立后不是maven项目。当然，前提是你的maven已经在idea上做好配置了。2.打开项目后，从File --》
阅读更多2024-11-16
Gin HTML 模板渲染
Gin HTML模板入门
阅读更多2024-11-16
未来的车网互动如何重塑我们的城市生活
设想一下，在一个寒冷的冬日，你的车辆通过车网互动得知前方桥梁可能结冰，它会自动降低速度，并提醒你注意驾驶安全。公众的参与同样重要，只有当越来越多的车辆加入到车网互动系统中，才能真正发挥其潜力，提高整个
阅读更多2024-11-16
人工智能技术的应用前景及其对生活和工作方式的影响
人工智能技术的应用前景广阔，它不仅在医疗、企业和日常生活中带来了显著的变化，还将继续推动社会的创新和发展。面对 AI 技术带来的机遇和挑战，我们需要共同努力，确保技术的发展能够造福人类社会，创造一个更
阅读更多2024-11-16
《AI技术，让生活更简单》
想象一下，你回到家，灯自动亮了，空调调到你喜欢的温度，冰箱告诉你牛奶快没了，甚至还能帮你预约超市送货。这不是科幻电影，这就是AI技术正在做的事情。
阅读更多2024-11-16
sychronized锁
sychronized 关键字能成为锁的原因，是因为它提供了**内置锁（Intrinsic Lock）**机制，用于线程同步，确保同一时刻只有一个线程能够访问被标记为 synchronized 的代码
阅读更多2024-11-16
SpringBoot 2.2.10 无法执行Test单元测试
同样的Idea版本，现有的项目却可以执行，按照C老师的提示增加对junit5的引用支持，依然没有，StackOverflow上也是提示增加依赖，依赖加完之后执行报错一个 EnginListener N
阅读更多2024-11-16
springMVC 全局异常统一处理
进⾏异常处理，具有集成简单、有良好的扩展性、对已有代码没有⼊侵性等优点，但该⽅法仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适⽤。Unchecked Exception，⽽
阅读更多2024-11-16
thinkphp6配置多应用项目及多域名访问路由app配置
ThinkPHP 多应用模式初探
阅读更多2024-11-16