(一)PaddlePaddle(深度学习框架)的搭建、使用

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,形状是[22],也叫维度,并赋值为1,类型为int64,得到一个张良[[11][11]]
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参数指定CPUGPU进行计算
# 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)

运行结果:

(一)PaddlePaddle(深度学习框架)的搭建、使用_第1张图片

(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创建两个形状[12]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(深度学习框架)的搭建、使用_第2张图片

二、PaddlePaddle的线性回归算法:

(1)深度神经网络的搭建:

1、单个神经元的模型就是有多个输入,经过求和、求积计算,然后再经过非线性函数(如ReLU等各种激活函数),最终输出
(一)PaddlePaddle(深度学习框架)的搭建、使用_第3张图片
1、将多个神经元组合在一起,就构成了一个神经网络,依次有输入层、隐藏层、输出层。输入层的每个输入都与隐藏层连接,通过隐藏层计算,最终连接输出层进行输出;
2、在简单的神经网络模型的基础上,再在输入层和输出层之间增加多个隐藏层,会增加整个模型的深度。正因为有大量的隐藏层,所以称为深度神经网络模型;
(一)PaddlePaddle(深度学习框架)的搭建、使用_第4张图片

(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]))

运行结果,模型收敛:

(一)PaddlePaddle(深度学习框架)的搭建、使用_第5张图片

(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(深度学习框架)的搭建、使用_第6张图片

三、PaddlePaddle卷积神经网络(MNIST手写数字识别):

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

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

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

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))

训练结果:

(一)PaddlePaddle(深度学习框架)的搭建、使用_第7张图片

识别手写数字8:

(一)PaddlePaddle(深度学习框架)的搭建、使用_第8张图片

代码:

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

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)

运行结果:

(一)PaddlePaddle(深度学习框架)的搭建、使用_第9张图片

你可能感兴趣的:(python,paddlepaddle,深度学习,人工智能)