課程簡介：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源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。