Pytorch 学习笔记之自定义 Module

pytorch 是一个基于 python 的深度学习库。pytorch 源码库的抽象层次少,结构清晰,代码量适中。相比于非常工程化的 tensorflow,pytorch 是一个更易入手的,非常棒的深度学习框架。

对于系统学习 pytorch,官方提供了非常好的入门教程 ,同时还提供了面向深度学习的示例,同时热心网友分享了更简洁的示例

1. overview

不同于 theano,tensorflow 等低层程序库,或者 keras、sonnet 等高层 wrapper,pytorch 是一种自成体系的深度学习库(图1)。

图1. 几种深度学习程序库对比

如图2所示,pytorch 由低层到上层主要有三大块功能模块。

图2. pytorch 主要功能模块

1.1 张量计算引擎(tensor computation)

Tensor 计算引擎,类似 numpy 和 matlab,基本对象是tensor(类比 numpy 中的 ndarray 或 matlab 中的 array)。除提供基于 CPU 的常用操作的实现外,pytorch 还提供了高效的 GPU 实现,这对于深度学习至关重要。

1.2 自动求导机制(autograd)

由于深度学习模型日趋复杂,因此,对自动求导的支持对于学习框架变得必不可少。pytorch 采用了动态求导机制,使用类似方法的框架包括: chainer,dynet。作为对比,theano,tensorflow 采用静态自动求导机制。

1.3 神经网络的高层库(NN)

pytorch 还提供了高层的神经网络模块。对于常用的网络结构,如全连接、卷积、RNN 等。同时,pytorch 还提供了常用的目标函数optimizer 及参数初始化方法

这里,我们重点关注如何自定义神经网络结构。

2. 自定义 Module

图3. pytorch Module

module 是 pytorch 组织神经网络的基本方式。Module 包含了模型的参数以及计算逻辑。Function 承载了实际的功能,定义了前向和后向的计算逻辑。

下面以最简单的 MLP 网络结构为例,介绍下如何实现自定义网络结构。完整代码可以参见repo

2.1 Function

Function 是 pytorch 自动求导机制的核心类。Function 是无参数或者说无状态的,它只负责接收输入,返回相应的输出;对于反向,它接收输出相应的梯度,返回输入相应的梯度。

这里我们只关注如何自定义 Function。Function 的定义见源码。下面是简化的代码段:

class Function(object):
    def forward(self, *input):
        raise NotImplementedError

    def backward(self, *grad_output):
        raise NotImplementedError

forward 和 backward 的输入和输出都是 Tensor 对象。

Function 对象是 callable 的,即可以通过()的方式进行调用。其中调用的输入和输出都为 Variable 对象。下面的代码示例了如何实现一个 ReLU 激活函数并进行调用:

import torch
from torch.autograd import Function

class ReLUF(Function):
    def forward(self, input):
        self.save_for_backward(input)

        output = input.clamp(min=0)
        return output

    def backward(self, output_grad):
        input = self.to_save[0]

        input_grad = output_grad.clone()
        input_grad[input < 0] = 0
        return input_grad

## Test
if __name__ == "__main__":
      from torch.autograd import Variable

      torch.manual_seed(1111)  
      a = torch.randn(2, 3)

      va = Variable(a, requires_grad=True)
      vb = ReLUF()(va)
      print va.data, vb.data

      vb.backward(torch.ones(va.size()))
      print vb.grad.data, va.grad.data

如果 backward 中需要用到 forward 的输入,需要在 forward 中显式的保存需要的输入。在上面的代码中,forward 利用self.save_for_backward函数,将输入暂时保存,并在 backward 中利用saved_tensors (python tuple 对象) 取出。

显然,forward 的输入应该和 backward 的输入相对应;同时,forward 的输出应该和 backward 的输入相匹配。

由于 Function 可能需要暂存 input tensor,因此,建议不复用 Function 对象,以避免遇到内存提前释放的问题。如示例代码所示,forward的每次调用都重新生成一个 ReLUF 对象,而不能在初始化时生成在 forward 中反复调用。

2.2 Module

类似于 Function,Module 对象也是 callable 是,输入和输出也是 Variable。不同的是,Module 是[可以]有参数的。Module 包含两个主要部分:参数及计算逻辑(Function 调用)。由于ReLU激活函数没有参数,这里我们以最基本的全连接层为例来说明如何自定义Module。

全连接层的运算逻辑定义如下 Function:

import torch
from torch.autograd import Function

class LinearF(Function):

     def forward(self, input, weight, bias=None):
         self.save_for_backward(input, weight, bias)

         output = torch.mm(input, weight.t())
         if bias is not None:
             output += bias.unsqueeze(0).expand_as(output)

         return output

     def backward(self, grad_output):
         input, weight, bias = self.saved_tensors

         grad_input = grad_weight = grad_bias = None
         if self.needs_input_grad[0]:
             grad_input = torch.mm(grad_output, weight)
         if self.needs_input_grad[1]:
             grad_weight = torch.mm(grad_output.t(), input)
         if bias is not None and self.needs_input_grad[2]:
             grad_bias = grad_output.sum(0).squeeze(0)

         if bias is not None:
             return grad_input, grad_weight, grad_bias
         else:
             return grad_input, grad_weight

needs_input_grad 为一个元素为 bool 型的 tuple,长度与 forward 的参数数量相同,用来标识各个输入是否输入计算梯度;对于无需梯度的输入,可以减少不必要的计算。

Function(此处为 LinearF) 定义了基本的计算逻辑,Module 只需要在初始化时为参数分配内存空间,并在计算时,将参数传递给相应的 Function 对象。代码如下:

import torch
import torch.nn as nn

class Linear(nn.Module):

    def __init__(self, in_features, out_features, bias=True):
         super(Linear, self).__init__()
         self.in_features = in_features
         self.out_features = out_features
         self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
         if bias:
             self.bias = nn.Parameter(torch.Tensor(out_features))
         else:
            self.register_parameter('bias', None)

    def forward(self, input):
         return LinearF()(input, self.weight, self.bias)

需要注意的是,参数是内存空间由 tensor 对象维护,但 tensor 需要包装为一个Parameter 对象。Parameter 是 Variable 的特殊子类,仅有是不同是 Parameter 默认requires_grad为 True。Varaible 是自动求导机制的核心类,此处暂不介绍,参见教程

3. 自定义循环神经网络(RNN)

我们尝试自己定义一个更复杂的 Module ——RNN。这里,我们只定义最基础的 vanilla RNN(图4),基本的计算公式如下:

ht=relu(W⋅x+U⋅ht−1)

图4. RNN【来源】

更复杂的 LSTM、GRU 或者其他变种的实现也非常类似。

3.1 定义 Cell

import torch
from torch.nn import Module, Parameter

class RNNCell(Module):
    def __init__(self, input_size, hidden_size):
        super(RNNCell, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size

        self.weight_ih = Parameter(torch.Tensor(hidden_size, input_size))
        self.weight_hh = Parameter(torch.Tensor(hidden_size, hidden_size))
        self.bias_ih = Parameter(torch.Tensor(hidden_size))
        self.bias_hh = Parameter(torch.Tensor(hidden_size))

        self.reset_parameters()

    def reset_parameters(self):
        stdv = 1.0 / math.sqrt(self.hidden_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, stdv)

    def forward(self, input, h):
        output = LinearF()(input, self.weight_ih, self.bias_ih) + LinearF()(h, self.weight_hh, self.bias_hh)
        output = ReLUF()(output)

        return output

3.2 定义完整的 RNN

import torch
from torch.nn import Module

class RNN(Moudule):
    def __init__(self, input_size, hidden_size):
        super(RNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size

        sef.cell = RNNCell(input_size, hidden_size)

    def forward(self, inputs, initial_state):
        time_steps = inputs.size(1)

        state = initial_state
        outputs = []
        for t in range(time_steps):
            state = self.cell(inputs[:, t, :], state)
            outputs.append(state)

        return outputs

可运行的完整代码见repo

讨论

pytorch 的 Module 结构是传承自 torch,这一点也同样被 keras (functional API)所借鉴。 在 caffe 等一些[早期的]深度学习框架中,network 是由于若干 layer ,经由不同的拓扑结构组成的。而在 (pyt)torch 中没有 layer 和 network 是区分,一切都是 callable 的 Module。Module 的调用的输入和输出都是 tensor (由 Variable 封装),用户可以非常自然的构造任意有向无环的网络结构(DAG)。

同时, pytorch 的 autograd 机制封装的比较浅,可以比较容易的定制反传或修改梯度。这对有些算法是非常重要。

总之,仅就自定义算法而言,pytorch 是一个非常优雅的深度学习框架。

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏陈仁松博客

ASP.NET Core 'Microsoft.Win32.Registry' 错误修复

今天在发布Asp.net Core应用到Azure的时候出现错误InvalidOperationException: Cannot find compilati...

5208
来自专栏跟着阿笨一起玩NET

c#实现打印功能

3572
来自专栏芋道源码1024

熔断器 Hystrix 源码解析 —— 断路器 HystrixCircuitBreaker

本文主要基于 Hystrix 1.5.X 版本 1. 概述 2. HystrixCircuitBreaker 3. HystrixCircuitBreaker....

5697
来自专栏闻道于事

js登录滑动验证,不滑动无法登陆

js的判断这里是根据滑块的位置进行判断,应该是用一个flag判断 <%@ page language="java" contentType="text/html...

8358
来自专栏张善友的专栏

LINQ via C# 系列文章

LINQ via C# Recently I am giving a series of talk on LINQ. the name “LINQ via C...

2965
来自专栏一个会写诗的程序员的博客

Spring Reactor 项目核心库Reactor Core

Non-Blocking Reactive Streams Foundation for the JVM both implementing a Reactiv...

2722
来自专栏我和未来有约会

Kit 3D 更新

Kit3D is a 3D graphics engine written for Microsoft Silverlight. Kit3D was inita...

2886
来自专栏菩提树下的杨过

Flash/Flex学习笔记(23):运动学原理

先写一个公用的小球类Ball: package{ import flash.display.Sprite; //小球 类 public class B...

27110
来自专栏码匠的流水账

聊聊NettyConnector的start及shutdown

reactor-netty-0.7.6.RELEASE-sources.jar!/reactor/ipc/netty/NettyConnector.java

1021
来自专栏转载gongluck的CSDN博客

cocos2dx 打灰机

#include "GamePlane.h" #include "PlaneSprite.h" #include "BulletNode.h" #include...

6886

扫码关注云+社区