课程简介：html
“跟着雨哥学AI”是百度飞桨开源框架近期针对高层API推出的系列课。本课程由多位资深飞桨工程师精心打造，不只提供了从数据处理、到模型组网、模型训练、模型评估和推理部署全流程讲解；还提供了丰富的趣味案例，旨在帮助开发者更全面清晰地掌握百度飞桨框架的用法，并可以触类旁通、灵活使用飞桨框架进行深度学习实践。python
下载安装命令 ## CPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/cpu paddlepaddle ## GPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/gpu paddlepaddle-gpu
1. 什么是模型训练？
在深度学习领域，咱们常常听到「模型训练」这一关键词，上节课中咱们详细的解释了什么是模型以及模型是如何组建的，这节课咱们须要考虑「什么是模型训练？」「为何要进行模型训练？」「咱们如何进行模型的训练？」， 甚至咱们还会好奇「模型训练的结果是什么？」 。算法
以识别任务为例，以下图所示，面对大量的数据和素材，咱们的目的就是使用咱们设计并组建的模型（算法）可以实现对目标进行准确的识别。那么这一目标也就是咱们进行模型训练的原动力，为了达到这一目标，咱们须要有一个好的算法，而算法对应的就是咱们上节课讲述的模型，这套算法里面包含若干的关键权重信息，用于指导每一个模型（算法）节点如何对输入数据作特征提取，在刚建设好模型的时候，这些权重信息会随机设置，效果不好，没法直接用于咱们的任务使用，咱们就须要为算法找到一组最合适的权重参数，这组权重参数就是咱们模型训练后获得的结果。网络
总的来讲，模型训练其实就是咱们使用大量的数据「调教」模型（算法）找出最优权重参数的过程。框架
那么如何才能进行模型训练呢？函数
2. 模型训练详解
以往咱们实现模型训练时经常须要面对很是繁杂的代码，要写好多步骤，才能正确的使程序运行起来。这些代码里面包含比较多的概念和接口使用，刚刚上手的同窗们通常须要花比较多的时间和精力来弄明白相关的知识和使用方法，使得许多开发者望而却步。学习
为了解决这种问题，同时知足新手开发者和资深开发者，既可以减小入门的难度，提高开发的效率，又能拥有较好的定制化能力。飞桨框架提供了两种模型训练的方法：一种是基于基础API的常规训练方式；另外一种是用paddle.Model对组建好的模型进行封装，经过高层API完成模型的训练与预测，能够在3-5行内，完成模型的训练。前者适合框架经验比较多的资深开发者，然后者极大的简化了学习和开发的代码量，对初学者用户很是友好。测试
接下来咱们就进行到详细的讲解环节吧。优化
Note: 高层API实现的模型训练与预测API均可以经过基础API实现，本文着重介绍高层API的训练方式，而后会将高层API拆解为基础API，方便同窗们对比学习。ui
2.1 模型训练配置
什么是模型训练配置呢？
这里是咱们作的一个概念抽象，在模型训练的时候咱们须要选用和指定咱们要使用的梯度优化器、损失函数计算方法和模型评估指标计算方法，那么咱们能够在正式启动训练以前对这些所需的必备内容作一个统一配置。
那么如何进行模型训练配置呢？
第一步就是咱们须要使用paddle.Model接口完成对模型的封装，将网络结构组合成一个可快速使用高层API进行训练和预测的类。完成模型的封装之后，咱们即可以使用model.prepare接口实现模型的配置。
为了完整的实现这个过程，咱们就一块儿回忆一下前几节课的内容，进行数据的处理和加载、模型组建、模型的封装以及模型配置吧。
数据的处理与加载
模型的组建In [1] import paddle import paddle.nn as nn paddle.__version__ '2.0.0-rc1'In [2] import paddle.vision.transforms as T from paddle.vision.datasets import MNIST # 数据预处理，这里用到了随机调整亮度、对比度和饱和度 transform = T.Normalize(mean=[127.5], std=[127.5]) # 数据加载，在训练集上应用数据预处理的操做 train_dataset = MNIST(mode='train', transform=transform) test_dataset = MNIST(mode='test', transform=transform) Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-images-idx3-ubyte.gz Begin to download Download finished Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-labels-idx1-ubyte.gz Begin to download ........ Download finished Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-images-idx3-ubyte.gz Begin to download Download finished Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-labels-idx1-ubyte.gz Begin to download .. Download finished
In [3] # 模型的组建 mnist = nn.Sequential( nn.Flatten(), nn.Linear(784, 512), nn.ReLU(), nn.Linear(512, 10))
模型的封装
In [5] # 将网络结构用 Model类封装成为模型 model = paddle.Model(mnist)
模型训练配置
In [6] # 为模型训练作准备，参数optimizer设置优化器，参数loss损失函数，参数metrics设置精度计算方式 model.prepare(optimizer=paddle.optimizer.Adam(parameters=model.parameters()), loss=paddle.nn.CrossEntropyLoss(), metrics=paddle.metric.Accuracy())
2.2 模型训练
完成模型的配置工做之后，咱们能够正式进入模型训练环节。那么如何进行模型训练呢？
飞桨框架进行模型训练有3种方式来完成：
-
全流程的训练启动，包含轮次迭代，数据集迭代，模型评估等，咱们可使用高层APImodel.fit接口来完成；
-
对于一些单轮训练内部定制化训练计算过程能够本身手写轮次和数据集迭代，经过高层APImodel.train_batch来实现单个批次数据的训练操做，好比训练GAN类型的网络，须要同时训练生成器和辨别器两个网络；
-
若是每一个计算细节都想自定义来完成，咱们也能够直接使用基础API来实现整个训练过程。
接下来咱们就给你们展现下3种方式的使用示例代码来具体了解一下接口的使用方式。
2.2.1 全流程模型训练model.fit接口
In [7] # 启动模型训练，指定训练数据集，设置训练轮次，设置每次数据集计算的批次大小，设置日志格式 model.fit(train_dataset, epochs=5, batch_size=64, verbose=1)The loss value printed in the log is the current step, and the metric is the average value of previous step. Epoch 1/5 step 10/938 [..............................] - loss: 0.9135 - acc: 0.3906 - ETA: 26s - 29ms/step /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/utils.py:77: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working return (isinstance(seq, collections.Sequence) and step 20/938 [..............................] - loss: 0.6332 - acc: 0.5844 - ETA: 20s - 22ms/step step 938/938 [==============================] - loss: 0.2774 - acc: 0.9140 - 9ms/step Epoch 2/5 step 938/938 [==============================] - loss: 0.0598 - acc: 0.9598 - 9ms/step Epoch 3/5 step 938/938 [==============================] - loss: 0.0467 - acc: 0.9688 - 9ms/step Epoch 4/5 step 938/938 [==============================] - loss: 0.0051 - acc: 0.9734 - 10ms/step Epoch 5/5 step 938/938 [==============================] - loss: 0.0877 - acc: 0.9775 - 9ms/step
2.2.2 单批次模型训练model.train_batch接口
那么咱们若是使用train_batch来实现整个训练过程代码是如何编写呢，下面咱们为你们展现一下。
In [8]
epoch_num = 5
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)
model_2 = paddle.Model(mnist)
model_2.prepare(optimizer=paddle.optimizer.Adam(parameters=model.parameters()),
loss=paddle.nn.CrossEntropyLoss(),
metrics=paddle.metric.Accuracy())
for epoch in range(epoch_num):
for batch_id, batch_data in enumerate(train_loader):
inputs = batch_data[0]
labels = batch_data[1]
out = model_2.train_batch([inputs], [labels])
if batch_id % 100 == 0:
print('epoch: {}, batch: {}, loss: {}, acc: {}'.format(epoch, batch_id, out[0], out[1]))epoch: 0, batch: 0, loss: [array([0.03247563], dtype=float32)], acc: [0.984375]
epoch: 0, batch: 100, loss: [array([0.07372712], dtype=float32)], acc: [0.984375]
epoch: 0, batch: 200, loss: [array([0.01235867], dtype=float32)], acc: [1.0]
epoch: 0, batch: 300, loss: [array([0.0119832], dtype=float32)], acc: [1.0]
epoch: 0, batch: 400, loss: [array([0.06045506], dtype=float32)], acc: [0.96875]
epoch: 0, batch: 500, loss: [array([0.14250125], dtype=float32)], acc: [0.953125]
epoch: 0, batch: 600, loss: [array([0.1298923], dtype=float32)], acc: [0.984375]
epoch: 0, batch: 700, loss: [array([0.23071991], dtype=float32)], acc: [0.96875]
epoch: 0, batch: 800, loss: [array([0.01316315], dtype=float32)], acc: [1.0]
epoch: 0, batch: 900, loss: [array([0.04338323], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 0, loss: [array([0.02602096], dtype=float32)], acc: [1.0]
epoch: 1, batch: 100, loss: [array([0.04736591], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 200, loss: [array([0.02717919], dtype=float32)], acc: [1.0]
epoch: 1, batch: 300, loss: [array([0.0559457], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 400, loss: [array([0.07509188], dtype=float32)], acc: [0.96875]
epoch: 1, batch: 500, loss: [array([0.02436191], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 600, loss: [array([0.04190612], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 700, loss: [array([0.07679007], dtype=float32)], acc: [0.953125]
epoch: 1, batch: 800, loss: [array([0.08825812], dtype=float32)], acc: [0.984375]
epoch: 1, batch: 900, loss: [array([0.18007225], dtype=float32)], acc: [0.953125]
epoch: 2, batch: 0, loss: [array([0.01614574], dtype=float32)], acc: [1.0]
epoch: 2, batch: 100, loss: [array([0.08536448], dtype=float32)], acc: [0.953125]
epoch: 2, batch: 200, loss: [array([0.00554189], dtype=float32)], acc: [1.0]
epoch: 2, batch: 300, loss: [array([0.07758754], dtype=float32)], acc: [0.96875]
epoch: 2, batch: 400, loss: [array([0.14692244], dtype=float32)], acc: [0.953125]
epoch: 2, batch: 500, loss: [array([0.00391791], dtype=float32)], acc: [1.0]
epoch: 2, batch: 600, loss: [array([0.10242598], dtype=float32)], acc: [0.953125]
epoch: 2, batch: 700, loss: [array([0.02423085], dtype=float32)], acc: [1.0]
epoch: 2, batch: 800, loss: [array([0.01023059], dtype=float32)], acc: [1.0]
epoch: 2, batch: 900, loss: [array([0.02060814], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 0, loss: [array([0.02141282], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 100, loss: [array([0.02560318], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 200, loss: [array([0.0649575], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 300, loss: [array([0.05790395], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 400, loss: [array([0.00305776], dtype=float32)], acc: [1.0]
epoch: 3, batch: 500, loss: [array([0.01016137], dtype=float32)], acc: [1.0]
epoch: 3, batch: 600, loss: [array([0.03847548], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 700, loss: [array([0.03043737], dtype=float32)], acc: [1.0]
epoch: 3, batch: 800, loss: [array([0.05468608], dtype=float32)], acc: [0.984375]
epoch: 3, batch: 900, loss: [array([0.07398543], dtype=float32)], acc: [0.984375]
epoch: 4, batch: 0, loss: [array([0.02614518], dtype=float32)], acc: [1.0]
epoch: 4, batch: 100, loss: [array([0.13249119], dtype=float32)], acc: [0.984375]
epoch: 4, batch: 200, loss: [array([0.05901051], dtype=float32)], acc: [0.96875]
epoch: 4, batch: 300, loss: [array([0.00670905], dtype=float32)], acc: [1.0]
epoch: 4, batch: 400, loss: [array([0.01490758], dtype=float32)], acc: [1.0]
epoch: 4, batch: 500, loss: [array([0.03787259], dtype=float32)], acc: [0.984375]
epoch: 4, batch: 600, loss: [array([0.02870828], dtype=float32)], acc: [0.984375]
epoch: 4, batch: 700, loss: [array([0.05344635], dtype=float32)], acc: [0.96875]
epoch: 4, batch: 800, loss: [array([0.01395352], dtype=float32)], acc: [1.0]
epoch: 4, batch: 900, loss: [array([0.00741577], dtype=float32)], acc: [1.0]
2.2.3 基础API实现模型训练
使用高层API实现模型训练只须要一行代码就能够搞定，比较方便。有的时候咱们的任务比较复杂，整个训练过程发现高层API的封装没法来达到预期目标，这个时候咱们也能够将上述用高层API实现的过程拆解成用基础API的实现。
In [9]
# dataset与mnist网络结构的定义与第一部份内容一致
# 用 DataLoader 实现数据加载
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)
mnist.train()
# 设置迭代次数
epoch_num = 5
# 设置优化器
optim = paddle.optimizer.Adam(parameters=model.parameters())
# 设置损失函数
loss_fn = paddle.nn.CrossEntropyLoss()
for epoch in range(epoch_num):
for batch_id, data in enumerate(train_loader):
inputs = data[0] # 训练数据
labels = data[1] # 训练数据标签
predicts = mnist(inputs) # 预测结果
# 计算损失 等价于 prepare 中loss的设置
loss = loss_fn(predicts, labels)
# 计算准确率 等价于 prepare 中metrics的设置
acc = paddle.metric.accuracy(predicts, labels)
# 反向传播
loss.backward()
if batch_id % 100 == 0:
print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))
# 更新参数
optim.step()
# 梯度清零
optim.clear_grad()epoch: 0, batch_id: 0, loss is: [0.0035142], acc is: [1.]
epoch: 0, batch_id: 100, loss is: [0.05046262], acc is: [0.96875]
epoch: 0, batch_id: 200, loss is: [0.05871505], acc is: [0.953125]
epoch: 0, batch_id: 300, loss is: [0.0398513], acc is: [0.984375]
epoch: 0, batch_id: 400, loss is: [0.02114001], acc is: [0.984375]
epoch: 0, batch_id: 500, loss is: [0.03265548], acc is: [0.984375]
epoch: 0, batch_id: 600, loss is: [0.02440762], acc is: [0.984375]
epoch: 0, batch_id: 700, loss is: [0.01399789], acc is: [1.]
epoch: 0, batch_id: 800, loss is: [0.00720934], acc is: [1.]
epoch: 0, batch_id: 900, loss is: [0.03644863], acc is: [0.96875]
epoch: 1, batch_id: 0, loss is: [0.04353006], acc is: [0.984375]
epoch: 1, batch_id: 100, loss is: [0.05608448], acc is: [0.96875]
epoch: 1, batch_id: 200, loss is: [0.01647361], acc is: [1.]
epoch: 1, batch_id: 300, loss is: [0.01115488], acc is: [1.]
epoch: 1, batch_id: 400, loss is: [0.0112262], acc is: [1.]
epoch: 1, batch_id: 500, loss is: [0.03933069], acc is: [0.984375]
epoch: 1, batch_id: 600, loss is: [0.02522848], acc is: [1.]
epoch: 1, batch_id: 700, loss is: [0.00357857], acc is: [1.]
epoch: 1, batch_id: 800, loss is: [0.02319109], acc is: [1.]
epoch: 1, batch_id: 900, loss is: [0.0019039], acc is: [1.]
epoch: 2, batch_id: 0, loss is: [0.02895336], acc is: [0.984375]
epoch: 2, batch_id: 100, loss is: [0.00558926], acc is: [1.]
epoch: 2, batch_id: 200, loss is: [0.01878058], acc is: [1.]
epoch: 2, batch_id: 300, loss is: [0.10249343], acc is: [0.96875]
epoch: 2, batch_id: 400, loss is: [0.00268026], acc is: [1.]
epoch: 2, batch_id: 500, loss is: [0.03055108], acc is: [0.984375]
epoch: 2, batch_id: 600, loss is: [0.0162295], acc is: [1.]
epoch: 2, batch_id: 700, loss is: [0.00872635], acc is: [1.]
epoch: 2, batch_id: 800, loss is: [0.00212811], acc is: [1.]
epoch: 2, batch_id: 900, loss is: [0.00818303], acc is: [1.]
epoch: 3, batch_id: 0, loss is: [0.0039459], acc is: [1.]
epoch: 3, batch_id: 100, loss is: [0.08966698], acc is: [0.953125]
epoch: 3, batch_id: 200, loss is: [0.01709959], acc is: [1.]
epoch: 3, batch_id: 300, loss is: [0.08004878], acc is: [0.984375]
epoch: 3, batch_id: 400, loss is: [0.14321736], acc is: [0.96875]
epoch: 3, batch_id: 500, loss is: [0.00930889], acc is: [1.]
epoch: 3, batch_id: 600, loss is: [0.0018653], acc is: [1.]
epoch: 3, batch_id: 700, loss is: [0.11423732], acc is: [0.953125]
epoch: 3, batch_id: 800, loss is: [0.00624554], acc is: [1.]
epoch: 3, batch_id: 900, loss is: [0.00426558], acc is: [1.]
epoch: 4, batch_id: 0, loss is: [0.00100102], acc is: [1.]
epoch: 4, batch_id: 100, loss is: [0.01645062], acc is: [1.]
epoch: 4, batch_id: 200, loss is: [0.00757009], acc is: [1.]
epoch: 4, batch_id: 300, loss is: [0.08349247], acc is: [0.984375]
epoch: 4, batch_id: 400, loss is: [0.00622703], acc is: [1.]
epoch: 4, batch_id: 500, loss is: [0.01024241], acc is: [1.]
epoch: 4, batch_id: 600, loss is: [0.06242872], acc is: [0.96875]
epoch: 4, batch_id: 700, loss is: [0.00065227], acc is: [1.]
epoch: 4, batch_id: 800, loss is: [0.00531822], acc is: [1.]
epoch: 4, batch_id: 900, loss is: [0.07632213], acc is: [0.984375]
2.3 模型评估
模型训练结束后，咱们获得了一组精度看起来还不错的模型参数，可是这组参数到底好仍是很差还须要咱们去具体作下评估。
那么何为模型评估呢？
模型评估其实就是使用咱们预留的验证数据放到所获得的模型中进行实际的预测并基于标签进行校验，来看模型在验证集上的精度表现，模型的好坏直接影响咱们的目标任务是否能够实现。模型评估的代码实如今高层API中也很是地简单，咱们事先定义好用于评估使用的数据集后，能够简单的调用飞桨高层API提供的model.evaluate接口或model.eval_batch接口完成模型评估操做，其中model.eval_batch接口是在一个批次的数据上进行评估测试。
操做结束后会根据prepare接口配置的loss和metric来进行相关指标计算返回。
2.3.1 全流程评估model.evaluate接口
In [10] # 用 model.evaluate 在测试集上对模型进行验证 eval_result = model.evaluate(test_dataset, verbose=1) Eval begin... The loss value printed in the log is the current batch, and the metric is the average value of previous step. step 10000/10000 [==============================] - loss: 0.0000e+00 - acc: 0.9766 - 2ms/step Eval samples: 10000
2.3.2 单批次model.eval_batch接口
In [11]
# 用 model.eval_batch 在测试集一个批次的数据上进行验证
eval_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)
for batch_id, batch_data in enumerate(eval_loader):
inputs = batch_data[0]
labels = batch_data[1]
out = model.eval_batch([inputs],[labels])
if batch_id % 100 == 0:
print('batch_id: {}, loss: {}, acc: {}'.format(batch_id, out[0], out[1]))batch_id: 0, loss: [array([0.00120578], dtype=float32)], acc: [1.0]
batch_id: 100, loss: [array([0.00050124], dtype=float32)], acc: [1.0]
2.3.3 基础API实现模型评估
相似地，咱们来了解一下使用基础API如何实现模型评估功能。以下代码所示，和模型训练功能类似，使用基础API实现模型评估须要数据的加载和读取，损失函数和精度的定义，须要十几行代码，使用高层API只须要一行代码就能够完成模型的评估。
In [12]
# 加载测试数据集
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)
loss_fn = paddle.nn.CrossEntropyLoss()
mnist.eval()
for batch_id, data in enumerate(test_loader()):
inputs = data[0] # 测试数据
labels = data[1] # 测试数据标签
predicts = mnist(inputs) # 预测结果
# 计算损失与精度
loss = loss_fn(predicts, labels)
acc = paddle.metric.accuracy(predicts, labels)
# 打印信息
if batch_id % 100 == 0:
print("batch_id: {}, loss is: {}, acc is: {}".format(batch_id, loss.numpy(), acc.numpy()))batch_id: 0, loss is: [0.00120578], acc is: [1.]
batch_id: 100, loss is: [0.00050124], acc is: [1.]
2.4 模型预测
从数据的处理到模型的组建再到模型的训练，其实咱们的终极任务是但愿咱们的模型能够真正的用起来。若是是模型评估的结果符合咱们的指望，咱们就模型就能够真正的使用了，那就是模型预测。那么如何进行模型预测呢？飞桨高层API中提供了model.predict接口和model.predict_batch接口来方便用户对训练好的模型进行预测验证，只须要基于训练好的模型将须要进行预测测试的数据放到接口中进行计算便可，接口会把模型计算获得的预测结果返回，从而完成咱们的任务。
2.4.1 使用高层API全流程预测接口 model.predict
In [13] # 用 predict 在测试集上对模型进行测试 test_result = model.predict(test_dataset) # 能够在后面继续加上本身对于预测数据的处理 Predict begin... step 10000/10000 [==============================] - 2ms/step Predict samples: 10000
2.4.2 使用高层API单批次预测接口 model.predict_batch
In [14]
# 用 predict_batch 在测试集一个批次的数据上进行测试
predict_loader = paddle.io.DataLoader(test_dataset, batch_size=64)
for batch_id, batch_data in enumerate(predict_loader):
inputs = batch_data[0]
test_result = model.predict_batch([inputs])
# 能够在后面继续加上本身对于预测数据的处理
print("predict finished")
predict finished
2.4.3 使用基础API来完成模型预测
若是将高层API的实现拆解，使用基础API来操做的话，那么对应的代码以下：
In [15]
# 定义测试数据集加载器
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64)
# 将网络结构的模式变成评估
mnist.eval()
# 加载数据进行迭代预测
for batch_id, batch_data in enumerate(test_loader):
inputs = data[0]
predicts = mnist(inputs)
# 能够在后面继续加上本身对于预测数据的处理
print("predict finished")
predict finished
总结
本节课首先为你们详细的讲解了什么是模型训练以及为何要进行模型训练。而后和同窗们一块儿学习了如何进行模型训练，而且在学习过程当中，咱们还复习了数据的预处理和加载以及模型组建等前面所学的课程，详细介绍了飞桨框架提供的4个模型训练的功能，且将高层API的代码实现拆解成基础API，方便同窗们对比学习。到这里，同窗们已经基本掌握了模型训练的一整套流程了，课后同窗们必定要多练习，本身完成一个小项目。为了让同窗们的学习节奏变的紧凑，下周咱们将会发布两篇高层API的高阶用法的内容，你们若是有什么但愿实现的模型或者感兴趣的趣味案例均可以在评论区留言，咱们将会在后续的课程中给你们安排上哈，今天的课程到这里就结束了，我是雨哥，下节课见~
下载安装命令 ## CPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/cpu paddlepaddle ## GPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/gpu paddlepaddle-gpu
回顾往期：
有任何问题能够在本项目中评论或到飞桨Github仓库（连接）提交Issue。
同时欢迎扫码加入飞桨框架高层API技术交流群
本文同步分享在 博客“飞桨PaddlePaddle”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。