PaddlePaddle是百度公司2016年开源的深度学习框架，现如今可以方便部署到服务器、智能手机和嵌入式设备中。PaddlePaddle还开源大量常用的深度学习模型。

一、PaddlePaddle快速入门：

（1）PaddlePaddle的大部分API都在paddle.fluid中。接着定义两个PaddlePaddle常量x1和x2，形状是[2，2]，也叫维度，并赋值为1，类型为int64，得到一个张良[[1，1]，[1，1]]，代码：

# PaddlePaddle的大部分API都在paddle.fluid中。
import paddle
# 兼容PaddlePaddle2.0
paddle.enable_static()

# 接着定义两个PaddlePaddle常量x1和x2，形状是[2，2]，也叫维度，并赋值为1，类型为int64，得到一个张良[[1，1]，[1，1]]
x1 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')
x2 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')

# 将x1与x2两个张量相加
# PaddlePaddle支持使用算术运算符号，如改成x1+x2
y1 = fluid.layers.sum(x=[x1, x2])

# 然后创建一个执行器，执行器用于把数据传入模型中，并执行模型中。执行器可以使用place参数指定CPU或GPU进行计算
# place = fluid.CUDAPlace(0)         # 使用GPU，其中0是指序号为0的显卡
place = fluid.CPUPlace()             # 使用CPU
exe = fluid.executor.Executor(place)
# 使用fluid.Executor()函数执行fluid.default_startup_program()函数，对整个PaddlePaddle程序进行参数随机初始化
exe.run(fluid.default_startup_program())

# PaddlePaddle中两个程序默认：default_startup_program()、default_main_program()
# 使用fluid.Executor()函数执行，主程序参数值是fluid.default_main_program()
result = exe.run(program=fluid.default_main_program(),
                 fetch_list=[y1])
print(result)

运行结果：

（2）PaddlePaddle定义两个变量，赋值，然后相加：

import paddle.fluid as fluid
import numpy as np
import paddle
# 兼容PaddlePaddle2.0
paddle.enable_static()

# PaddlePaddle的每层又有名称，定义两个张量，不需要指定形状和值，只指定变量的类型和名称（a，b）即可，如不指定名称，会默认设置名称
a = fluid.layers.create_tensor(dtype='int64', name='a')
b = fluid.layers.create_tensor(dtype='int64', name='b')

# 将两个张量求和
y = fluid.layers.sum(x=[a, b])

# 创建一个使用CPU的执行器
place = fluid.CPUPlace()
exe = fluid.executor.Executor(place)
# 进行参数初始化
exe.run(fluid.default_startup_program())

# 用numpy创建两个形状[1，2]de1矩阵,
a1 = np.array([3, 2]).astype('int64')
b1 = np.array([1, 1]).astype('int64')

# 进行运算，并把y的结果输出
out_a, out_b, result = exe.run(program=fluid.default_main_program(),
                               feed={a.name: a1, b.name: b1},
                               fetch_list=[a, b, y])
print(out_a," + ", out_b," = ", result)

运行结果：

二、PaddlePaddle的线性回归算法：

（1）深度神经网络的搭建：

1、单个神经元的模型就是有多个输入，经过求和、求积计算，然后再经过非线性函数（如ReLU等各种激活函数），最终输出

1、将多个神经元组合在一起，就构成了一个神经网络，依次有输入层、隐藏层、输出层。输入层的每个输入都与隐藏层连接，通过隐藏层计算，最终连接输出层进行输出；
2、在简单的神经网络模型的基础上，再在输入层和输出层之间增加多个隐藏层，会增加整个模型的深度。正因为有大量的隐藏层，所以称为深度神经网络模型；

（2）模型训练

# PaddlePaddle的线性回归算法
import numpy as np
import paddle
paddle.enable_static()
import paddle.fluid as fluid
import numpy

# 搭建一个简单的神经网络（1个输入层，2个隐藏层，1个输出层，即全连接层）
# 定义一个输入层:指定输入层的名称'x'，形状和类型。shape的第一个参数是输入数据批量大小通常设置None，这样可以自动根据输入数据的批量大小变动，输入层都是float32类型
x = fluid.data(name='x', shape=[None, 1], dtype='float32')
# 定义两个隐藏层(大小无为100（神经元数量），激活函数为ReLU)
hidden = fluid.layers.fc(input=x, size=100, act='relu')
hidden = fluid.layers.fc(input=hidden, size=100, act='relu')
# 最后输出大小为1的全连接层，也叫输出层
net = fluid.layers.fc(input=hidden, size=1, act=None)

# PaddlePaddle按顺序把深度神经网络模型、损失函数等这些计算添加到主程序中，但此时只复制神经网路模型
infer_program = fluid.default_main_program().clone(for_test=True)

# 定义一个标签层，每个标签层为每组数据对应的真实结果
y = fluid.data(name='y', shape=[None,1], dtype='float32')
# 定义神经网络模型的损失函数,是一个批量的损失
cost = fluid.layers.square_error_cost(input=net, label=y)
# 求平均值
avg_cost = fluid.layers.mean(cost)

# 定义训练的优化方法(SGD随机梯度下降，学习率0.01)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01)
opts = optimizer.minimize(avg_cost)

# 创建执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

# 用numpy定义一组数据，输入层数据：x_data，标签层：y_data（y=2*x+1），程序不知道这个规律，我们进行训练来拟合
x_data = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]]).astype('float32')
y_data = np.array([[3.0], [5.0], [7.0], [9.0], [11.0]]).astype('float32')

for pass_id in range(100):
    train_cost = exe.run(program=fluid.default_main_program(),  # 加载模型
                         feed={x.name:x_data, y.name:y_data},   # 喂入输入数据、真实结果数据
                         fetch_list=[avg_cost])                 # 让执行器在训练中输出损失值
    print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0]))

运行结果，模型收敛：

（3）模型预测：

# PaddlePaddle的线性回归算法
# PaddlePaddle的线性回归算法
import numpy as np
import paddle
paddle.enable_static()
import paddle.fluid as fluid
import numpy

# 搭建一个简单的神经网络（1个输入层，2个隐藏层，1个输出层，即全连接层）
# 定义一个输入层:指定输入层的名称'x'，形状和类型。shape的第一个参数是输入数据批量大小通常设置None，这样可以自动根据输入数据的批量大小变动，输入层都是float32类型
x = fluid.data(name='x', shape=[None, 1], dtype='float32')
# 定义两个隐藏层(大小无为100（神经元数量），激活函数为ReLU)
hidden = fluid.layers.fc(input=x, size=100, act='relu')
hidden = fluid.layers.fc(input=hidden, size=100, act='relu')
# 最后输出大小为1的全连接层，也叫输出层
net = fluid.layers.fc(input=hidden, size=1, act=None)

# 创建深度神经网络后，可以从主程序复制一个程序与预测数据
# PaddlePaddle按顺序把深度神经网络模型、损失函数等这些计算添加到主程序中，但此时只复制神经网路模型
infer_program = fluid.default_main_program().clone(for_test=True)

# 定义一个标签层，每个标签层为每组数据对应的真实结果
y = fluid.data(name='y', shape=[None,1], dtype='float32')
# 定义神经网络模型的损失函数,是一个批量的损失（cost是通过了神经网络输出的net，与标签为y的方差值）
cost = fluid.layers.square_error_cost(input=net, label=y)
# 求方差平均值
avg_cost = fluid.layers.mean(cost)

# 定义训练的优化方法(SGD随机梯度下降，学习率0.01)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.005)
opts = optimizer.minimize(avg_cost)

# 创建执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

# 用numpy定义一组数据，输入层数据：x_data，标签层：y_data（y=2*x+1），程序不知道这个规律，我们进行训练来拟合
x_data = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]]).astype('float32')
y_data = np.array([[3.0], [5.0], [7.0], [9.0], [11.0]]).astype('float32')

for pass_id in range(200):
    train_cost = exe.run(program=fluid.default_main_program(),  # 加载模型
                         feed={x.name:x_data, y.name:y_data},   # 喂入输入数据、真实结果数据(分别把x_data、y_data的值赋给x、y)
                         fetch_list=[avg_cost])                 # 让执行器在训练中输出损失值
    print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0]))


test_data = np.array([[6.0]]).astype('float32')
result = exe.run(program=infer_program,
                 feed={x.name:test_data},
                 fetch_list=[net])
print("当x为6.0时，y为：%0.5f:" % result[0])

运行结果：

三、PaddlePaddle卷积神经网络（MNIST手写数字识别）：

卷积神经网络一般用于图像特征提取，如图像分类、目标检测、文字识别等。卷积神经网络通常由卷积层、池化层、全连接层组成。

MNIST手写数据集包括6000条训练数据集和1000条测试训练集

# PaddlePaddle卷积神经网络--MNIST手写数字识别
# MNIST手写数据集包括6000条训练数据集和1000条测试训练集
# 图片是28pxX29xp的灰度图像，对应的标签是0`9的10个数字，每张图片都经过大小归一化和居中处理

import numpy as np
import paddle
paddle.enable_static()
import paddle.dataset.mnist as mnist
import paddle.fluid as fluid
from PIL import Image


# 搭建简单的卷积神经网络：输入层、卷积层、池化层、卷积层、池化层、输出层
def convolutional_neural_netwrk(input):
    # 卷积层(input:数据输入，num_filters：卷积核数量，filter_size：卷积核大小，stride：卷积核滑动步长)
    conv1 = fluid.layers.conv2d(input=input,
                                num_filters=32,
                                filter_size=3,
                                stride=1)
    # 池化层(最大值池化)
    pool1 = fluid.layers.pool2d(input=conv1,
                               pool_size=2,
                               pool_stride=1,
                               pool_type='max')
    conv2 = fluid.layers.conv2d(input=pool1,
                                num_filters=64,
                                filter_size=3,
                                stride=1)
    pool2 = fluid.layers.pool2d(input=conv2,
                               pool_size=2,
                               pool_stride=1,
                               pool_type='max')
    # 全连接层,指定大小为10，因为MNIST数据集的类别数量是10。softmax通过用于分类任务中，每个类别的概率总和为1
    fc = fluid.layers.fc(input=pool2, size=10, act='softmax')
    return fc

# 定义标签层，图像是单通道28pxX28px，所以[1, 28, 28]
image = fluid.data(name='image', shape=[None, 1, 28, 28], dtype='float32')
label = fluid.data(name='label', shape=[None, 1], dtype='int64')

model = convolutional_neural_netwrk(image)
# 在通过深度神经获取输出之后，就可以从主程序中复制一个程序用于训练结束时的预测
infer_program = fluid.default_main_program().clone(for_test=True)

cost = fluid.layers.cross_entropy(input=model, label=label)  # 交叉熵
avg_cost = fluid.layers.mean(cost)  # 求均值
acc = fluid.layers.accuracy(input=model, label=label)  # 准备率

# 从主程序中复制多一个
test_program = fluid.default_main_program().clone(for_test=True)

# 优化器(Adam是一种自适应调整学习率的方法，使用大数据高维空间场景)
optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.0005)
opts = optimizer.minimize(avg_cost)

# 通过mnist.train()、mnist.test()获取训练集、测试集，batch_size把数据集分割一个个批次，一批次数据为128张
train_reader = paddle.batch(mnist.train(), batch_size=128)
test_reader = paddle.batch(mnist.test(), batch_size=128)

# 初始化执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

# 通过feed_list指定每组数据输入顺序，通过place指定训练数据向CPU输入
feeder = fluid.DataFeeder(place=place, feed_list=[image, label])

# 训练两轮
for pass_id in range(2):
    for batch_id, data in enumerate(train_reader()):
        train_cost, train_acc = exe.run(program=fluid.default_main_program(),
                                        feed=feeder.feed(data),
                                        fetch_list=[avg_cost, acc])
        if batch_id % 100 == 0:
            print('Pass:%d, Batch:%d, Cost:%0.5f, Accuracy:%0.5f' % (pass_id, batch_id, train_cost[0], train_acc[0]))

# 训练结束，再进行一次测试，使用测试集进行测试
test_accs = []
test_costs = []
for batch_id, data in enumerate(test_reader()):
    test_cost, test_acc = exe.run(program=test_program,
                                  feed=feeder.feed(data),
                                  fetch_list=[avg_cost, acc])
    test_costs.append(test_cost[0])
    test_accs.append(test_cost[0])
# 求测试结果的平均值
test_cost = (sum(test_costs) / len(test_costs))
test_acc = (sum(test_accs) / len(test_accs))
print("Test:%d, Cost:%0.5f, Accuracy:%0.5f" % (pass_id, test_cost, test_acc))

训练结果：

识别手写数字8：

代码：

# PaddlePaddle卷积神经网络--MNIST手写数字识别
# MNIST手写数据集包括6000条训练数据集和1000条测试训练集
# 图片是28pxX29xp的灰度图像，对应的标签是0`9的10个数字，每张图片都经过大小归一化和居中处理

import numpy as np
import paddle
paddle.enable_static()
import paddle.dataset.mnist as mnist
import paddle.fluid as fluid
from PIL import Image


# 搭建简单的卷积神经网络：输入层、卷积层、池化层、卷积层、池化层、输出层
def convolutional_neural_netwrk(input):
    # 卷积层(input:数据输入，num_filters：卷积核数量，filter_size：卷积核大小，stride：卷积核滑动步长)
    conv1 = fluid.layers.conv2d(input=input,
                                num_filters=32,
                                filter_size=3,
                                stride=1)
    # 池化层(最大值池化)
    pool1 = fluid.layers.pool2d(input=conv1,
                               pool_size=2,
                               pool_stride=1,
                               pool_type='max')
    conv2 = fluid.layers.conv2d(input=pool1,
                                num_filters=64,
                                filter_size=3,
                                stride=1)
    pool2 = fluid.layers.pool2d(input=conv2,
                               pool_size=2,
                               pool_stride=1,
                               pool_type='max')
    # 全连接层,指定大小为10，因为MNIST数据集的类别数量是10。softmax通过用于分类任务中，每个类别的概率总和为1
    fc = fluid.layers.fc(input=pool2, size=10, act='softmax')
    return fc

# 定义标签层，图像是单通道28pxX28px，所以[1, 28, 28]
image = fluid.data(name='image', shape=[None, 1, 28, 28], dtype='float32')
label = fluid.data(name='label', shape=[None, 1], dtype='int64')

model = convolutional_neural_netwrk(image)
# 在通过深度神经获取输出之后，就可以从主程序中复制一个程序用于训练结束时的预测
infer_program = fluid.default_main_program().clone(for_test=True)

cost = fluid.layers.cross_entropy(input=model, label=label)  # 交叉熵
avg_cost = fluid.layers.mean(cost)  # 求均值
acc = fluid.layers.accuracy(input=model, label=label)  # 准确率

# 从主程序中复制多一个测试程序，为了能够在测试中输出损失值和准确率
test_program = fluid.default_main_program().clone(for_test=True)

# 优化器(Adam是一种自适应调整学习率的方法，使用大数据高维空间场景)
optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.0005)
opts = optimizer.minimize(avg_cost)

# 通过mnist.train()、mnist.test()获取训练集、测试集，batch_size把数据集分割一个个批次，一批次数据为128张
train_reader = paddle.batch(mnist.train(), batch_size=128)
test_reader = paddle.batch(mnist.test(), batch_size=128)

# 初始化执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

# 通过feed_list指定每组数据输入顺序，通过place指定训练数据向CPU输入
feeder = fluid.DataFeeder(place=place, feed_list=[image, label])

# 训练两轮
for pass_id in range(2):
    for batch_id, data in enumerate(train_reader()):
        # fetch_list:后面的参数是决定上面功能
        train_cost, train_acc = exe.run(program=fluid.default_main_program(),
                                        feed=feeder.feed(data),
                                        fetch_list=[avg_cost, acc])   # 损失值、准确率
        if batch_id % 100 == 0:
            print('Pass:%d, Batch:%d, Cost:%0.5f, Accuracy:%0.5f' % (pass_id, batch_id, train_cost[0], train_acc[0]))

# 训练结束，再进行一次测试，使用测试集进行测试
test_accs = []
test_costs = []
for batch_id, data in enumerate(test_reader()):
    test_cost, test_acc = exe.run(program=test_program,
                                  feed=feeder.feed(data),
                                  fetch_list=[avg_cost, acc])   # 损失值、准确率
    test_accs.append(test_acc[0])
    test_costs.append(test_cost[0])
# 求测试结果的平均值
test_cost = (sum(test_costs) / len(test_costs))
test_acc = (sum(test_accs) / len(test_accs))
print("Test:%d, Cost:%0.5f, Accuracy:%0.5f" % (pass_id, test_cost, test_acc))

# 上述训练结束，接下来预测一张实际的图片
# 先将图片经过预处理转换成张量加载到PaddlePaddle训练。（灰度化缩放大小）
def load_image(file):
    im = Image.open(file).convert('L')
    im = im.resize((28,28), Image.ANTIALIAS)   # ANTIALIAS:高质量
    im = np.array(im).reshape(1,1,28,28).astype(np.float32)
    im = im / 255.0 * 2.0 - 1.0
    return im

img = load_image('F:\\PyQt_Serial_Assistant_Drive_Detect\\Friuts_Classify\\8.jpg')
results = exe.run(program=infer_program,   # program是上面复制的预测程序
                  feed={image.name:img},   # 只有输入层，为加载的图片
                  fetch_list=[model])      # 为神经网络模型最后的分类器，输出一个分类结果

# np.argsort(results)得到的是每个类别的概率，通过下标找出最大概率测试结果的标签
lab = np.argsort(results)[0][0][-1]
c = np.argsort(results)
print('数字8的image is: %d' % lab)
print(c)

运行结果：