飞桨paddle和pytorch兼容 pytorch 飞桨

飞桨实验（1.使用LeNet在MNIST数据集实现图像分类（基于基础API和高层API，完成模型的训练与预测）2.完成实践：手写数字识别任务）

<Windows系统下安装配置paddlepaddle>

Conda下载(一般选择CPU版)：

conda install paddlepaddle==2.3.2 --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/Paddle/

验证安装

运行结果：

安装完成后可以使用 python 或 python3 进入python解释器，输入import paddle ，再输入 paddle.utils.run_check()

如果出现PaddlePaddle is installed successfully!，说明已成功安装。

Pycharm中安装Paddlepaddle（指定好自己使用的python解释器）

命令安装：

执行以下命令安装（推荐使用清华源）：

pip install paddlepaddle==2.3.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

 

另一种方法pycharm仓库安装指定版本：

先将清华源导入仓库

 

然后再下载源仓库里面的指定版本安装：

验证安装

查看版本号：

 

<Docker中安装配置Paddlepaddle>

docker没安装的可以去看之前的博客，里面都有详细的安装过程：

对于国内用户，因为网络问题下载docker比较慢时，可使用百度提供的镜像：

拉取预安装 PaddlePaddle 的镜像：

CPU版的PaddlePaddle：

docker pull registry.baidubce.com/paddlepaddle/paddle:2.3.2

验证安装

构建并进入docker容器

使用CPU版本的PaddlePaddle：

docker run --name paddle_docker -it -v $PWD:/paddle registry.baidubce.com/paddlepaddle/paddle:2.3.2 /bin/bash

--name paddle_docker：设定Docker的名称，paddle_docker 是自己设置的名称

-it：参数说明容器已和本机交互式运行；

-v $PWD:/paddle：指定将当前路径（PWD变量会展开为当前路径的绝对路径）挂载到容器内部的 /paddle 目录；

registry.baidubce.com/paddlepaddle/paddle:2.3.2：指定需要使用的image名称，您可以通过docker images命令查看；/bin/bash是在Docker中要执行的命令

 

<使用LeNet在MNIST数据集实现图像分类（基于基础API和高层API，完成模型的训练与预测）>

数据加载

手写数字的MNIST数据集，包含60,000个用于训练的示例和10,000个用于测试的示例。这些数字已经过尺寸标准化并位于图像中心，图像是固定大小(28x28像素)，其值为0到1。该数据集的官方地址为：http://yann.lecun.com/exdb/mnist 。

我们使用飞桨框架自带的 paddle.vision.datasets.MNIST 完成mnist数据集的加载。

from paddle.vision.transforms import Compose, Normalize

transform = Compose([Normalize(mean=[127.5],

                               std=[127.5],

                               data_format='CHW')])

# 使用transform对数据集做归一化

print('download training data and load training data')

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform)

test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)

print('load finished')

取训练集中的一条数据看一下。

import numpy as np

import matplotlib.pyplot as plt

train_data0, train_label_0 = train_dataset[0][0],train_dataset[0][1]

train_data0 = train_data0.reshape([28,28])

plt.figure(figsize=(2,2))

plt.imshow(train_data0, cmap=plt.cm.binary)

print('train_data0 label is: ' + str(train_label_0))

组网

用paddle.nn下的API，如Conv2D、MaxPool2D、Linear完成LeNet的构建。

def forward(self, x):

        x = self.conv1(x)

        x = F.relu(x)

        x = self.max_pool1(x)

        x = self.conv2(x)

        x = F.relu(x)

        x = self.max_pool2(x)

        x = paddle.flatten(x, start_axis=1,stop_axis=-1)

        x = self.linear1(x)

        x = F.relu(x)

        x = self.linear2(x)

        x = F.relu(x)

        x = self.linear3(x)

        return x

方式1：基于高层API，完成模型的训练与预测

通过paddle提供的Model 构建实例，使用封装好的训练与测试接口，快速完成模型训练与测试。

from paddle.metric import Accuracy

model = paddle.Model(LeNet())   # 用Model封装模型

optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())

# 配置模型

model.prepare(

    optim,

    paddle.nn.CrossEntropyLoss(),

    Accuracy()

    )

# 训练模型

model.fit(train_dataset,

        epochs=2,

        batch_size=64,

        verbose=1

        )

 使用 Model.evaluate 来预测模型

model.evaluate(test_dataset, batch_size=64, verbose=1)

 

方式一结束

以上就是方式一，可以快速、高效的完成网络模型训练与预测。

方式2：基于基础API，完成模型的训练与预测

 模型训练

组网后，开始对模型进行训练，先构建train_loader，加载训练数据，然后定义train函数，设置好损失函数后，按batch加载数据，完成模型的训练。

import paddle.nn.functional as F

train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

# 加载训练集 batch_size 设为 64

def train(model):

    model.train()

    epochs = 2

    optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())

    # 用Adam作为优化函数

    for epoch in range(epochs):

        for batch_id, data in enumerate(train_loader()):

            x_data = data[0]

            y_data = data[1]

            predicts = model(x_data)

            loss = F.cross_entropy(predicts, y_data)

            # 计算损失

            acc = paddle.metric.accuracy(predicts, y_data)

            loss.backward()

            if batch_id % 300 == 0:

                print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))

            optim.step()

            optim.clear_grad()

model = LeNet()

train(model)

test_loader = paddle.io.DataLoader(test_dataset, places=paddle.CPUPlace(), batch_size=64)

# 加载测试数据集

def test(model):

    model.eval（)

    batch_size = 64

    for batch_id, data in enumerate(test_loader()):

        x_data = data[0]

        y_data = data[1]

        predicts = model(x_data)

        # 获取预测结果

        loss = F.cross_entropy(predicts, y_data)

        acc = paddle.metric.accuracy(predicts, y_data)

        if batch_id % 20 == 0:

            print("batch_id: {}, loss is: {}, acc is: {}".format(batch_id, loss.numpy(), acc.numpy()))

test(model)

方式二结束

以上就是方式二，通过底层API，可以清楚的看到训练和测试中的每一步过程。但是，这种方式比较复杂。因此，我们提供了训练方式一，使用高层API来完成模型的训练与预测。对比底层API，高层API能够更加快速、高效的完成模型的训练与测试。

<实践：手写数字识别任务>

手写数字识别是深度学习里的 Hello World 任务，用于对 0 ~ 9 的十类数字进行分类，即输入手写数字的图片，可识别出这个图片中的数字。

开始之前，需要使用下面的命令安装 Python 的 matplotlib 库和 numpy 库，matplotlib 库用于可视化图片，numpy 库用于处理数据。

# 使用 pip 工具安装 matplotlib 和 numpy

python3 -m pip install matplotlib numpy -i https://mirror.baidu.com/pypi/simple

Pycharm中终端下载：

或者指定仓库中安装指定版本安装：

查看安装结果：

下面是手写数字识别任务的完整代码，如果想直接运行代码，可以拷贝下面的完整代码到一个Python文件中运行。

import paddle

import numpy as np

from paddle.vision.transforms import Normalize



transform = Normalize(mean=[127.5], std=[127.5], data_format='CHW')

# 下载数据集并初始化 DataSet

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform)

test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)



# 模型组网并初始化网络

lenet = paddle.vision.models.LeNet(num_classes=10)

model = paddle.Model(lenet)



# 模型训练的配置准备，准备损失函数，优化器和评价指标

model.prepare(paddle.optimizer.Adam(parameters=model.parameters()),

              paddle.nn.CrossEntropyLoss(),

              paddle.metric.Accuracy())



# 模型训练

model.fit(train_dataset, epochs=5, batch_size=64, verbose=1)

# 模型评估

model.evaluate(test_dataset, batch_size=64, verbose=1)



# 保存模型

model.save('./output/mnist')

# 加载模型

model.load('output/mnist')



# 从测试集中取出一张图片

img, label = test_dataset[0]

# 将图片shape从1*28*28变为1*1*28*28，增加一个batch维度，以匹配模型输入格式要求

img_batch = np.expand_dims(img.astype('float32'), axis=0)



# 执行推理并打印结果，此处predict_batch返回的是一个list，取出其中数据获得预测结果

out = model.predict_batch(img_batch)[0]

pred_label = out.argmax()

print('true label: {}, pred label: {}'.format(label[0], pred_label))

# 可视化图片

from matplotlib import pyplot as plt

plt.imshow(img[0])

代码结果：

以上代码使用 MNIST 数据集训练并测试了 LeNet 模型，并最终成功推理出了一张手写数字图片的标签，该图片推理结果是 7 （ pred label: 7），真实标签也是7 （true label: 7）：

<使用飞桨实现波士顿房价预测任务>

在数据处理之前，需要先加载飞桨框架的相关类库。

#加载飞桨、NumPy和相关类库

import paddle

from paddle.nn import Linear

import paddle.nn.functional as F

import numpy as np

import os

import random





def load_data():

    # 从文件导入数据

    datafile = './work/housing.data'

    data = np.fromfile(datafile, sep=' ', dtype=np.float32)



    # 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数

    feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \

                      'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]

    feature_num = len(feature_names)



    # 将原始数据进行Reshape，变成[N, 14]这样的形状

    data = data.reshape([data.shape[0] // feature_num, feature_num])



    # 将原数据集拆分成训练集和测试集

    # 这里使用80%的数据做训练，20%的数据做测试

    # 测试集和训练集必须是没有交集的

    ratio = 0.8

    offset = int(data.shape[0] * ratio)

    training_data = data[:offset]



    # 计算train数据集的最大值，最小值，平均值

    maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \

                                 training_data.sum(axis=0) / training_data.shape[0]

    

    # 记录数据的归一化参数，在预测时对数据做归一化

    global max_values

    global min_values

    global avg_values

    max_values = maximums

    min_values = minimums

    avg_values = avgs



    # 对数据进行归一化处理

    for i in range(feature_num):

        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])



    # 训练集和测试集的划分比例

    training_data = data[:offset]

    test_data = data[offset:]

    return training_data, test_data





# 验证数据集读取程序的正确性

training_data, test_data = load_data()

print(training_data.shape)

print(training_data[1,:])



class Regressor(paddle.nn.Layer):



    # self代表类的实例自身

    def __init__(self):

        # 初始化父类中的一些参数

        super(Regressor, self).__init__()

        

        # 定义一层全连接层，输入维度是13，输出维度是1

        self.fc = Linear(in_features=13, out_features=1)

    

    # 网络的前向计算

    def forward(self, inputs):

        x = self.fc(inputs)

        return x

训练配置

# 声明定义好的线性回归模型

model = Regressor()

# 开启模型训练模式

model.train()

# 加载数据

training_data, test_data = load_data()

# 定义优化算法，使用随机梯度下降SGD

# 学习率设置为0.01

opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())

训练过程

内层循环： 负责整个数据集的一次遍历，采用分批次方式（batch）。假设数据集样本数量为1000，一个批次有10个样本，则遍历一次数据集的批次数量是1000/10=100，即内层循环需要执行100次。

  for iter_id, mini_batch in enumerate(mini_batches):

外层循环： 定义遍历数据集的次数，通过参数EPOCH_NUM设置。 

batch的取值会影响模型训练效果，batch过大，会增大内存消耗和计算时间，且训练效果并不会明显提升（每次参数只向梯度反方向移动一小步，因此方向没必要特别精确）；batch过小，每个batch的样本数据没有统计意义，计算的梯度方向可能偏差较大。由于房价预测模型的训练数据集较小，因此将batch设置为10。

for epoch_id in range(EPOCH_NUM):



EPOCH_NUM = 10   # 设置外层循环次数

BATCH_SIZE = 10  # 设置batch大小



# 定义外层循环

for epoch_id in range(EPOCH_NUM):

    # 在每轮迭代开始之前，将训练数据的顺序随机的打乱

    np.random.shuffle(training_data)

    # 将训练数据进行拆分，每个batch包含10条数据

    mini_batches = [training_data[k:k+BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]

    # 定义内层循环

    for iter_id, mini_batch in enumerate(mini_batches):

        x = np.array(mini_batch[:, :-1]) # 获得当前批次训练数据

        y = np.array(mini_batch[:, -1:]) # 获得当前批次训练标签（真实房价）

        # 将numpy数据转为飞桨动态图tensor的格式

        house_features = paddle.to_tensor(x)

        prices = paddle.to_tensor(y)

        

        # 前向计算

        predicts = model(house_features)

        

        # 计算损失

        loss = F.square_error_cost(predicts, label=prices)

        avg_loss = paddle.mean(loss)

        if iter_id%20==0:

            print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))

        

        # 反向传播，计算每层参数的梯度值

        avg_loss.backward()

        # 更新参数，根据设置好的学习率迭代一步

        opt.step()

        # 清空梯度变量，以备下一轮计算

        opt.clear_grad()

保存并测试模型

# 保存模型参数，文件名为LR_model.pdparams

paddle.save(model.state_dict(), 'LR_model.pdparams')

print("模型保存成功，模型参数保存在LR_model.pdparams中")

测试模型

def load_one_example():

    # 从上边已加载的测试集中，随机选择一条作为测试数据

    idx = np.random.randint(0, test_data.shape[0])

    idx = -10

    one_data, label = test_data[idx, :-1], test_data[idx, -1]

    # 修改该条数据shape为[1,13]

    one_data =  one_data.reshape([1,-1])



return one_data, label



# 参数为保存模型参数的文件地址

model_dict = paddle.load('LR_model.pdparams')











model.load_dict(model_dict)

model.eval（)



# 参数为数据集的文件地址

one_data, label = load_one_example()

# 将数据转为动态图的variable格式

one_data = paddle.to_tensor(one_data)

predict = model(one_data)



# 对结果做反归一化处理

predict = predict * (max_values[-1] - min_values[-1]) + avg_values[-1]

# 对label数据做反归一化处理

label = label * (max_values[-1] - min_values[-1]) + avg_values[-1]



print("Inference result is {}, the corresponding label is {}".format(predict.numpy(), label))

实验运行结果：

飞桨针对很多应用场景和机器资源做了性能优化，在功能和性能上远强于自行编写的模型。