百度Paddle速查_CPU和GPU的mnist预测训练_模型导出_模型导入再预测_导出onnx并预测

需要做点什么

方便广大烟酒生研究生、人工智障炼丹师算法工程师快速使用百度PaddelPaddle，所以特写此文章，默认使用者已有基本的深度学习概念、数据集概念。

系统环境

python 3.7.4

paddlepaddle-gpu 2.2.2

paddle2onnx 0.9.1

onnx 1.9.0

onnxruntime-gpu 1.9.0

数据准备

MNIST数据集csv文件是一个42000x785的矩阵

42000表示有42000张图片

785中第一列是图片的类别(0,1,2,..,9),第二列到最后一列是图片数据向量 (28x28的图片张成784的向量)， 数据集长这个样子:

1 0 0 0 0 0 0 0 0 0 ..

0 0 0 0 0 0 0 0 0 0 ..

1 0 0 0 0 0 0 0 0 0 ..

1. 导入需要的包

import os
import onnx
import paddle
import numpy as np
import pandas as pd
import onnxruntime as ort
import paddle.nn.functional as F
from paddle.metric import Accuracy
from paddle.static import InputSpec
from sklearn.metrics import accuracy_score

2. 参数准备

N_EPOCH = 2
N_BATCH = 64
N_BATCH_NUM = 250
S_DATA_PATH = r"mnist_train.csv"
S_PADDLE_MODEL_PATH = r"cnn_model"
S_ONNX_MODEL_PATH = r"cnn_model_batch%d.onnx" % N_BATCH
S_DEVICE, N_DEVICE_ID, S_DEVICE_FULL = "gpu", 0, "gpu:0"
# S_DEVICE, N_DEVICE_ID, S_DEVICE_FULL = "cpu", 0, "cpu"
paddle.set_device(S_DEVICE_FULL)

运行输出:

CUDAPlace(0)

3. 读取数据

df = pd.read_csv(S_DATA_PATH, header=None)
print(df.shape)
np_mat = np.array(df)
print(np_mat.shape)

X = np_mat[:, 1:]
Y = np_mat[:, 0]
X = X.astype(np.float32) / 255

X_train = X[:N_BATCH * N_BATCH_NUM]
X_test = X[N_BATCH * N_BATCH_NUM:]
Y_train = Y[:N_BATCH * N_BATCH_NUM]
Y_test = Y[N_BATCH * N_BATCH_NUM:]
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

class MnistDataSet(paddle.io.Dataset):
    def __init__(self, X, Y):
        self.l_data, self.l_label = [], []
        for i in range(X.shape[0]):
            self.l_data.append(X[i, :, :, :])
            self.l_label.append(Y[i])

    def __getitem__(self, index):
        return self.l_data[index], self.l_label[index]

    def __len__(self):
        return len(self.l_data)

train_loader = paddle.io.DataLoader(MnistDataSet(X_train, Y_train),  batch_size=N_BATCH, shuffle=True)
test_loader = paddle.io.DataLoader(MnistDataSet(X_test, Y_test), batch_size=N_BATCH, shuffle=False)

运行输出

(42000, 785)
(42000, 785)
(16000, 1, 28, 28)
(16000,)
(26000, 1, 28, 28)
(26000,)

4. 模型构建

class Net(paddle.nn.Layer):
    def __init__(self):
        super(Net, self).__init__()
        self.encoder = paddle.nn.Sequential(paddle.nn.Conv2D(1, 16, 3, 1),
                                            paddle.nn.MaxPool2D(2),
                                            paddle.nn.Flatten(1),
                                            paddle.nn.Linear(2704, 128),
                                            paddle.nn.ReLU(),
                                            paddle.nn.Linear(128, 10))

    def forward(self, x):
        out = self.encoder(x)
        return out

5. 模型训练和保存

print("model train")
model = paddle.Model(Net(), InputSpec([None, 1, 28, 28], 'float32', 'x'), InputSpec([None, 10], 'float32', 'x'))
model.prepare(paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()), paddle.nn.CrossEntropyLoss(), Accuracy())
model.fit(train_loader,
          test_loader,
          epochs=N_EPOCH,
          batch_size=N_BATCH,
          save_dir=S_PADDLE_MODEL_PATH + "_iter",
          verbose=1)
model.save(S_PADDLE_MODEL_PATH + "_final_model")
print()
# model.save(S_PADDLE_MODEL_PATH) # Model save

运行输出

model train
The loss value printed in the log is the current step, and the metric is the average value of previous steps.
Epoch 1/2
step  30/250 [==>...........................] - loss: 0.3036 - acc: 0.7531 - ETA: 1s - 6ms/step
step 250/250 [==============================] - loss: 0.3151 - acc: 0.9073 - 4ms/step
save checkpoint at D:\Document\_Code_Py\ai_fast_handbook\cnn_model_iter\0
Eval begin...
step 407/407 [==============================] - loss: 0.0230 - acc: 0.9330 - 2ms/step          - loss: 0.1698 - acc: 0.9315 - ETA: 0s - 2ms/ - loss: 0.3643 - acc: 0.9326 - ETA: 0s - 2m
Eval samples: 26000
Epoch 2/2
step 250/250 [==============================] - loss: 0.0744 - acc: 0.9642 - 3ms/step
save checkpoint at D:\Document\_Code_Py\ai_fast_handbook\cnn_model_iter\1
Eval begin...
step 407/407 [==============================] - loss: 0.0614 - acc: 0.9575 - 2ms/step
Eval samples: 26000
save checkpoint at D:\Document\_Code_Py\ai_fast_handbook\cnn_model_iter\final

6.模型预测

print("model pred")
model.evaluate(test_loader, batch_size=N_BATCH, verbose=1)
print()

运行输出

model pred
Eval begin...
step 407/407 [==============================] - loss: 0.0614 - acc: 0.9575 - 2ms/step          - loss: 0.2162 - acc: 0.9559 - ETA
Eval samples: 26000

7.模型加载和加载模型使用

print("load model and pred test data")
model_load = paddle.Model(Net(), InputSpec([None, 1, 28, 28], 'float32', 'x'), InputSpec([None, 10], 'float32', 'x'))
# model_load.load(S_PADDLE_MODEL_PATH + "_iter/final")
model_load.load(S_PADDLE_MODEL_PATH + "_final_model")
model_load.prepare(paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()), paddle.nn.loss.CrossEntropyLoss(), Accuracy())
model_load.evaluate(test_loader, batch_size=N_BATCH, verbose=1)
print()

运行输出

load model and pred test data
Eval begin...
step 407/407 [==============================] - loss: 0.0614 - acc: 0.9575 - 2ms/step          - loss: 0.1656 - acc: 0.9561 - ETA:
Eval samples: 26000

8.导出ONNX

x_spec = InputSpec([None, 1, 28, 28], 'float32', 'x')
paddle.onnx.export(Net(), S_ONNX_MODEL_PATH, input_spec=[x_spec])

运行输出

2022-03-24 08:08:21 [INFO]	ONNX model saved in cnn_model_batch64.onnx.onnx

8. 加载ONNX并运行

S_DEVICE = "cuda" if S_DEVICE == "gpu" else S_DEVICE
model = onnx.load(S_ONNX_MODEL_PATH + ".onnx")
print(onnx.checker.check_model(model))  # Check that the model is well formed
print(onnx.helper.printable_graph(model.graph))  # Print a human readable representation of the graph
ls_input_name, ls_output_name = [input.name for input in model.graph.input], [output.name for output in model.graph.output]
print("input name ", ls_input_name)
print("output name ", ls_output_name)
s_input_name = ls_input_name[0]

x_input = X_train[:N_BATCH * 2, :, :, :].astype(np.float32)
ort_val = ort.OrtValue.ortvalue_from_numpy(x_input, S_DEVICE, N_DEVICE_ID)
print("val device ", ort_val.device_name())
print("val shape ", ort_val.shape())
print("val data type ", ort_val.data_type())
print("is_tensor ", ort_val.is_tensor())
print("array_equal ", np.array_equal(ort_val.numpy(), x_input))
providers = 'CUDAExecutionProvider' if S_DEVICE == "cuda" else 'CPUExecutionProvider'
print("providers ", providers)
ort_session = ort.InferenceSession(S_ONNX_MODEL_PATH + ".onnx", providers=[providers])  # gpu运行
ort_session.set_providers([providers])
outputs = ort_session.run(None, {s_input_name: ort_val})
print("sess env ", ort_session.get_providers())
print(type(outputs))
print(outputs[0])
'''
For example ['CUDAExecutionProvider', 'CPUExecutionProvider']
    means execute a node using CUDAExecutionProvider if capable, otherwise execute using CPUExecutionProvider.
'''

运行输出

None
graph paddle-onnx (
  %x[FLOAT, -1x1x28x28]
) {
  %conv2d_2.w_0 = Constant[value = <Tensor>]()
  %conv2d_2.b_0 = Constant[value = <Tensor>]()
  %linear_4.w_0 = Constant[value = <Tensor>]()
  %linear_4.b_0 = Constant[value = <Tensor>]()
  %linear_5.w_0 = Constant[value = <Tensor>]()
  %linear_5.b_0 = Constant[value = <Tensor>]()
  %conv2d_3.tmp_0 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [0, 0, 0, 0], strides = [1, 1]](%x, %conv2d_2.w_0)
  %Constant_0 = Constant[value = <Tensor>]()
  %Reshape_0 = Reshape(%conv2d_2.b_0, %Constant_0)
  %conv2d_3.tmp_1 = Add(%conv2d_3.tmp_0, %Reshape_0)
  %pool2d_0.tmp_0 = MaxPool[kernel_shape = [2, 2], pads = [0, 0, 0, 0], strides = [2, 2]](%conv2d_3.tmp_1)
  %Shape_0 = Shape(%pool2d_0.tmp_0)
  %Slice_0 = Slice[axes = [0], ends = [1], starts = [0]](%Shape_0)
  %Constant_1 = Constant[value = <Tensor>]()
  %Concat_0 = Concat[axis = 0](%Slice_0, %Constant_1)
  %flatten_3.tmp_0 = Reshape(%pool2d_0.tmp_0, %Concat_0)
  %linear_6.tmp_0 = MatMul(%flatten_3.tmp_0, %linear_4.w_0)
  %linear_6.tmp_1 = Add(%linear_6.tmp_0, %linear_4.b_0)
  %relu_0.tmp_0 = Relu(%linear_6.tmp_1)
  %linear_7.tmp_0 = MatMul(%relu_0.tmp_0, %linear_5.w_0)
  %linear_7.tmp_1 = Add(%linear_7.tmp_0, %linear_5.b_0)
  return %linear_7.tmp_1
}
input name  ['x']
output name  ['linear_7.tmp_1']
val device  cuda
val shape  [128, 1, 28, 28]
val data type  tensor(float)
is_tensor  True
array_equal  True
providers  CUDAExecutionProvider
sess env  ['CUDAExecutionProvider', 'CPUExecutionProvider']
<class 'list'>
[[ 0.763783   -0.16668957 -0.16518936 ...  0.07235195 -0.01643395
   0.06049304]
 [ 1.8068395  -0.74552214  0.3836273  ...  0.75880224 -0.88902843
   0.32921085]
 [ 0.2381373  -0.14879732 -0.21634206 ... -0.06579521 -0.461351
   0.15305203]
 ...
 [ 0.97004616  0.07693841  0.05774391 ...  0.21991295  0.07179791
  -0.22383693]
 [ 0.5787286  -0.34370935 -0.12914304 ... -0.03083546 -0.01817408
  -0.5147962 ]
 [ 0.60808766 -0.12549599 -0.32095248 ... -0.32175955 -0.03176413
  -0.06790417]]

你甚至不愿意Start的Github

ai_fast_handbook