飞桨（Paddlepaddle）的动态图、静态图全流程例子

前言

本文主要记录一下，使用飞桨（Paddlepaddle）进行模型训练、评估、测试的用法，作为以后的备忘录。

数据

本次实验的数据是使用MNIST，这个数据相当于图像识别领域的Helloworld。加载方式是使用paddle的方式来加载。
Python版本：3.7
Paddle版本：1.8.5
注意：使用2.0以上的Paddle，使用静态图时需要加入一句paddle.enable_static()

动态图

训练

导入要用到的包

import paddle
from paddle import fluid
from paddle.dataset import mnist
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np

以Layer类的形式构建神经网络

class Network(fluid.Layer):
    def __init__(self):
        super(Network, self).__init__()
        self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5) # n, 20, 24, 24
        self.pool1 = Pool2D(pool_size=2, pool_stride=2) # n, 20, 12, 12
        self.conv2 = Conv2D(num_channels=20, num_filters=30, filter_size=5) # n, 30, 8, 8
        self.pool2 = Pool2D(pool_size=2, pool_stride=2) # n, 30, 4, 4
        self.fc1 = Linear(input_dim=30*4*4, output_dim=1024)
        self.fc2 = Linear(input_dim=1024, output_dim=10)
    def forward(self, inputs):
        x = self.conv1(inputs)
        x = self.pool1(x)
        x = fluid.layers.tanh(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = fluid.layers.tanh(x)
        x = fluid.layers.reshape(x, (x.shape[0], -1))
        x = self.fc1(x)
        x = fluid.layers.dropout(x, 0.5)
        x = self.fc2(x)
        return x

训练过程以及保存动态图模型，保存使用save_dygraph方法。

with fluid.dygraph.guard():
    model = Network()
    opt = fluid.optimizer.Adam(learning_rate=0.001, parameter_list=model.parameters())
    train_loader = paddle.batch(mnist.train(), batch_size=1000)
    test_loader = paddle.batch(mnist.test(), batch_size=1000)
    losses_train = []
    acces_train = []
    for epoch_i in range(2):
        model.train()
        for batch_i, batch_data in enumerate(train_loader()):
            x = np.array([d[0] for d in batch_data], dtype='float32').reshape(-1, 1, 28, 28)
            y = np.array([d[1] for d in batch_data], dtype='int64').reshape(-1, 1)
            input_x = fluid.dygraph.to_variable(x)
            output_y = fluid.dygraph.to_variable(y)
            logit_y = model(input_x)
            loss = fluid.layers.softmax_with_cross_entropy(logit_y, output_y)
            loss = fluid.layers.mean(loss)
            acc = fluid.layers.accuracy(logit_y, output_y)
            losses_train.append(loss.numpy())
            acces_train.append(acc.numpy())
            loss.backward()
            opt.minimize(loss)
            model.clear_gradients()
            print('on train', epoch_i, batch_i, losses_train[-1], acces_train[-1])
        model.eval()
        losses_eval = []
        acces_eval = []
        for batch_i, batch_data in enumerate(test_loader()):
            x = np.array([d[0] for d in batch_data], dtype='float32').reshape(-1, 1, 28, 28)
            y = np.array([d[1] for d in batch_data], dtype='int64').reshape(-1, 1)
            input_x = fluid.dygraph.to_variable(x)
            output_y = fluid.dygraph.to_variable(y)
            logit_y = model(input_x)
            loss = fluid.layers.softmax_with_cross_entropy(logit_y, output_y)
            loss = fluid.layers.mean(loss)
            acc = fluid.layers.accuracy(logit_y, output_y)
            losses_eval.append(loss.numpy())
            acces_eval.append(acc.numpy())
        print('end eval', epoch_i, np.mean(losses_eval), np.mean(acces_eval))

fluid.save_dygraph(model.state_dict(), './mnist/mnist')

评估

导入要用到的包

import paddle
from paddle import fluid
from paddle.dataset import mnist
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np

以Layer类的形式构建神经网络，这里注意一下，使用动态图加载已有的模型，需要事先构建神经网络，需要完全一致。

class Network(fluid.Layer):
    def __init__(self):
        super(Network, self).__init__()
        self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5) # n, 20, 24, 24
        self.pool1 = Pool2D(pool_size=2, pool_stride=2) # n, 20, 12, 12
        self.conv2 = Conv2D(num_channels=20, num_filters=30, filter_size=5) # n, 30, 8, 8
        self.pool2 = Pool2D(pool_size=2, pool_stride=2) # n, 30, 4, 4
        self.fc1 = Linear(input_dim=30*4*4, output_dim=1024)
        self.fc2 = Linear(input_dim=1024, output_dim=10)
    def forward(self, inputs):
        x = self.conv1(inputs)
        x = self.pool1(x)
        x = fluid.layers.tanh(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = fluid.layers.tanh(x)
        x = fluid.layers.reshape(x, (x.shape[0], -1))
        x = self.fc1(x)
        x = fluid.layers.dropout(x, 0.5)
        x = self.fc2(x)
        return x

加载模型以及评估过程，加载使用load_dygraph方法。

with fluid.dygraph.guard():
    model = Network()
    para_dict, opti_dict = fluid.load_dygraph('./mnist/mnist')
    model.set_dict(para_dict)
    model.eval()
    train_loader = paddle.batch(mnist.train(), batch_size=1000)
    test_loader = paddle.batch(mnist.test(), batch_size=1000)
    losses_eval = []
    acces_eval = []
    for batch_i, batch_data in enumerate(test_loader()):
        x = np.array([d[0] for d in batch_data], dtype='float32').reshape(-1, 1, 28, 28)
        y = np.array([d[1] for d in batch_data], dtype='int64').reshape(-1, 1)
        input_x = fluid.dygraph.to_variable(x)
        output_y = fluid.dygraph.to_variable(y)
        logit_y = model(input_x)
        loss = fluid.layers.softmax_with_cross_entropy(logit_y, output_y)
        loss = fluid.layers.mean(loss)
        acc = fluid.layers.accuracy(logit_y, output_y)
        losses_eval.append(loss.numpy())
        acces_eval.append(acc.numpy())
    print('end eval', np.mean(losses_eval), np.mean(acces_eval))

测试

导入要用到的包

import paddle
from paddle import fluid
from paddle.dataset import mnist
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np

同评估的一样，以Layer类的形式构建神经网络，这里注意一下，使用动态图加载已有的模型，需要事先构建神经网络，需要完全一致。

class Network(fluid.Layer):
    def __init__(self):
        super(Network, self).__init__()
        self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5) # n, 20, 24, 24
        self.pool1 = Pool2D(pool_size=2, pool_stride=2) # n, 20, 12, 12
        self.conv2 = Conv2D(num_channels=20, num_filters=30, filter_size=5) # n, 30, 8, 8
        self.pool2 = Pool2D(pool_size=2, pool_stride=2) # n, 30, 4, 4
        self.fc1 = Linear(input_dim=30*4*4, output_dim=1024)
        self.fc2 = Linear(input_dim=1024, output_dim=10)
    def forward(self, inputs):
        x = self.conv1(inputs)
        x = self.pool1(x)
        x = fluid.layers.tanh(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = fluid.layers.tanh(x)
        x = fluid.layers.reshape(x, (x.shape[0], -1))
        x = self.fc1(x)
        x = fluid.layers.dropout(x, 0.5)
        x = self.fc2(x)
        return x

加载图片的方法，使用Paddlepaddle自带的paddle.dataset.image.load_image方法。注意要定数据类型，搞一下shape，规一化数据。

def load_img(pic_path):
    img = paddle.dataset.image.load_image(pic_path, is_color=False)
    img = img.astype(np.float32)
    img = img[np.newaxis, np.newaxis, :, :] / 255.0
    img = img * 2.0 - 1.0
    return img

加载模型以及测试过程

with fluid.dygraph.guard():
    model = Network()
    para_dict, opti_dict = fluid.load_dygraph('./mnist/mnist')
    model.set_dict(para_dict)
    model.eval()
    x = load_img('./mnist/2.png')
    input_x = fluid.dygraph.to_variable(x)
    logit_y = model(input_x)
    print(np.argmax(logit_y.numpy()))

静态图

训练

导入要用到的包

import paddle
from paddle import fluid
import numpy as np
from paddle.dataset import mnist

构建神经网络，使用layers里的方法。

def lenet(inputs):
    x = fluid.layers.conv2d(inputs, num_filters=20, filter_size=5)
    x = fluid.layers.pool2d(x, pool_size=2, pool_stride=2)
    x = fluid.layers.tanh(x)
    x = fluid.layers.conv2d(x, num_filters=30, filter_size=5)
    x = fluid.layers.pool2d(x, pool_size=2, pool_stride=2)
    x = fluid.layers.tanh(x)
    x = fluid.layers.fc(x, size=1024)
    x = fluid.layers.dropout(x, 0.5)
    x = fluid.layers.fc(x, size=10)
    return x

输入输出tensor的定义，以及传播过程，损失函数和指标的定义，以及对损失函数的优化

# paddle.enable_static()  # paddle 2.0 need
input_x = fluid.layers.data(name='input_x', shape=[-1, 1, 28, 28], dtype='float32')
output_y = fluid.layers.data(name='output_y', shape=[-1, 1], dtype='int64')
logit_y = lenet(input_x)
loss = fluid.layers.softmax_with_cross_entropy(logit_y, output_y)
loss_mean = fluid.layers.mean(loss)
acc = fluid.layers.accuracy(logit_y, output_y)
optimizer = fluid.optimizer.Adam(learning_rate=0.001)
opt = optimizer.minimize(loss_mean)

创建执行器，输入喂数据的对象，数据生成器

use_gpu = False
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
validation_program = fluid.default_main_program().clone(for_test=True)
feeder = fluid.DataFeeder(feed_list=['input_x', 'output_y'], place=place)
train_loader = paddle.batch(mnist.train(), batch_size=1000)
test_loader = paddle.batch(mnist.test(), batch_size=1000)

训练过程以及保存模型。这里使用save_inference_model方法。

for epoch_i in range(2):
    losses_train = []
    acces_train = []
    for batch_i, batch_data in enumerate(train_loader()):
        loss_cal, acc_cal = exe.run(feed=feeder.feed(batch_data), fetch_list=[loss_mean, acc], )
        losses_train.append(loss_cal)
        acces_train.append(acc_cal)
        if batch_i % 10 == 0:
            print('on train', epoch_i, batch_i, losses_train[-1], acces_train[-1])
            losses_eval = []
            acces_eval = []
            for batch_eval_i, batch_eval_data in enumerate(test_loader()):
                loss_cal, acc_cal = exe.run(program=validation_program, feed=feeder.feed(batch_eval_data), fetch_list=[loss_mean, acc])
                losses_eval.append(loss_cal)
                acces_eval.append(acc_cal)
            print('end eval', epoch_i, batch_i, np.mean(losses_eval),np.mean(acces_eval))
fluid.io.save_inference_model('./mnist/', feeded_var_names=['input_x'], target_vars=[logit_y], executor=exe, model_filename='__model__', params_filename='__params__')

评估

导入要用到的包

import paddle
from paddle import fluid
import numpy as np
from paddle.dataset import mnist

定义执行器，要scope。静态图的形式不需要重新构建神经网络。但不好的地方是不能再拿来进行训练。

use_gpu = False
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference = fluid.core.Scope()

在scope内，创建数据生成器，加载模型，遍历数据进行评估。这里使用load_inference_model方法加载模型。

with fluid.scope_guard(inference):
    test_loader = paddle.batch(mnist.test(), batch_size=1000)
    program, feed_target_names, fetch_targets = fluid.io.load_inference_model('./mnist/', exe, model_filename='__model__', params_filename='__params__')
    allcount = 0
    rightcount = 0
    for batch_i, batch_data in enumerate(test_loader()):
        x = np.array([d[0] for d in batch_data], dtype='float32').reshape(-1, 1, 28, 28)
        y = np.array([d[1] for d in batch_data], dtype='int64').reshape(-1, 1)
        allcount += y.shape[0]
        result = exe.run(program=program, feed={feed_target_names[0]:x}, fetch_list=fetch_targets)
        result = np.argmax(result[0], axis=1)
        for i in range(y.shape[0]):
            if y[i] == result[i]:
                rightcount += 1
        print('on eval', batch_i, allcount, rightcount)
    print('end eval', allcount, rightcount, rightcount/allcount)

测试

导入要用到的包

import paddle
from paddle import fluid
import numpy as np

定义执行器，要scope。静态图的形式不需要重新构建神经网络。

use_gpu = False
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
inference = fluid.core.Scope()

加载图片的方法，使用Paddlepaddle自带的paddle.dataset.image.load_image方法。注意要定数据类型，搞一下shape，规一化数据。

def load_img(pic_path):
    img = paddle.dataset.image.load_image(pic_path, is_color=False)
    img = img.astype(np.float32)
    img = img[np.newaxis, np.newaxis, :, :] / 255.0
    img = img * 2.0 - 1.0
    return img

加载模型，推理结果

with fluid.scope_guard(inference):
    program, feed_target_names, fetch_targets = fluid.io.load_inference_model('./mnist/', exe, model_filename='__model__', params_filename='__params__')
    result = exe.run(program=program, feed={feed_target_names[0]:load_img('./mnist/2.png')}, fetch_list=fetch_targets)
    print(np.argmax(result[0]))