一、__xxx__形式的魔法方法
我们可以经常在python代码片段中看到类的定义,其中第一个被定义的方法往往是__init__,如下所示:
python
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设计的一种特殊方法,它别称为魔法方法,它可以被运算符隐式调用,下面给出示例:
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__方法,它能通过以下方式被直接调用:
python
test=Accumulator(3)
test.__call__(param)
test(param)
'''两者等价'''
示例如下:
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 __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__两个方法
python
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,这是一个包含多个层的类,可以按顺序执行一系列函数
如上的多层感知机,我就可以这样定义:
python
net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
X=torch.arange(20.0)
print(net(X))
事实上,其源码的形式如下所示:
python
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块类添加层,其中第一个参数是层的名称,第二个参数是层的类型。
python
net=nn.Sequential(nn.Linear(20,256))
net.add_module("mylayer",nn.Linear(256,10))
直接打印net可以查看整个Sequential块的组成情况:
python
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类,可以使用类似数组下标访问的方法来访问其每一层:
python
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]中的各个参数:
python
net=nn.Sequential(nn.Linear(20,256),nn.Linear(256,10))
print(net[0].state_dict())
一般,nn.Linear结构中的参数包括weight和bias,即权重和偏置,可以用.运算符访问:
python
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,可以如下进行访问和设置
python
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、嵌套结构
python
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下带有的方法将参数初始化。
python
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_方法可以将参数置为某个常数。
python
nn.init.zeros_(m.weight)
nn.init.constant_(m.weight,1.0) #将weight向量全置为1
而nn.init.uniform_方法,可以使参数均匀分布。其第一个参数还是需要初始化的tensor向量,a代表均匀分布的下界(默认为0.0),b代表上界(默认为1.0)
python
nn.init.uniform_(m.weight,a=0.0,b=2.0)
对块net使用apply方法,可以让自定义初始化函数在所有层上作用一遍。
python
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,就可以知晓其运作的规律:
python
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)
)