paddle17-模型訓練和預測 & 資源配置(多卡、分布式)

本文轉載自查看原文 2021-05-08 22:11 383 paddle

訓練與預測

在完成數據預處理，數據加載與模型的組建后，你就可以進行模型的訓練與預測了。飛槳框架提供了兩種訓練與預測的方法，一種是用paddle.Model對模型進行封裝，通過高層API如Model.fit()、Model.evaluate()、Model.predict()等完成模型的訓練與預測；另一種就是基於基礎API常規的訓練方式。

高層API實現的模型訓練與預測如Model.fit()、Model.evaluate()、Model.predict()都可以通過基礎API實現，本文先介紹高層API的訓練方式，然后會將高層API拆解為基礎API的方式，方便對比學習。

一、訓練前准備

在封裝模型前，需要先完成數據的加載與模型的組建，由於這一部分高層API與基礎API通用，所以都可用下面的代碼實現：

import paddle
from paddle.vision.transforms import ToTensor

# 加載數據集
train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())

# 定義網絡結構
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(1, -1),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

通過上述的代碼，你就完成了訓練集與測試集的構建，並創建了一個 mnist的網絡模型。下面分別用兩種方式完成模型的訓練與預測。

二、通過paddle.Model訓練與預測（高層API）

你可以使用paddle.Model完成模型的封裝，將網絡結構組合成一個可快速使用高層API進行訓練和預測的對象。代碼如下：

model = paddle.Model(mnist)

概述
增加了paddle.Model高層API，大部分任務可以使用此API用於簡化訓練、評估、預測類代碼開發。注意區別Model和Net概念，Net是指繼承paddle.nn.Layer的網絡結構；而Model是指持有一個Net對象，同時指定損失函數、優化算法、評估指標的可訓練、評估、預測的實例。具體參考高層API的代碼示例。

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()

# Mnist繼承paddle.nn.Layer屬於Net，model包含了訓練功能
model = paddle.Model(lenet)

# 設置訓練模型所需的optimizer, loss, metric
model.prepare(
    paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    paddle.nn.CrossEntropyLoss(),
    paddle.metric.Accuracy()
    )

# 啟動訓練
model.fit(train_dataset, epochs=2, batch_size=64, log_freq=200)

# 啟動評估
model.evaluate(test_dataset, log_freq=20, batch_size=64)

2.1 用Model.prepare()配置模型

用paddle.Model完成模型的封裝后，在訓練前，需要對模型進行配置，通過Model.prepare接口來對訓練進行提前的配置准備工作，包括設置模型優化器，Loss計算方法，精度計算方法等。

# 為模型訓練做准備，設置優化器，損失函數和精度計算方式
model.prepare(optimizer=paddle.optimizer.Adam(parameters=model.parameters()),
              loss=paddle.nn.CrossEntropyLoss(),
              metrics=paddle.metric.Accuracy())

2.2 用Model.fit()訓練模型

做好模型訓練的前期准備工作后，調用fit()接口來啟動訓練過程，需要指定至少3個關鍵參數：訓練數據集，訓練輪次和單次訓練數據批次大小。

# 啟動模型訓練，指定訓練數據集，設置訓練輪次，設置每次數據集計算的批次大小，設置日志格式
model.fit(train_dataset,
          epochs=5,
          batch_size=64,
          verbose=1)

2.3 用Model.evaluate()評估模型

對於訓練好的模型進行評估可以使用evaluate接口，事先定義好用於評估使用的數據集后，直接調用evaluate接口即可完成模型評估操作，結束后根據在prepare中loss和metric的定義來進行相關評估結果計算返回。

返回格式是一個字典： * 只包含loss，{'loss': xxx} * 包含loss和一個評估指標，{'loss': xxx, 'metric name': xxx} * 包含loss和多個評估指標，{'loss': xxx, 'metric name1': xxx, 'metric name2': xxx}

# 用 evaluate 在測試集上對模型進行驗證
eval_result = model.evaluate(test_dataset, verbose=1)

2.4 用Model.predict()預測模型

高層API中提供了predict接口來方便用戶對訓練好的模型進行預測驗證，只需要基於訓練好的模型將需要進行預測測試的數據放到接口中進行計算即可，接口會將經過模型計算得到的預測結果進行返回。

返回格式是一個list，元素數目對應模型的輸出數目： * 模型是單一輸出：[(numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n)] * 模型是多輸出：[(numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n), (numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n), …]

numpy_ndarray_n是對應原始數據經過模型計算后得到的預測數據，數目對應預測數據集的數目。

# 用 predict 在測試集上對模型進行測試
test_result = model.predict(test_dataset)

三、通過基礎API實現模型的訓練與預測

除了通過第一部分的高層API實現模型的訓練與預測，飛槳框架也同樣支持通過基礎API對模型進行訓練與預測。簡單來說，Model.prepare()、Model.fit()、Model.evaluate()、Model.predict()都是由基礎API封裝而來。下面通過拆解高層API到基礎API的方式，來了解如何用基礎API完成模型的訓練與預測。

概述

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()
loss_fn = paddle.nn.CrossEntropyLoss()

# 加載訓練集 batch_size 設為 64
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

def train():
    epochs = 2
    adam = paddle.optimizer.Adam(learning_rate=0.001, parameters=lenet.parameters())
    # 用Adam作為優化函數
    for epoch in range(epochs):
        for batch_id, data in enumerate(train_loader()):
            x_data = data[0]
            y_data = data[1]
            predicts = lenet(x_data)
            acc = paddle.metric.accuracy(predicts, y_data)
            loss = loss_fn(predicts, y_data)
            loss.backward()
            if batch_id % 100 == 0:
                print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))
            adam.step()
            adam.clear_grad()

# 啟動訓練
train()

3.1 拆解Model.prepare()、Model.fit()-- 用基礎API訓練模型

飛槳框架通過基礎API對模型進行訓練與預測，對應第一部分的Model.prepare()與Model.fit()：

# dataset與mnist的定義與第一部分內容一致

# 用 DataLoader 實現數據加載
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

mnist.train()

# 設置迭代次數
epochs = 5

# 設置優化器
optim = paddle.optimizer.Adam(parameters=mnist.parameters())
# 設置損失函數
loss_fn = paddle.nn.CrossEntropyLoss()

for epoch in range(epochs):
    for batch_id, data in enumerate(train_loader()):

        x_data = data[0]            # 訓練數據
        y_data = data[1]            # 訓練數據標簽
        predicts = mnist(x_data)    # 預測結果

        # 計算損失 等價於 prepare 中loss的設置
        loss = loss_fn(predicts, y_data)

        # 計算准確率 等價於 prepare 中metrics的設置
        acc = paddle.metric.accuracy(predicts, y_data)

        # 下面的反向傳播、打印訓練信息、更新參數、梯度清零都被封裝到 Model.fit() 中

        # 反向傳播
        loss.backward()

        if (batch_id+1) % 900 == 0:
            print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id+1, loss.numpy(), acc.numpy()))

        # 更新參數
        optim.step()

        # 梯度清零
        optim.clear_grad()

result:

epoch: 0, batch_id: 900, loss is: [0.29550618], acc is: [0.90625]
epoch: 1, batch_id: 900, loss is: [0.05875912], acc is: [0.984375]
epoch: 2, batch_id: 900, loss is: [0.05824642], acc is: [0.96875]
epoch: 3, batch_id: 900, loss is: [0.02940615], acc is: [1.]
epoch: 4, batch_id: 900, loss is: [0.05713747], acc is: [0.984375]

3.2 拆解Model.evaluate()-- 用基礎API驗證模型

飛槳框架通過基礎API對模型進行驗證，對應第一部分的Model.evaluate():

# 加載測試數據集
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()):

    x_data = data[0]            # 測試數據
    y_data = data[1]            # 測試數據標簽
    predicts = mnist(x_data)    # 預測結果

    # 計算損失與精度
    loss = loss_fn(predicts, y_data)
    acc = paddle.metric.accuracy(predicts, y_data)

    # 打印信息
    if (batch_id+1) % 30 == 0:
        print("batch_id: {}, loss is: {}, acc is: {}".format(batch_id+1, loss.numpy(), acc.numpy()))

result:

batch_id: 30, loss is: [0.15860887], acc is: [0.953125]
batch_id: 60, loss is: [0.21005578], acc is: [0.921875]
batch_id: 90, loss is: [0.0889321], acc is: [0.953125]
batch_id: 120, loss is: [0.00115552], acc is: [1.]
batch_id: 150, loss is: [0.12016675], acc is: [0.984375]

3.3 拆解Model.predict()-- 用基礎API測試模型

飛槳框架通過基礎API對模型進行測試，對應第一部分的Model.predict():

# 加載測試數據集
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)

mnist.eval()
for batch_id, data in enumerate(test_loader()):
    x_data = data[0]
    predicts = mnist(x_data)
    # 獲取預測結果
print("predict finished")

資源配置: 多卡啟動、分布式訓練

飛槳框架2.0增加paddle.distributed.spawn函數來啟動單機多卡訓練，同時原有的paddle.distributed.launch的方式依然保留。

一、launch啟動

1.1 高層API場景

當調用paddle.Model高層API來實現訓練時，想要啟動單機多卡訓練非常簡單，代碼不需要做任何修改，只需要在啟動時增加一下參數-m paddle.distributed.launch。

# 單機單卡啟動，默認使用第0號卡        不需要指定GPU運行,自動放到GPU ?   數據+模型 不用設置CUDA？ 
$ python train.py

# 單機多卡啟動，默認使用當前可見的所有卡
$ python -m paddle.distributed.launch train.py

# 單機多卡啟動，設置當前使用的第0號和第1號卡
$ python -m paddle.distributed.launch --gpus='0,1' train.py

# 單機多卡啟動，設置當前使用第0號和第1號卡
$ export CUDA_VISIBLE_DEVICES=0,1
$ python -m paddle.distributed.launch train.py

1.2 基礎API場景

如果使用基礎API實現訓練，想要啟動單機多卡訓練，需要對單機單卡的代碼進行3處修改，具體如下：

import paddle
# 第1處改動 導入分布式訓練所需的包
import paddle.distributed as dist

# 加載數據集
train_dataset = paddle.vision.datasets.MNIST(mode='train')
test_dataset = paddle.vision.datasets.MNIST(mode='test')

# 定義網絡結構
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(1, -1),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

# 第2處改動，初始化並行環境
dist.init_parallel_env()

# 用 DataLoader 實現數據加載
train_loader = paddle.io.DataLoader(train_dataset, batch_size=32, shuffle=True)

# 第3處改動，增加paddle.DataParallel封裝
mnist = paddle.DataParallel(mnist)
mnist.train()

# 設置迭代次數
epochs = 5

# 設置優化器
optim = paddle.optimizer.Adam(parameters=model.parameters())

for epoch in range(epochs):
    for batch_id, data in enumerate(train_loader()):

        x_data = data[0]            # 訓練數據
        y_data = data[1]            # 訓練數據標簽
        predicts = mnist(x_data)    # 預測結果

        # 計算損失 等價於 prepare 中loss的設置
        loss = paddle.nn.functional.cross_entropy(predicts, y_data)

        # 計算准確率 等價於 prepare 中metrics的設置
        acc = paddle.metric.accuracy(predicts, y_data)

        # 下面的反向傳播、打印訓練信息、更新參數、梯度清零都被封裝到 Model.fit() 中

        # 反向傳播
        loss.backward()

        if (batch_id+1) % 1800 == 0:
            print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))

        # 更新參數
        optim.step()

        # 梯度清零
        optim.clear_grad()

修改完后保存文件，然后使用跟高層API相同的啟動方式即可。注意：單卡訓練不支持調用init_parallel_env，請使用以下幾種方式進行分布式訓練。

# 單機多卡啟動，默認使用當前可見的所有卡
$ python -m paddle.distributed.launch train.py

# 單機多卡啟動，設置當前使用的第0號和第1號卡
$ python -m paddle.distributed.launch --gpus '0,1' train.py

# 單機多卡啟動，設置當前使用第0號和第1號卡
$ export CUDA_VISIBLE_DEVICES=0,1
$ python -m paddle.distributed.launch train.py

二、spawn啟動

launch方式啟動訓練，以文件為單位啟動多進程，需要用戶在啟動時調用paddle.distributed.launch，對於進程的管理要求較高。飛槳框架2.0版本增加了spawn啟動方式，可以更好地控制進程，在日志打印、訓練退出時更友好。使用示例如下：

from __future__ import print_function

import paddle
import paddle.nn as nn
import paddle.optimizer as opt
import paddle.distributed as dist

class LinearNet(nn.Layer):
    def __init__(self):
        super(LinearNet, self).__init__()
        self._linear1 = nn.Linear(10, 10)
        self._linear2 = nn.Linear(10, 1)

    def forward(self, x):
        return self._linear2(self._linear1(x))

def train(print_result=False):

    # 1. 初始化並行訓練環境
    dist.init_parallel_env()

    # 2. 創建並行訓練 Layer 和 Optimizer
    layer = LinearNet()
    dp_layer = paddle.DataParallel(layer)

    loss_fn = nn.MSELoss()
    adam = opt.Adam(
        learning_rate=0.001, parameters=dp_layer.parameters())

    # 3. 運行網絡
    inputs = paddle.randn([10, 10], 'float32')
    outputs = dp_layer(inputs)
    labels = paddle.randn([10, 1], 'float32')
    loss = loss_fn(outputs, labels)

    if print_result is True:
        print("loss:", loss.numpy())

    loss.backward()

    adam.step()
    adam.clear_grad()

# 使用方式1：僅傳入訓練函數
# 適用場景：訓練函數不需要任何參數，並且需要使用所有當前可見的GPU設備並行訓練
if __name__ == '__main__':
    dist.spawn(train)

# 使用方式2：傳入訓練函數和參數
# 適用場景：訓練函數需要一些參數，並且需要使用所有當前可見的GPU設備並行訓練
if __name__ == '__main__':
    dist.spawn(train, args=(True,))

# 使用方式3：傳入訓練函數、參數並指定並行進程數
# 適用場景：訓練函數需要一些參數，並且僅需要使用部分可見的GPU設備並行訓練，例如：
# 當前機器有8張GPU卡 {0,1,2,3,4,5,6,7}，此時會使用前兩張卡 {0,1}；
# 或者當前機器通過配置環境變量 CUDA_VISIBLE_DEVICES=4,5,6,7，僅使4張
# GPU卡可見，此時會使用可見的前兩張卡 {4,5}
if __name__ == '__main__':
    dist.spawn(train, args=(True,), nprocs=2)

# 使用方式4：傳入訓練函數、參數、指定進程數並指定當前使用的卡號
# 使用場景：訓練函數需要一些參數，並且僅需要使用部分可見的GPU設備並行訓練，但是
# 可能由於權限問題，無權配置當前機器的環境變量，例如：當前機器有8張GPU卡
# {0,1,2,3,4,5,6,7}，但你無權配置CUDA_VISIBLE_DEVICES，此時可以通過
# 指定參數 gpus 選擇希望使用的卡，例如 gpus='4,5'，
# 可以指定使用第4號卡和第5號卡
if __name__ == '__main__':
    dist.spawn(train, nprocs=2, gpus='4,5')

🌟 framework 相關 14個

1.paddle.CPUPlace() 一個設備描述符，指定CPUPlace則Tensor將被自動分配在該設備上，並且模型將會運行在該設備上.
```
cpu_place = paddle.CPUPlace()
```

2.paddle.CUDAPinnerPlace() 通過數據並行模型執行靜態圖模型

一個設備描述符，它所指代的頁鎖定內存由 CUDA 函數 cudaHostAlloc() 在主機內存上分配，主機的操作系統將不會對這塊內存進行分頁和交換操作，可以通過直接內存訪問技術訪問，加速主機和 GPU 之間的數據拷貝

3.paddle.CUDAPlace() 一個設備描述符，表示一個分配或將要分配 Tensor 或 LoDTensor 的 GPU 設備

如果通過
CUDAPlace 是一個設備描述符，表示一個分配或將要分配 Tensor 或 LoDTensor 的 GPU 設備。 每個 CUDAPlace 有一個 dev_id （設備id）來表明當前的 CUDAPlace 所代表的顯卡編號，編號從 0 開始。 dev_id 不同的 CUDAPlace 所對應的內存不可相互訪問。 這里編號指的是可見顯卡的邏輯編號，而不是顯卡實際的編號。 可以通過 CUDA_VISIBLE_DEVICES 環境變量限制程序能夠使用的 GPU 設備，程序啟動時會遍歷當前的可見設備，並從 0 開始為這些設備編號。 如果沒有設置 CUDA_VISIBLE_DEVICES，則默認所有的設備都是可見的，此時邏輯編號與實際編號是相同的。

place = paddle.CUDAPlace(0)

4.類class paddle.DataParallel(layers, strategy=None, comm_buffer_size=25, last_comm_buffer_size=1) 通過數據並行模式執行動態圖模型

返回: 支持數據並行的 Layer, 返回類型: Layer類型  

目前，DataParallel 僅支持以多進程的方式執行動態圖模型。  
支持兩種使用方式:    
    1. 使用 paddle.distributed.spawn 方法啟動, 例如: 
        ```
        python demo.py (spawn need to be called in __main__ method)
        ```
    2. 使用paddle.distributed.launch 方法啟動,例如: 
        ```
        python -m paddle.distributed.launch –selected_gpus=0,1 demo.py

        其中 demo.py 腳本的代碼可以是下面的示例代碼。
        ```


class LinearNet(nn.Layer):
    def __init__(self):
        super(LinearNet, self).__init__()
        self._linear1 = nn.Linear(10, 10)
        self._linear2 = nn.Linear(10, 1)

    def forward(self, x):
        return self._linear2(self._linear1(x))

def train():
    # 1. initialize parallel environment
    dist.init_parallel_env()

    # 2. create data parallel layer & optimizer
    layer = LinearNet()
    dp_layer = paddle.DataParallel(layer)

    loss_fn = nn.MSELoss()
    adam = opt.Adam(
        learning_rate=0.001, parameters=dp_layer.parameters())

    # 3. run layer
    inputs = paddle.randn([10, 10], 'float32')
    outputs = dp_layer(inputs)
    labels = paddle.randn([10, 1], 'float32')
    loss = loss_fn(outputs, labels)

    loss.backward()

    adam.step()
    adam.clear_grad()

if __name__ == '__main__':
    # 1. start by ``paddle.distributed.spawn`` (default)
    dist.spawn(train, nprocs=2)
    # 2. start by ``paddle.distributed.launch``
    # train()

方法: state_dict ( destination=None, include_sublayers=True )

返回：dict， 包含所有parameters和持久的buffers的dict
獲取當前層及其子層的所有parameters和持久的buffers。並將所有parameters和buffers存放在dict結構中。

* destination (dict, 可選) - 如果提供 destination ，則所有參數和持久的buffers都將存放在 destination 中。 默認值：None。   
* include_sublayers (bool, 可選) - 如果設置為True，則包括子層的參數和buffers。默認值：True。

set_state_dict ( state_dict, include_sublayers=True, use_structured_name=True )

返回: 無
根據傳入的 state_dict 設置parameters和持久的buffers。 所有parameters和buffers將由 state_dict 中的 Tensor 設置。   

* state_dict (dict) - 包含所有parameters和可持久性buffers的dict
* include_sublayers (bool, 可選) - 如果設置為True，則還包括子Layer的parameters和buffers。 默認值：True   
* use_structured_name (bool, 可選) - 如果設置為True，將使用Layer的結構性變量名作為dict的key，否則將使用Parameter或者Buffer的變量名作為key。默認值：True

5.paddle.disable_static(place=None) 關閉靜態圖模式

place (paddle.CPUPlace|paddle.CUDAPlace，可選) - 動態圖運行時的設備。默認值為 None , 此時，會根據paddle的版本自動判斷

print(paddle.in_dynamiic_mode())    True， pp2.0默認動態圖模式  
paddle.enable_static()  
print(paddle.in_dynamic_mode())        False, 已經開啟靜態圖  

paddle.disable_static()     
print(paddle.in_dynamic_mode())         True，已經關閉靜態圖

6.paddle.enable_static() 開啟靜態圖模式

7.paddle.get_default_dtype() 得到當前全局的 dtype, 該初始值是 float32

返回: string，這個全局dtype僅支持float16、float32、float64
paddle.get_default_dtype()

8.不懂 paddle.grad() 對於每個inputs, 計算所有 outputs相對於其的梯度和
9.paddle.in_dynamic_mode() 查看paddle 當前是否在動態圖模式中
10.paddle.save(obj, path, pickle_protocol=2) 將對象實例obj保存到指定路徑中。【模型保存 & 導入】
11.paddle.load(path, **configs) 從指定路徑載入可以在 paddle中使用的對象實例。【模型保存 & 導入】

12.paddle.ParamAttr() 創建一個參數屬性對象
class paddle.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False, need_clip=True)
```
返回: 表示參數屬性的對象。

  類, 創建一個參數屬性對象，用戶可以設置參數的名稱、初始化方式、學習率、正則化規則、是否需要訓練、梯度裁剪方式、是否做模型平均等屬性。   
  一般用在paddle.nn*  下面的模型初始化過程中,進行 類的實例化  
  * name: str,可選， 參數的名稱。 默認值: None， 表示框架自動創建參數的名稱。  
  * initializer: Initializer, 可選，參數的初始化方式， 默認:None,表示權重參數采用Xavier初始化方式,偏置參數全0   
  * learning_rate: float, 可選, 參數的學習率。  實際參數的學習率等於全局學習率乘以參數的學習率，再乘以learning rate schedule的系數。   
  * regularizer: 可選，正則化方法,支持兩種正則化策略: api_paddle_regularizer_L1Decay 、 api_paddle_regularizer_L2Decay, 如果在 optimizer (例如 api_paddle_optimizer_SGD ) 中也 設置了正則化，optimizer 中的正則化將被忽略。默認值為None，表示沒有正則化。      
  * trainanle: bool, 可選, 參數是否需要訓練。 默認值為True.   
  * do_model_average: bool, 可選, 是否做模型平均， 默認值: True. 僅在 ExponentialMovingAverage 下使用。   
  * need_clip: bool, 可選, 參數是否進行梯度裁剪。 默認值True, 表示該參數的梯度會根據優化器中中設置的裁剪規則進行裁剪。   

  weight_attr = paddle.ParamAttr(name="weight",
                                  learning_rate=0.5,
                                  regularizer=paddle.regularizer.L2Decay(1.0),
                                  trainable=True)
  print(weight_attr.name) # "weight"
  paddle.nn.Linear(3, 4, weight_attr=weight_attr)
  ```

13.paddle.no_grad() 創建一個上下文來禁止動態圖梯度計算。

在此模式下，每次計算的結果都將具有stop_gradient=True。也可以用作一個裝飾器（需要創建實例對象作為裝飾器）

# 用作生成器
data = np.array([[2, 3], [4, 5]]).astype('float32')
l0 = paddle.nn.Linear(2, 2)  # l0.weight.gradient() is None
l1 = paddle.nn.Linear(2, 2)
with paddle.no_grad():
    # l1.weight.stop_gradient is False
    tmp = l1.weight * 2  # tmp.stop_gradient is True
x = paddle.to_tensor(data)
y = l0(x) + tmp
o = l1(y)
o.backward()
print(tmp.gradient() is None)  # True
print(l0.weight.gradient() is None)  # False

# 用作裝飾器
@paddle.no_grad()
def test_layer():
    inp = np.ones([3, 1024], dtype='float32')
    t = paddle.to_tensor(inp)
    linear1 = paddle.nn.Linear(1024, 4, bias_attr=False)
    linear2 = paddle.nn.Linear(4, 4)
    ret = linear1(t)
    dy_ret = linear2(ret)

test_layer()

14.paddle.set_default_dtype() 設置默認的全局dtype,默認的全局dtype最初是float32
```
paddle.set_default_dtype("float32")
```

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 PaddlePaddle使用多卡（分布式）訓練 Longhorn，企業級雲原生容器分布式存儲 - K8S 資源配置示例使用Pytorch進行單機多卡分布式訓練分布式訓練 [源碼解析] 深度學習分布式訓練框架 horovod (17) --- 彈性訓練之容錯深度學習分布式訓練及CTR預估模型應用 pytorch 分布式訓練 PyTorch分布式訓練 Pytorch 分布式訓練 pytorch分布式訓練