百度PGL-动态图模式(命令式编程)

import paddle

# 定义批大小
BATCH_SIZE = 64

# 通过调用paddle.dataset.mnist的train函数和test函数来构造reader
train_reader = paddle.batch(
    paddle.dataset.mnist.train(), batch_size=BATCH_SIZE, drop_last=True)
test_reader = paddle.batch(
    paddle.dataset.mnist.test(), batch_size=BATCH_SIZE, drop_last=True)

Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-images-idx3-ubyte.gz
Begin to download

Download finished
Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-labels-idx1-ubyte.gz
Begin to download
........
Download finished
Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-images-idx3-ubyte.gz
Begin to download

Download finished
Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-labels-idx1-ubyte.gz
Begin to download
..
Download finished

import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D

# 定义SimpleImgConvPool网络，必须继承自fluid.dygraph.Layer
# 该网络由一个卷积层和一个池化层组成
class SimpleImgConvPool(fluid.dygraph.Layer):
    # 在__init__构造函数中会执行变量的初始化、参数初始化、子网络初始化的操作
    # 本例中执行了Conv2D和Pool2D网络的初始化操作
    def __init__(self,
                 num_channels,
                 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__()

        # Conv2D网络的初始化
        self._conv2d = Conv2D(
            num_channels=num_channels,
            num_filters=num_filters,
            filter_size=filter_size,
            stride=conv_stride,
            padding=conv_padding,
            dilation=conv_dilation,
            groups=conv_groups,
            param_attr=None,
            bias_attr=None,
            act=act,
            use_cudnn=use_cudnn)

        # Pool2D网络的初始化
        self._pool2d = Pool2D(
            pool_size=pool_size,
            pool_type=pool_type,
            pool_stride=pool_stride,
            pool_padding=pool_padding,
            global_pooling=global_pooling,
            use_cudnn=use_cudnn)

    # forward函数实现了SimpleImgConvPool网络的执行逻辑
    def forward(self, inputs):
        x = self._conv2d(inputs)
        x = self._pool2d(x)
        return x


可以看出实现一个 ConvPool 层（即SimpleImgConvPool）分为两个步骤：

定义 __init__ 构造函数。
在 __init__ 构造函数中，通常会执行变量初始化、参数初始化、子网络初始化等操作，执行这些操作时不依赖于输入的动态信息。这里我们对子网络（卷积层和池化层）做了初始化操作。

定义 forward 函数。
该函数负责定义网络运行时的执行逻辑，将会在每一轮训练/预测中被调用。上述示例中，forward 函数的逻辑是先执行一个卷积操作，然后执行一个池化操作。

接下来我们介绍如何利用子网络组合出MNIST网络，该网络由两个 SimpleImgConvPool 子网络和一个全连接层组成。

# 定义MNIST网络，必须继承自fluid.dygraph.Layer
# 该网络由两个SimpleImgConvPool子网络、reshape层、matmul层、softmax层、accuracy层组成
class MNIST(fluid.dygraph.Layer):
    # 在__init__构造函数中会执行变量的初始化、参数初始化、子网络初始化的操作
    # 本例中执行了self.pool_2_shape变量、matmul层中参数self.output_weight、SimpleImgConvPool子网络的初始化操作
    def __init__(self):
        super(MNIST, self).__init__()
        self._simple_img_conv_pool_1 = SimpleImgConvPool(
            1, 20, 5, 2, 2, act="relu")
        self._simple_img_conv_pool_2 = SimpleImgConvPool(
            20, 50, 5, 2, 2, act="relu")

        # self.pool_2_shape变量定义了经过self._simple_img_conv_pool_2层之后的数据
        # 除了batch_size维度之外其他维度的乘积
        self.pool_2_shape = 50 * 4 * 4
        # self.pool_2_shape、SIZE定义了self.output_weight参数的维度
        SIZE = 10
        # 定义全连接层的参数
        self.output_weight = self.create_parameter(
            [self.pool_2_shape, 10])

    # forward函数实现了MNIST网络的执行逻辑
    def forward(self, inputs, label=None):
        x = self._simple_img_conv_pool_1(inputs)
        x = self._simple_img_conv_pool_2(x)
        x = fluid.layers.reshape(x, shape=[-1, self.pool_2_shape])
        x = fluid.layers.matmul(x, self.output_weight)
        x = fluid.layers.softmax(x)
        if label is not None:
            acc = fluid.layers.accuracy(input=x, label=label)
            return x, acc
        else:
            return x

import numpy as np
from paddle.fluid.optimizer import AdamOptimizer
from paddle.fluid.dygraph.base import to_variable

with fluid.dygraph.guard():
    # 定义MNIST类的对象
    mnist = MNIST()
    # 定义优化器为AdamOptimizer，学习旅learning_rate为0.001
    # 注意动态图模式下必须传入parameter_list参数，该参数为需要优化的网络参数，本例需要优化mnist网络中的所有参数
    adam = AdamOptimizer(learning_rate=0.001, parameter_list=mnist.parameters())

import numpy as np
from paddle.fluid.optimizer import AdamOptimizer
from paddle.fluid.dygraph.base import to_variable

with fluid.dygraph.guard():
    # 定义MNIST类的对象
    mnist = MNIST()
    # 定义优化器为AdamOptimizer，学习旅learning_rate为0.001
    # 注意动态图模式下必须传入parameter_list参数，该参数为需要优化的网络参数，本例需要优化mnist网络中的所有参数
    adam = AdamOptimizer(learning_rate=0.001, parameter_list=mnist.parameters())

    # 设置全部样本的训练次数
    epoch_num = 5

    # 执行epoch_num次训练
    for epoch in range(epoch_num):
        # 读取训练数据进行训练
        for batch_id, data in enumerate(train_reader()):
            dy_x_data = np.array([x[0].reshape(1, 28, 28) for x in data]).astype('float32')
            y_data = np.array([x[1] for x in data]).astype('int64').reshape(-1, 1)

            #将ndarray类型的数据转换为Variable类型
            img = to_variable(dy_x_data)
            label = to_variable(y_data)

            # 网络正向执行
            cost, acc = mnist(img, label)

            # 计算损失值
            loss = fluid.layers.cross_entropy(cost, label)
            avg_loss = fluid.layers.mean(loss)
            # 执行反向计算
            avg_loss.backward()
            # 参数更新
            adam.minimize(avg_loss)
            # 将本次计算的梯度值清零，以便进行下一次迭代和梯度更新
            mnist.clear_gradients()

            # 输出对应epoch、batch_id下的损失值
            if batch_id % 100 == 0:
                print("Loss at epoch {} step {}: {:}".format(
                    epoch, batch_id, avg_loss.numpy()))

    # 保存训练好的模型
    model_dict = mnist.state_dict()
    fluid.save_dygraph(model_dict, "save_temp")

Loss at epoch 0 step 0: [3.362183]
Loss at epoch 0 step 100: [0.20108832]
Loss at epoch 0 step 200: [0.1681692]
Loss at epoch 0 step 300: [0.11894853]
Loss at epoch 0 step 400: [0.13005154]
Loss at epoch 0 step 500: [0.10004535]
Loss at epoch 0 step 600: [0.11465541]
Loss at epoch 0 step 700: [0.14584845]
Loss at epoch 0 step 800: [0.21515566]
Loss at epoch 0 step 900: [0.13847716]
Loss at epoch 1 step 0: [0.03004131]
Loss at epoch 1 step 100: [0.1855965]
Loss at epoch 1 step 200: [0.07302501]
Loss at epoch 1 step 300: [0.02016284]
Loss at epoch 1 step 400: [0.03899964]
Loss at epoch 1 step 500: [0.05415711]
Loss at epoch 1 step 600: [0.09633664]
Loss at epoch 1 step 700: [0.07155745]
Loss at epoch 1 step 800: [0.13023862]
Loss at epoch 1 step 900: [0.09051394]
Loss at epoch 2 step 0: [0.00580437]
Loss at epoch 2 step 100: [0.1506507]
Loss at epoch 2 step 200: [0.03713503]
Loss at epoch 2 step 300: [0.01145383]
Loss at epoch 2 step 400: [0.0497771]

model.eval()      #切换到评估模式
model.train()     #切换到训练模式

with fluid.dygraph.guard():
    # 定义MNIST类的对象
    mnist_eval = MNIST()

    # 加载保存的模型
    model_dict, _ = fluid.load_dygraph("save_temp")
    mnist_eval.set_dict(model_dict)
    print("checkpoint loaded")

    # 切换到预测评估模式
    mnist_eval.eval()

    acc_set = []
    avg_loss_set = []
    # 读取测试数据进行评估测试
    for batch_id, data in enumerate(test_reader()):
        dy_x_data = np.array([x[0].reshape(1, 28, 28)
                              for x in data]).astype('float32')
        y_data = np.array(
            [x[1] for x in data]).astype('int64').reshape(-1, 1)

        # 将ndarray类型的数据转换为Variable类型
        img = to_variable(dy_x_data)
        label = to_variable(y_data)

        # 网络正向执行
        prediction, acc = mnist_eval(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()))

    # 输出不同 batch 数据下损失值和准确率的平均值
    acc_val_mean = np.array(acc_set).mean()
    avg_loss_val_mean = np.array(avg_loss_set).mean()
    print("Eval avg_loss is: {}, acc is: {}".format(avg_loss_val_mean, acc_val_mean))

# 保存模型参数
1. fluid.save_dygraph(minist.state_dict(), “save_path”)
# 保存优化器信息
2. fluid.save_dygraph(adam.state_dict(), “save_path”)

# 获取模型参数和优化器信息
1. model_state, opt_state= fluid.load_dygraph(“save_path”)
# 加载模型参数
2. mnist.set_dict(model_state)
# 加载优化器信息
3. adam.set_dict(opt_state)

x = y * 10
print(x.numpy())

x = y * 10
x.backward()
print(y.gradient())

# 设置全部样本训练次数（epoch_num）、批大小（BATCH_SIZE）。
epoch_num = 1
BATCH_SIZE = 64

main_program = fluid.Program()
startup_program = fluid.Program()

with fluid.program_guard(main_program=main_program, startup_program=startup_program):
    # 静态图中需要使用执行器执行之前已经定义好的网络
    exe = fluid.Executor(fluid.CPUPlace())

    # 定义MNIST类的对象，可以使用动态图定义好的网络结构
    mnist_static = MNIST()
    # 定义优化器对象，静态图模式下不需要传入parameter_list参数
    sgd_static = fluid.optimizer.SGDOptimizer(learning_rate=1e-3)

    # 通过调用paddle.dataset.mnist的train函数，直接获取处理好的MNIST训练集
    train_reader = paddle.batch(
        paddle.dataset.mnist.train(), batch_size=BATCH_SIZE, drop_last=True)

    # 静态图需要明确定义输入变量，即“占位符”，在静态图组网阶段并没有读入数据，所以需要使用占位符指明输入数据的类型，shape等信息
    img_static = fluid.data(
        name='pixel', shape=[None, 1, 28, 28], dtype='float32')
    label_static = fluid.data(name='label', shape=[None, 1], dtype='int64')

    # 调用网络，执行前向计算
    cost_static = mnist_static(img_static)
    # 计算损失值
    loss_static = fluid.layers.cross_entropy(cost_static, label_static)
    avg_loss_static = fluid.layers.mean(loss_static)

    # 调用优化器的minimize接口计算和更新梯度
    sgd_static.minimize(avg_loss_static)

    # 静态图中需要显示对网络进行初始化操作
    exe.run(fluid.default_startup_program())

    for epoch in range(epoch_num):
        for batch_id, data in enumerate(train_reader()):
            x_data_static = np.array(
                [x[0].reshape(1, 28, 28)
                for x in data]).astype('float32')
            y_data_static = np.array(
                [x[1] for x in data]).astype('int64').reshape([BATCH_SIZE, 1])

            fetch_list = [avg_loss_static.name]
            # 静态图中需要调用执行器的run方法执行计算过程，需要获取的计算结果（如avg_loss）需要通过fetch_list指定
            out = exe.run(
                fluid.default_main_program(),
                feed={"pixel": x_data_static,
                    "label": y_data_static},
                fetch_list=fetch_list)

            static_out = out[0]

            if batch_id % 100 == 0 and batch_id is not 0:
                print("epoch: {}, batch_id: {}, loss: {}".format(epoch, batch_id, static_out))

fw_out = fw_out.detach()

import paddle.fluid as fluid
import numpy as np

with fluid.dygraph.guard():
    value0 = np.arange(26).reshape(2, 13).astype("float32")
    value1 = np.arange(6).reshape(2, 3).astype("float32")
    value2 = np.arange(10).reshape(2, 5).astype("float32")

    # 将ndarray类型的数据转换为Variable类型
    a = fluid.dygraph.to_variable(value0)
    b = fluid.dygraph.to_variable(value1)
    c = fluid.dygraph.to_variable(value2)

    # 构造fc、fc2层
    fc = fluid.Linear(13, 5, dtype="float32")
    fc2 = fluid.Linear(3, 3, dtype="float32")

    # 对fc、fc2层执行前向计算
    out1 = fc(a)
    out2 = fc2(b)

    # 将不会对out1这部分子图做反向计算
    out1 = out1.detach()

    out = fluid.layers.concat(input=[out1, out2, c], axis=1)
    out.backward()

    # 可以发现这里out1.gradient()的值都为0，同时使得fc.weight的grad没有初始化
    assert (out1.gradient() == 0).all()

fw_out.stop_gradient = True

import paddle.fluid as fluid
import numpy as np

with fluid.dygraph.guard():
    value0 = np.arange(26).reshape(2, 13).astype("float32")
    value1 = np.arange(6).reshape(2, 3).astype("float32")
    value2 = np.arange(10).reshape(2, 5).astype("float32")

    # 将ndarray类型的数据转换为Variable类型
    a = fluid.dygraph.to_variable(value0)
    b = fluid.dygraph.to_variable(value1)
    c = fluid.dygraph.to_variable(value2)

    # 构造fc、fc2层
    fc = fluid.Linear(13, 5, dtype="float32")
    fc2 = fluid.Linear(3, 3, dtype="float32")

    # 对fc、fc2层执行前向计算
    out1 = fc(a)
    out2 = fc2(b)

    # 相当于不会对out1这部分子图做反向计算
    out1.stop_gradient = True

    out = fluid.layers.concat(input=[out1, out2, c], axis=1)
    out.backward()

    # 可以发现这里fc参数的梯度都为0
    assert (fc.weight.gradient() == 0).all()
    assert (out1.gradient() == 0).all()