都9102年了还不懂动态图吗?一文带你了解飞桨动态图

导读:飞桨PaddlePaddle致力于让深度学习技术的创新与应用更简单。飞桨核心框架已提供了动态图(DyGraph)相关的API和文档,并且还附有Language model、Sentiment Classification、OCR、ResNet等模型的动态图版本官方实现。飞桨目前兼具了动态图和静态图的优势,同时具备灵活性和高效性。

飞桨动态图&静态图整体结构如下:

1. 动态图与静态图

目前深度学习框架主要有声明式编程和命令式编程两种编程方式。声明式编程,代码先描述要做的事情但不立即执行,对深度学习任务建模,需要事先定义神经网络的结构,然后再执行整个图结构,这一般称为静态图模式。而命令式编程对应的动态图模式,代码直接返回运算的结果,神经网络结构的定义和执行同步。通常来说,静态图模式能够对整体性做编译优化,更有利于性能的提升,而动态图则非常便于用户对程序进行调试。

2. 飞桨动态图的三大特色

飞桨的DyGraph模式是一种动态的图执行机制。与静态计算图的执行机制不同,DyGraph模式下的操作可以立即获得执行结果,而不必等待计算图全部构建完成。这样可以让开发者更加直观地构建深度学习任务并进行模型的调试,同时还减少了大量用于构建静态计算图的代码,使得编写、调试网络的过程变得非常便捷。

飞桨DyGraph动态图模式,主要有三大特色:

    灵活便捷的代码书写方式:能够使用Python的控制流(for,if…else..等)进行编程。 便捷的调试功能:直接使用Python的打印方法即时打印所需要的结果,从而检查正在运行的模型结果便于调试。 和静态执行图通用的模型代码:对于没有使用Python控制流的网络,动态图的代码可以直接在静态图模式下执行,提升执行的效率。


3. 飞桨动态图与静态图的直观对比

让我们通过一个实际例子,直观地感受一下动态图与静态图在使用过程中的差异。

想要实现如下的功能:

(1) 如果inp1各元素之和小于inp2各元素之和,那么执行inp1与 inp2各元素对应相加。

(2) 如果inp1各元素之和大于等于inp2各元素之和,那么执行inp1与 inp2各元素对应相减。

如果使用飞桨动态图来实现的话,代码如下:

import paddle.fluid asfluid
import numpy as np
inp1 = np.random.rand(4, 3, 3)
inp2 = np.random.rand(4, 3, 3)
# dynamic graph
with fluid.dygraph.guard():
    if np.sum(inp1) <np.sum(inp2):
        x =fluid.layers.elementwise_add(inp1, inp2)
    else:
        x =fluid.layers.elementwise_sub(inp1, inp2)
    dygraph_result = x.numpy()

在飞桨动态图的模式下,可以灵活复用(if…else…)等Python控制流操作,关键代码只需要短短6行,非常简单。

而如果换用静态图方式来实现的话,代码可就复杂多了。具体如下:

import paddle.fluid asfluid
import numpy as np
inp1 = np.random.rand(4, 3, 3)
inp2 = np.random.rand(4, 3, 3)
# static graph
with new_program_scope():
    inp_data1 =fluid.layers.data(name=inp1, shape=[3, 3], dtype=np.float32)
    inp_data2 =fluid.layers.data(name=inp2, shape=[3, 3], dtype=np.float32)
 
    a =fluid.layers.expand(fluid.layers.reshape(fluid.layers.reduce_sum(inp_data1),[1, 1]), [4, 1])
    b =fluid.layers.expand(fluid.layers.reshape(fluid.layers.reduce_sum(inp_data2),[1, 1]), [4, 1])
    cond =fluid.layers.less_than(x=a, y=b)
 
    ie =fluid.layers.IfElse(cond)
    with ie.true_block():
        d1 =ie.input(inp_data1)
        d2 =ie.input(inp_data2)
        d3 =fluid.layers.elementwise_add(d1, d2)
        ie.output(d3)
 
    with ie.false_block():
        d1 =ie.input(inp_data1)
        d2 =ie.input(inp_data2)
        d3 =fluid.layers.elementwise_sub(d1, d2)
        ie.output(d3)
    out = ie()
 
    exe =fluid.Executor(fluid.CPUPlace() if not core.is_compiled_with_cuda() elsefluid.CUDAPlace(0))
    static_result =exe.run(fluid.default_main_program(),feed={inp1: inp1,inp2:inp2},fetch_list=out)[0]

怎么样?感受到差异了吗?

直观一点,直接看代码行数。

关键代码部分,静态图方式的代码行数有20行,而动态图方式仅需要短短的6行代码。代码量减少到1/3,逻辑复杂程度也大大简化。

这就是飞桨动态图在Python控制流操作复用和代码简洁性方面的优势。

除此之外,飞桨动态图还提供了非常便捷的调试功能,直接使用Python的打印方法,就可以即时打印出所需要的结果,从而检查正在运行的模型结果,非常方便调试。

4. 飞桨动态图的基本用法

飞桨动态图具有如此多的优势,下面讲述最基本的一些用法。

(1) 动态图与静态图的最大区别是采用了命令式的编程方式,任务不用在区分组网阶段和执行阶段。代码运行完成之后,可以立马获取结果。由于采用与我们书写大部分Python和c++的方式是一致的命令式编程方式,程序的编写和调试会非常的容易。

(2) 同时动态图能够使用Python的控制流,例如for,if else, switch等,对于rnn等任务的支持更方便。

(3) 动态图能够与numpy更好的交互。

使用飞桨动态图,首先需要将PaddlePaddle升级到最新的1.5.1版本,使用以下命令即可。

pip install -q --upgrade paddlepaddle==1.5.1
import paddle.fluid as fluid
with fluid.dygraph.guard():

这样就可以在fluid.dygraph.guard()上下文环境中使用动态图DyGraph的模式运行网络了。DyGraph将改变以往静态图的执行方式,开始运行之后会立即执行,并且将计算结果返回给Python。

Dygraph非常适合和Numpy一起使用,使用fluid.dygraph.to_variable(x)将会将Numpy的ndarray转换为fluid.Variable,而使用fluid.Variable.numpy()将可以把任意时刻获取到的计算结果转换为Numpy ndarray,举例如下:

import paddle.fluid asfluid
import numpy as np
x = np.ones([10, 2, 2], np.float32)
 
with fluid.dygraph.guard():
     inputs = []
     seq_len = x.shape[0]
     for i in range(seq_len):
        inputs.append(fluid.dygraph.to_variable(x[i]))
     ret =fluid.layers.sums(inputs)
     print(ret.numpy())

得到输出:

[[10. 10.]
   [10. 10.]]           

以上代码根据输入x的第0维的长度、将x拆分为多个ndarray的输入,执行了一个sum操作之后,可以直接将运行的结果打印出来。然后通过调用reduce_sum后使用Variable.backward()方法执行反向,使用Variable.gradient()方法即可获得反向网络执行完成后的梯度值的ndarray形式:

loss =fluid.layers.reduce_sum(ret)
    loss.backward()
    print(loss.gradient())

得到输出 :

[1.]

5. 飞桨动态图的项目实战

下面以“手写数字识别”为例讲解一个动态图实战案例,手写体识别是一个非常经典的图像识别任务,任务中的图片如下图所示,根据一个28 * 28像素的图像,识别图片中的数字。

MNIST示例代码地址:

https://github.com/PaddlePaddle/models/tree/develop/dygraph/mnist

介绍网络训练的基本结构,也比较简单,两组conv2d和pool2d层,最后一个输出的全连接层。

飞桨动态图模式下搭建网络并训练模型的全过程主要包含以下内容:

5.1 数据准备

首先使用paddle.dataset.mnist作为训练所需要的数据集:飞桨把一些公开的数据集进行了封装,用户可以通过dataset.mnist接口直接调用mnist数据集,train()返回训练数据的reader,test()接口返回测试的数据的reader。

train_reader = paddle.batch(paddle.dataset.mnist.train(),batch_size=BATCH_SIZE, drop_last=True)

5.2 Layer定义

为了能够支持更复杂的网络搭建,动态图引入了Layer模块,每个Layer是一个独立的模块,Layer之间又可以互相嵌套。

Conv2D是飞桨提供的卷积运算的Layer,Pool2D是池化操作的Layer。

1)定义SimpleImgConvPool 子Layer:SimpleImgConvPool把网络中循环使用的部分进行整合,其中包含包含了两个子Layer,Conv2D和Pool2D,forward函数定义了前向运行时的结构。

class SimpleImgConvPool(fluid.dygraph.Layer)
    def __init__(self,name_scope, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type=max,global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1,act=None, use_cudnn=False, param_attr=None, bias_attr=None):
         super(SimpleImgConvPool,self).__init__(name_scope)
         self._conv2d =fluid.dygraph.Conv2D(self.full_name(), num_filters=num_filters, filter_size=filter_size,stride=conv_stride,padding=conv_padding, dilation=conv_dilation, groups=conv_groups,aram_attr=None, bias_attr=None, act=act, use_cudnn=use_cudnn)
         self._pool2d =fluid.dygraph.Pool2D(self.full_name(), pool_size=pool_size, pool_type=pool_type,pool_stride=pool_stride, pool_padding=pool_padding, global_pooling=global_pooling,use_cudnn=use_cudnn)
    def forward(self,inputs):
         x =self._conv2d(inputs)
         x = self._pool2d(x)
         return x 

2)构建MNIST Layer,MNIST Layes包含了两个SimpleImgConvPool子Layer,以及一个FC(全连接层),forward函数定义了如图2所示得网络结构

class MNIST(fluid.dygraph.Layer):
    def __init__(self,name_scope):
        super(MNIST,self).__init__(name_scope)
        self._simple_img_conv_pool_1 = SimpleImgConvPool(self.full_name(), 20,5, 2, 2, act="relu")
        self._simple_img_conv_pool_2 = SimpleImgConvPool(self.full_name(), 50,5, 2, 2, act="relu")
        pool_2_shape = 50 *4 * 4
        SIZE = 10
        scale = (2.0 / (pool_2_shape**2 *SIZE))**0.5
        self._fc =fluid.dygraph.FC(self.full_name(),10, param_attr=fluid.param_attr.ParamAttr(initializer=fluid.initializer.NormalInitializer(loc=0.0, scale=scale)),act="softmax")
    def forward(self, inputs,label=None):
        x =self._simple_img_conv_pool_1(inputs)
        x =self._simple_img_conv_pool_2(x)
        x = self._fc(x)
        if label is notNone:
            acc =fluid.layers.accuracy(input=x, label=label)
            return x, acc
        else:
            return x

5.3 优化器定义

使用经典的Adam优化算法:

adam =fluid.optimizer.AdamOptimizer(learning_rate=0.001)

5.4 训练

构建训练循环,顺序为:1).从reader读取数据 2).调用MNIST Layer 前向网络3).利用cross_entropy计算loss 4)调用backward计算梯度 5)调用adam.minimize更新梯度,6) clear_gradients()将梯度设置为0(这种方案是为了支持backward of backward功能,如果系统自动将梯度置为0,则无法使用backward of backward功能)

with fluid.dygraph.guard():
    epoch_num = 5
    BATCH_SIZE = 64
 
    mnist =MNIST("mnist")
    adam =fluid.optimizer.AdamOptimizer(learning_rate=0.001)
    train_reader =paddle.batch(paddle.dataset.mnist.train(), batch_size= BATCH_SIZE,drop_last=True)
 
    np.set_printoptions(precision=3,suppress=True)
    for epoch inrange(epoch_num):
        for batch_id, data inenumerate(train_reader()):
            dy_x_data = np.array(
               [x[0].reshape(1, 28, 28)
                 for x indata]).astype(float32)
            y_data =np.array(
                [x[1] for xin data]).astype(int64).reshape(BATCH_SIZE, 1)
             img =fluid.dygraph.to_variable(dy_x_data)
            label =fluid.dygraph.to_variable(y_data)
            label.stop_gradient = True
           cost =mnist(img)
           loss =fluid.layers.cross_entropy(cost, label)
           avg_loss =fluid.layers.mean(loss)
           dy_out =avg_loss.numpy()
           avg_loss.backward()
           adam.minimize(avg_loss)
           mnist.clear_gradients()
           dy_param_value ={}
           for param inmnist.parameters():
               dy_param_value[param.name] = param.numpy()
           if batch_id % 20== 0:
               print("Loss at step {}: {}".format(batch_id,avg_loss.numpy()))

5.5 预测

预测的目标是为了在训练的同时,了解一下在开发集上模型的表现情况,由于动态图的训练和预测使用同一个Layer,有一些op(比如dropout)在训练和预测时表现不一样,用户需要切换到预测的模式,通过 .eval()接口进行切换(注:训练的时候需要切回到训练的模式)

预测代码如下图所示:

def test_mnist(reader, model, batch_size):
    acc_set = []
    avg_loss_set = []
    for batch_id, data in enumerate(reader()):
       dy_x_data = np.array([x[0].reshape(1, 28, 28) for x indata]).astype(float32)
       y_data = np.array([x[1] for x indata]).astype(int64).reshape(batch_size, 1)
       img = to_variable(dy_x_data)
       label = to_variable(y_data)
       label.stop_gradient = True
       prediction, acc = model(img, label)
       loss = fluid.layers.cross_entropy(input=prediction, label=label)
       avg_loss = fluid.layers.mean(loss)
       acc_set.append(float(acc.numpy()))
       avg_loss_set.append(float(avg_loss.numpy()))
       # get test acc and loss
   acc_val_mean = np.array(acc_set).mean()
   avg_loss_val_mean = np.array(avg_loss_set).mean()
   return avg_loss_val_mean, acc_val_mean

最终可以通过打印数据自行绘制Loss曲线:

5.6 调试

调试是我们在搭建网络时候非常重要的功能,动态图由于是命令式编程,用户可以直接利用python的print打印变量,通过print( tensor.numpy() ) 直接打印tensor的值。在执行了backward之后,用户可以通过print(tensor.gradient) 打印反向的梯度值。

这样,一个简单的动态图的实例就完成了,亲爱的开发者们,你们学会了么?

想了解更多内容:

    官网地址:https://www.paddlepaddle.org.cn/ 动态图代码地址: https://github.com/PaddlePaddle/models/tree/v1.5.1/dygraph
导读:飞桨PaddlePaddle致力于让深度学习技术的创新与应用更简单。飞桨核心框架已提供了动态图(DyGraph)相关的API和文档,并且还附有Language model、Sentiment Classification、OCR、ResNet等模型的动态图版本官方实现。飞桨目前兼具了动态图和静态图的优势,同时具备灵活性和高效性。 飞桨动态图&静态图整体结构如下: 1. 动态图与静态图 目前深度学习框架主要有声明式编程和命令式编程两种编程方式。声明式编程,代码先描述要做的事情但不立即执行,对深度学习任务建模,需要事先定义神经网络的结构,然后再执行整个图结构,这一般称为静态图模式。而命令式编程对应的动态图模式,代码直接返回运算的结果,神经网络结构的定义和执行同步。通常来说,静态图模式能够对整体性做编译优化,更有利于性能的提升,而动态图则非常便于用户对程序进行调试。 2. 飞桨动态图的三大特色 飞桨的DyGraph模式是一种动态的图执行机制。与静态计算图的执行机制不同,DyGraph模式下的操作可以立即获得执行结果,而不必等待计算图全部构建完成。这样可以让开发者更加直观地构建深度学习任务并进行模型的调试,同时还减少了大量用于构建静态计算图的代码,使得编写、调试网络的过程变得非常便捷。 飞桨DyGraph动态图模式,主要有三大特色: 灵活便捷的代码书写方式:能够使用Python的控制流(for,if…else..等)进行编程。 便捷的调试功能:直接使用Python的打印方法即时打印所需要的结果,从而检查正在运行的模型结果便于调试。 和静态执行图通用的模型代码:对于没有使用Python控制流的网络,动态图的代码可以直接在静态图模式下执行,提升执行的效率。 3. 飞桨动态图与静态图的直观对比 让我们通过一个实际例子,直观地感受一下动态图与静态图在使用过程中的差异。 想要实现如下的功能: (1) 如果inp1各元素之和小于inp2各元素之和,那么执行inp1与 inp2各元素对应相加。 (2) 如果inp1各元素之和大于等于inp2各元素之和,那么执行inp1与 inp2各元素对应相减。 如果使用飞桨动态图来实现的话,代码如下: import paddle.fluid asfluid import numpy as np inp1 = np.random.rand(4, 3, 3) inp2 = np.random.rand(4, 3, 3) # dynamic graph with fluid.dygraph.guard(): if np.sum(inp1)
经验分享 程序员 微信小程序 职场和发展