文章目錄

• 1. Pytorch 是什么
• • 1.1 安裝
  • 1.2 張量(Tensors)
  • • 1.2.1 聲明和定義
    • 1.2.2 操作(Operations)
  • 1.3 和 Numpy 數(shù)組的轉(zhuǎn)換
  • • 1.3.1 Tensor 轉(zhuǎn)換為 Numpy 數(shù)組
    • 1.3.2 Numpy 數(shù)組轉(zhuǎn)換為 Tensor
  • 1.4. CUDA 張量
• 2. autograd
• • 2.1 張量
  • 2.2 梯度
• 3. 神經(jīng)網(wǎng)絡(luò)
• • 3.1 定義網(wǎng)絡(luò)
  • 3.2 損失函數(shù)
  • 3.3 反向傳播
  • 3.4 更新權(quán)重
• 4. 訓(xùn)練分類器
• 4.1 訓(xùn)練數(shù)據(jù)
• • 4.2 訓(xùn)練圖片分類器
  • • 4.2.1 加載和歸一化 CIFAR10
    • 4.2.2 構(gòu)建一個卷積神經(jīng)網(wǎng)絡(luò)
    • 4.2.3 定義損失函數(shù)和優(yōu)化器
    • 4.2.4 訓(xùn)練網(wǎng)絡(luò)
    • 4.2.5 測試模型性能
  • 4.3 在 GPU 上訓(xùn)練
• 5. 數(shù)據(jù)并行
• • 5.1 導(dǎo)入和參數(shù)
  • 5.2 構(gòu)建一個假數(shù)據(jù)集
  • 5.3 簡單的模型
  • 5.4 創(chuàng)建模型和數(shù)據(jù)平行
  • 5.5 運行模型
  • 5.6 運行結(jié)果
  • 5.7 總結(jié)

1. Pytorch 是什么

Pytorch 是一個基于 Python 的科學(xué)計算庫，它面向以下兩種人群：

希望將其代替 Numpy 來利用 GPUs 的威力；
一個可以提供更加靈活和快速的深度學(xué)習(xí)研究平臺。

1.1 安裝

略

1.2 張量(Tensors)

Pytorch 的一大作用就是可以代替 Numpy 庫，所以首先介紹 Tensors ，也就是張量，它相當(dāng)于 Numpy 的多維數(shù)組(ndarrays)。兩者的區(qū)別就是 Tensors 可以應(yīng)用到 GPU 上加快計算速度。

首先導(dǎo)入必須的庫，主要是 torch

from __future__ import print_function import torch

1.2.1 聲明和定義

首先是對 Tensors 的聲明和定義方法，分別有以下幾種：

torch.empty(): 聲明一個未初始化的矩陣。

# 創(chuàng)建一個 5*3 的矩陣 x = torch.empty(5, 3) print(x) tensor([[-1.5295e+17, 6.0536e-43, -7.3276e-34],[ 6.0536e-43, -1.8921e+17, 6.0536e-43],[-7.3276e-34, 6.0536e-43, -1.5295e+17],[ 6.0536e-43, -4.4784e-38, 6.0536e-43],[-1.8921e+17, 6.0536e-43, -7.3277e-34]])

torch.rand()：隨機初始化一個矩陣

# 創(chuàng)建一個隨機初始化的 5*3 矩陣 rand_x = torch.rand(5, 3) print(rand_x) tensor([[0.1696, 0.8806, 0.9775],[0.2274, 0.8217, 0.6517],[0.2400, 0.4360, 0.9738],[0.6987, 0.4369, 0.4041],[0.3466, 0.5234, 0.9666]])

torch.zeros()：創(chuàng)建數(shù)值皆為 0 的矩陣

# 創(chuàng)建一個數(shù)值皆是 0，類型為 long 的矩陣 zero_x = torch.zeros(5, 3, dtype=torch.long) print(zero_x) tensor([[0, 0, 0],[0, 0, 0],[0, 0, 0],[0, 0, 0],[0, 0, 0]])

類似的也可以創(chuàng)建數(shù)值都是 1 的矩陣，調(diào)用 torch.ones

torch.tensor()：直接傳遞 tensor 數(shù)值來創(chuàng)建

# tensor 數(shù)值是 [5.5, 3] tensor1 = torch.tensor([5.5, 3]) print(tensor1) #tensor0 = torch.tensor([[1,2],[3,4],[5,6]]) #print(tensor0) tensor([5.5000, 3.0000])

除了上述幾種方法，還可以根據(jù)已有的 tensor 變量創(chuàng)建新的 tensor 變量，這種做法的好處就是可以保留已有 tensor 的一些屬性，包括尺寸大小、數(shù)值屬性，除非是重新定義這些屬性。相應(yīng)的實現(xiàn)方法如下：

tensor.new_ones(row,cloumn,dtype)：方法需要輸入尺寸大小

# 顯示定義新的尺寸是 5*3，數(shù)值類型是 torch.double tensor2 = tensor1.new_ones(5, 3, dtype=torch.double) # new_* 方法需要輸入 tensor 大小 print(tensor2) tensor([[1., 1., 1.],[1., 1., 1.],[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]], dtype=torch.float64)

torch.randn_like(old_tensor)：保留相同的尺寸大小

# 修改數(shù)值類型 tensor3 = torch.randn_like(tensor2, dtype=torch.float) print('tensor3: ', tensor3) tensor3: tensor([[-1.0496, -0.9908, -0.4547],[ 0.6977, -0.9557, -0.8079],[ 0.3000, 2.5064, 2.8341],[ 1.6385, 0.3932, -1.0152],[-1.4500, 1.0717, -0.1984]])

輸出結(jié)果，這里是根據(jù)上個方法聲明的 tensor2 變量來聲明新的變量，可以看出尺寸大小都是 5*3，但是數(shù)值類型是改變了的。

最后，對 tensors 的尺寸大小獲取可以采用 tensor.size() 方法：

print(tensor3.size()) # 輸出: torch.Size([5, 3]) torch.Size([5, 3])

注意： torch.Size 實際上是元組(tuple)類型，所以支持所有的元組操作。

1.2.2 操作(Operations)

操作也包含了很多語法，但這里作為快速入門，僅僅以加法操作作為例子進(jìn)行介紹，更多的操作介紹可以點擊下面網(wǎng)址查看官方文檔，包括轉(zhuǎn)置、索引、切片、數(shù)學(xué)計算、線性代數(shù)、隨機數(shù)等等：

https://pytorch.org/docs/stable/torch.html

對于加法的操作，有幾種實現(xiàn)方式：

加號（+） 運算符

torch.add(tensor1, tensor2, [out=tensor3])，以新的張量tensor3輸出

tensor1.add_(tensor2)：直接修改 tensor 變量

tensor4 = torch.rand(5, 3) print('tensor3 + tensor4= ', tensor3 + tensor4) print('tensor3 + tensor4= ', torch.add(tensor3, tensor4)) # 新聲明一個 tensor 變量保存加法操作的結(jié)果 result = torch.empty(5, 3) torch.add(tensor3, tensor4, out=result) print('add result= ', result) # 直接修改變量 tensor3.add_(tensor4) print('tensor3= ', tensor3) tensor3 + tensor4= tensor([[-0.5615, -0.7841, -0.1440],[ 1.1251, -0.5450, 0.0642],[ 0.4851, 2.8179, 3.4867],[ 2.0238, 0.9959, -0.0265],[-1.2165, 1.5306, 0.7595]]) tensor3 + tensor4= tensor([[-0.5615, -0.7841, -0.1440],[ 1.1251, -0.5450, 0.0642],[ 0.4851, 2.8179, 3.4867],[ 2.0238, 0.9959, -0.0265],[-1.2165, 1.5306, 0.7595]]) add result= tensor([[-0.5615, -0.7841, -0.1440],[ 1.1251, -0.5450, 0.0642],[ 0.4851, 2.8179, 3.4867],[ 2.0238, 0.9959, -0.0265],[-1.2165, 1.5306, 0.7595]]) tensor3= tensor([[-0.5615, -0.7841, -0.1440],[ 1.1251, -0.5450, 0.0642],[ 0.4851, 2.8179, 3.4867],[ 2.0238, 0.9959, -0.0265],[-1.2165, 1.5306, 0.7595]])

注意：可以改變 tensor 變量的操作都帶有一個后綴_, 例如 x.copy_(y), x.t_() 都可以改變 x 變量

除了加法運算操作，對于 Tensor 的訪問，和 Numpy 對數(shù)組類似，可以使用索引來訪問某一維的數(shù)據(jù)，如下所示：

# 訪問 tensor3 第一列數(shù)據(jù) print(tensor3[:, 0]) tensor([-0.5615, 1.1251, 0.4851, 2.0238, -1.2165])

對 Tensor 的尺寸修改，可以采用 torch.view() ，如下所示：

x = torch.randn(4, 4) y = x.view(16) # -1 表示給定列維度8之后，用16/8=2計算的另一維度數(shù) z = x.view(-1, 8) print("x = ",x) print("y = ",y) print("z = ",z) print(x.size(), y.size(), z.size()) x = tensor([[-0.3114, 0.2321, 0.1309, -0.1945],[ 0.6532, -0.8361, -2.0412, 1.3622],[ 0.7440, -0.2242, 0.6189, -1.0640],[-0.1256, 0.6199, -1.5032, -1.0438]]) y = tensor([-0.3114, 0.2321, 0.1309, -0.1945, 0.6532, -0.8361, -2.0412, 1.3622,0.7440, -0.2242, 0.6189, -1.0640, -0.1256, 0.6199, -1.5032, -1.0438]) z = tensor([[-0.3114, 0.2321, 0.1309, -0.1945, 0.6532, -0.8361, -2.0412, 1.3622],[ 0.7440, -0.2242, 0.6189, -1.0640, -0.1256, 0.6199, -1.5032, -1.0438]]) torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

如果 tensor 僅有一個元素，可以采用 .item() 來獲取類似 Python 中整數(shù)類型的數(shù)值：

x = torch.randn(1) print(x) print(x.item()) #x1 = torch.rand(1,5) #print(x1) #only one element tensors can be converted to Python scalars,所以下面的語句不對 #for x0 in x1.item():#print(x0) tensor([-0.7328]) -0.7328450083732605

更多的運算操作可以查看官方文檔的介紹：

https://pytorch.org/docs/stable/torch.html

1.3 和 Numpy 數(shù)組的轉(zhuǎn)換

Tensor 和 Numpy 的數(shù)組可以相互轉(zhuǎn)換，并且兩者轉(zhuǎn)換后共享在 CPU 下的內(nèi)存空間，即改變其中一個的數(shù)值，另一個變量也會隨之改變。

1.3.1 Tensor 轉(zhuǎn)換為 Numpy 數(shù)組

實現(xiàn) Tensor 轉(zhuǎn)換為 Numpy 數(shù)組的例子如下所示，調(diào)用 tensor.numpy() 可以實現(xiàn)這個轉(zhuǎn)換操作。

a = torch.ones(5) print(a) b = a.numpy() print(b) tensor([1., 1., 1., 1., 1.]) [1. 1. 1. 1. 1.]

此外，剛剛說了兩者是共享同個內(nèi)存空間的，例子如下所示，修改 tensor 變量 a，看看從 a 轉(zhuǎn)換得到的 Numpy 數(shù)組變量 b 是否發(fā)生變化。

a.add_(1) print(a) print(b) tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]

很明顯，b 也隨著 a 的改變而改變。

1.3.2 Numpy 數(shù)組轉(zhuǎn)換為 Tensor

轉(zhuǎn)換的操作是調(diào)用 torch.from_numpy(numpy_array) 方法。例子如下所示：

import numpy as np a = np.ones(5) b = torch.from_numpy(a) np.add(a, 1, out=a) print(a) print(b) [2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

在 CPU 上，除了 CharTensor 外的所有 Tensor 類型變量，都支持和 Numpy數(shù)組的相互轉(zhuǎn)換操作。

1.4. CUDA 張量

Tensors 可以通過 .to 方法轉(zhuǎn)換到不同的設(shè)備上，即 CPU 或者 GPU 上。例子如下所示：

# 當(dāng) CUDA 可用的時候，可用運行下方這段代碼，采用 torch.device() 方法來改變 tensors 是否在 GPU 上進(jìn)行計算操作 if torch.cuda.is_available():device = torch.device("cuda") # 定義一個 CUDA 設(shè)備對象y = torch.ones_like(x, device=device) # 顯示創(chuàng)建在 GPU 上的一個 tensorx = x.to(device) # 也可以采用 .to("cuda") z = x + yprint(z)print(z.to("cpu", torch.double)) # .to() 方法也可以改變數(shù)值類型 tensor([0.2672], device='cuda:0') tensor([0.2672], dtype=torch.float64)

輸出結(jié)果，第一個結(jié)果就是在 GPU 上的結(jié)果，打印變量的時候會帶有 device=‘cuda:0’，而第二個是在 CPU 上的變量。

本小節(jié)教程：

https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html

本小節(jié)的代碼：

https://github.com/ccc013/DeepLearning_Notes/blob/master/Pytorch/practise/basic_practise.ipynb

2. autograd

對于 Pytorch 的神經(jīng)網(wǎng)絡(luò)來說，非常關(guān)鍵的一個庫就是 autograd ，它主要是提供了對 Tensors 上所有運算操作的自動微分功能，也就是計算梯度的功能。它屬于 define-by-run 類型框架，即反向傳播操作的定義是根據(jù)代碼的運行方式，因此每次迭代都可以是不同的。

接下來會簡單介紹一些例子來說明這個庫的作用。

2.1 張量

torch.Tensor 是 Pytorch 最主要的庫，當(dāng)設(shè)置它的屬性 .requires_grad=True，那么就會開始追蹤在該變量上的所有操作，而完成計算后，可以調(diào)用 .backward() 并自動計算所有的梯度，得到的梯度都保存在屬性 .grad 中。

調(diào)用 .detach() 方法分離出計算的歷史，可以停止一個 tensor 變量繼續(xù)追蹤其歷史信息 ，同時也防止未來的計算會被追蹤。

而如果是希望防止跟蹤歷史（以及使用內(nèi)存），可以將代碼塊放在 with torch.no_grad(): 內(nèi)，這個做法在使用一個模型進(jìn)行評估的時候非常有用，因為模型會包含一些帶有 requires_grad=True 的訓(xùn)練參數(shù)，但實際上并不需要它們的梯度信息。

對于 autograd 的實現(xiàn)，還有一個類也是非常重要-- Function 。

Tensor 和 Function 兩個類是有關(guān)聯(lián)并建立了一個非循環(huán)的圖，可以編碼一個完整的計算記錄。每個 tensor 變量都帶有屬性 .grad_fn ，該屬性引用了創(chuàng)建了這個變量的 Function （除了由用戶創(chuàng)建的 Tensors，它們的 grad_fn=None )。

如果要進(jìn)行求導(dǎo)運算，可以調(diào)用一個 Tensor 變量的方法 .backward() 。如果該變量是一個標(biāo)量，即僅有一個元素，那么不需要傳遞任何參數(shù)給方法 .backward()，當(dāng)包含多個元素的時候，就必須指定一個 gradient 參數(shù)，表示匹配尺寸大小的 tensor，這部分見第二小節(jié)介紹梯度的內(nèi)容。

接下來就開始用代碼來進(jìn)一步介紹。

首先導(dǎo)入必須的庫：

import torch

開始創(chuàng)建一個 tensor， 并讓 requires_grad=True 來追蹤該變量相關(guān)的計算操作：

x = torch.ones(2, 2, requires_grad=True) print(x) tensor([[1., 1.],[1., 1.]], requires_grad=True)

執(zhí)行任意計算操作，這里進(jìn)行簡單的加法運算：

y = x + 2 print(y) tensor([[3., 3.],[3., 3.]], grad_fn=<AddBackward0>)

y 是一個操作的結(jié)果，所以它帶有屬性 grad_fn：

print(y.grad_fn) <AddBackward0 object at 0x000001B088735550>

繼續(xù)對變量 y 進(jìn)行操作：

z = y * y * 3 out = z.mean()print('z=', z) print('out=', out) z= tensor([[27., 27.],[27., 27.]], grad_fn=<MulBackward0>) out= tensor(27., grad_fn=<MeanBackward0>)

實際上，一個 Tensor 變量的默認(rèn) requires_grad 是 False ，可以像上述定義一個變量時候指定該屬性是 True，當(dāng)然也可以定義變量后，調(diào)用 .requires_grad_(True) 設(shè)置為 True ，這里帶有后綴_ 是會改變變量本身的屬性，在上一節(jié)介紹加法操作 add_() 說明過，下面是一個代碼例子：

#randn函數(shù)會因為樣本太少而產(chǎn)生較大誤差(均值不為0，方差不為1)！！ a = torch.randn(2, 2) a = ((a * 3) / (a - 1)) #如果有一個單一的輸入操作需要梯度，它的輸出也需要梯度。相反，只有所有輸入都不需要梯度，輸出才不需要。 print(a.requires_grad) a.requires_grad_(True) print(a.requires_grad) b = (a * a).sum() print(b.grad_fn) False True <SumBackward0 object at 0x000001B0887350B8>

第一行是為設(shè)置 requires_grad 的結(jié)果，接著顯示調(diào)用 .requires_grad_(True)，輸出結(jié)果就是 True 。

2.2 梯度

接下來就是開始計算梯度，進(jìn)行反向傳播的操作。out 變量是上一小節(jié)中定義的，它是一個標(biāo)量，因此 out.backward() 相當(dāng)于 out.backward(torch.tensor(1.)) ，代碼如下：

out.backward() # 輸出梯度 d(out)/dx print(x.grad) tensor([[4.5000, 4.5000],[4.5000, 4.5000]])

結(jié)果應(yīng)該就是得到數(shù)值都是 4.5 的矩陣。這里我們用 o 表示 out 變量，那么根據(jù)之前的定義會有：

$$o=\frac{1}{4}\sum _i{z}_i$$
$$z_i=3(x_i+2{)}^2$$
$$z_i{\mid }_{x_i=1}=27$$

詳細(xì)來說，初始定義的 x 是一個全為 1 的矩陣，然后加法操作 x+2 得到 y ，接著 y*y*3， 得到 z ，并且此時 z 是一個 2*2 的矩陣，所以整體求平均得到 out 變量應(yīng)該是除以 4，所以得到上述三條公式。

因此，計算梯度：

$$\frac{?o}{?x_i}=\frac{3}{2}(x_i+2)$$
$$\frac{?o}{?x_i}{\mid }_{x_i=1}=\frac{9}{2}=4.5$$

從數(shù)學(xué)上來說，如果你有一個向量值函數(shù)：

$$y=f(x)$$

那么對應(yīng)的梯度是一個雅克比矩陣(Jacobian matrix)：

一般來說，torch.autograd 就是用于計算雅克比向量(vector-Jacobian)乘積的工具。這里略過數(shù)學(xué)公式，直接上代碼例子介紹：

x = torch.randn(3, requires_grad=True)y = x * 2 while y.data.norm() < 1000: #沒太看懂y = y * 2print(y)

輸出結(jié)果：

tensor([ 237.5009, 1774.2396, 274.0625], grad_fn=<$MulBackward$>)

這里得到的變量 y 不再是一個標(biāo)量，torch.autograd 不能直接計算完整的雅克比行列式，但我們可以通過簡單的傳遞向量給 backward() 方法作為參數(shù)得到雅克比向量的乘積，例子如下所示：

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float) y.backward(v)print(x.grad)

輸出結(jié)果：

tensor([ 102.4000, 1024.0000, 0.1024])
最后，加上 with torch.no_grad() 就可以停止追蹤變量歷史進(jìn)行自動梯度計算：

print(x.requires_grad) print((x ** 2).requires_grad)with torch.no_grad():print((x ** 2).requires_grad)

輸出結(jié)果：

True

True

False
更多有關(guān) autograd 和 Function 的介紹：

https://pytorch.org/docs/autograd

本小節(jié)教程：

https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html

本小節(jié)的代碼：

https://github.com/ccc013/DeepLearning_Notes/blob/master/Pytorch/practise/autograd.ipynb

3. 神經(jīng)網(wǎng)絡(luò)

在 PyTorch 中 torch.nn 專門用于實現(xiàn)神經(jīng)網(wǎng)絡(luò)。其中 nn.Module 包含了網(wǎng)絡(luò)層的搭建，以及一個方法-- forward(input) ，并返回網(wǎng)絡(luò)的輸出 outptu .

下面是一個經(jīng)典的 LeNet 網(wǎng)絡(luò)，用于對字符進(jìn)行分類。

對于神經(jīng)網(wǎng)絡(luò)來說，一個標(biāo)準(zhǔn)的訓(xùn)練流程是這樣的：

1.定義一個多層的神經(jīng)網(wǎng)絡(luò)
2.對數(shù)據(jù)集的預(yù)處理并準(zhǔn)備作為網(wǎng)絡(luò)的輸入
3.將數(shù)據(jù)輸入到網(wǎng)絡(luò)
4.計算網(wǎng)絡(luò)的損失
5.反向傳播，計算梯度
6.更新網(wǎng)絡(luò)的梯度，一個簡單的更新規(guī)則是 weight = weight - learning_rate * gradient

3.1 定義網(wǎng)絡(luò)

首先定義一個神經(jīng)網(wǎng)絡(luò)，下面是一個 5 層的卷積神經(jīng)網(wǎng)絡(luò)，包含兩層卷積層和三層全連接層：

import torch import torch.nn as nn import torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()# 輸入圖像是單通道，conv1 kenrnel size=5*5，輸出通道 6self.conv1 = nn.Conv2d(1, 6, 5)# conv2 kernel size=5*5, 輸出通道 16self.conv2 = nn.Conv2d(6, 16, 5)# 全連接層self.fc1 = nn.Linear(16*5*5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)def forward(self, x):# max-pooling 采用一個 (2,2) 的滑動窗口x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))# 核(kernel)大小是方形的話，可僅定義一個數(shù)字，如 (2,2) 用 2 即可x = F.max_pool2d(F.relu(self.conv2(x)), 2)x = x.view(-1, self.num_flat_features(x))x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))x = self.fc3(x)return xdef num_flat_features(self, x):# 除了 batch 維度外的所有維度size = x.size()[1:]num_features = 1for s in size:num_features *= sreturn num_featuresnet = Net() print(net) Net((conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))(fc1): Linear(in_features=400, out_features=120, bias=True)(fc2): Linear(in_features=120, out_features=84, bias=True)(fc3): Linear(in_features=84, out_features=10, bias=True) )

這里必須實現(xiàn) forward 函數(shù)，而 backward 函數(shù)在采用 autograd 時就自動定義好了，在 forward 方法可以采用任何的張量操作。

net.parameters() 可以返回網(wǎng)絡(luò)的訓(xùn)練參數(shù)，使用例子如下：

params = list(net.parameters()) print('參數(shù)數(shù)量: ', len(params)) # conv1.weight print('第一個參數(shù)大小: ', params[0].size()) 參數(shù)數(shù)量: 10 第一個參數(shù)大小: torch.Size([6, 1, 5, 5])

然后簡單測試下這個網(wǎng)絡(luò)，隨機生成一個 32*32 的輸入：

# 隨機定義一個變量輸入網(wǎng)絡(luò) input = torch.randn(1, 1, 32, 32) out = net(input) print(out) tensor([[ 0.0527, 0.0785, -0.0961, -0.0425, 0.0973, 0.1605, -0.0440, -0.0142,0.0985, -0.0596]], grad_fn=<AddmmBackward>)

接著反向傳播需要先清空梯度緩存，并反向傳播隨機梯度：

# 清空所有參數(shù)的梯度緩存，然后計算隨機梯度進(jìn)行反向傳播 net.zero_grad() out.backward(torch.randn(1, 10))

注意：

torch.nn 只支持小批量(mini-batches)數(shù)據(jù)，也就是輸入不能是單個樣本，比如對于 nn.Conv2d 接收的輸入是一個 4 維張量–nSamples * nChannels * Height * Width 。
所以，如果你輸入的是單個樣本，需要采用 input.unsqueeze(0) 來擴充一個假的 batch 維度，即從 3 維變?yōu)?4 維。

3.2 損失函數(shù)

損失函數(shù)的輸入是 (output, target) ，即網(wǎng)絡(luò)輸出和真實標(biāo)簽對的數(shù)據(jù)，然后返回一個數(shù)值表示網(wǎng)絡(luò)輸出和真實標(biāo)簽的差距。

PyTorch 中其實已經(jīng)定義了不少的損失函數(shù)，這里僅采用簡單的均方誤差：nn.MSELoss ，例子如下：

output = net(input) # 定義偽標(biāo)簽 target = torch.randn(10) # 調(diào)整大小，使得和 output 一樣的 size target = target.view(1, -1) criterion = nn.MSELoss()loss = criterion(output, target) print(loss) tensor(0.7520, grad_fn=<MseLossBackward>)

這里，整個網(wǎng)絡(luò)的數(shù)據(jù)輸入到輸出經(jīng)歷的計算圖如下所示，其實也就是數(shù)據(jù)從輸入層到輸出層，計算 loss 的過程。

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d

-> view -> linear -> relu -> linear -> relu -> linear-> MSELoss-> loss

如果調(diào)用 loss.backward() ，那么整個圖都是可微分的，也就是說包括 loss ，圖中的所有張量變量，只要其屬性 requires_grad=True ，那么其梯度 .grad張量都會隨著梯度一直累計。

用代碼來說明：

# MSELoss print(loss.grad_fn) # Linear layer print(loss.grad_fn.next_functions[0][0]) # Relu print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) <MseLossBackward object at 0x000002830E0584A8> <AddmmBackward object at 0x000002830E058CF8> <AccumulateGrad object at 0x000002830E0584A8>

3.3 反向傳播

反向傳播的實現(xiàn)只需要調(diào)用 loss.backward() 即可，當(dāng)然首先需要清空當(dāng)前梯度緩存，即.zero_grad() 方法，否則之前的梯度會累加到當(dāng)前的梯度，這樣會影響權(quán)值參數(shù)的更新。

下面是一個簡單的例子，以 conv1 層的偏置參數(shù) bias 在反向傳播前后的結(jié)果為例：

# 清空所有參數(shù)的梯度緩存 net.zero_grad() print('conv1.bias.grad before backward') print(net.conv1.bias.grad)loss.backward()print('conv1.bias.grad after backward') print(net.conv1.bias.grad) conv1.bias.grad before backward tensor([0., 0., 0., 0., 0., 0.]) conv1.bias.grad after backward tensor([ 0.0127, -0.0079, -0.0007, 0.0046, 0.0076, -0.0117])

了解更多有關(guān) torch.nn 庫，可以查看官方文檔：

https://pytorch.org/docs/stable/nn.html

3.4 更新權(quán)重

采用隨機梯度下降(Stochastic Gradient Descent, SGD)方法的最簡單的更新權(quán)重規(guī)則如下：

weight = weight - learning_rate * gradient

按照這個規(guī)則，代碼實現(xiàn)如下所示：

# 簡單實現(xiàn)權(quán)重的更新例子 learning_rate = 0.01 for f in net.parameters():f.data.sub_(f.grad.data * learning_rate)

但是這只是最簡單的規(guī)則，深度學(xué)習(xí)有很多的優(yōu)化算法，不僅僅是 SGD，還有 Nesterov-SGD, Adam, RMSProp 等等，為了采用這些不同的方法，這里采用 torch.optim 庫，使用例子如下所示：

import torch.optim as optim # 創(chuàng)建優(yōu)化器 optimizer = optim.SGD(net.parameters(), lr=0.01)# 在訓(xùn)練過程中執(zhí)行下列操作 optimizer.zero_grad() # 清空梯度緩存 output = net(input) loss = criterion(output, target) loss.backward() # 更新權(quán)重 optimizer.step()

注意，同樣需要調(diào)用 optimizer.zero_grad() 方法清空梯度緩存。

本小節(jié)教程：

https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html

本小節(jié)的代碼：

https://github.com/ccc013/DeepLearning_Notes/blob/master/Pytorch/practise/neural_network.ipynb

4. 訓(xùn)練分類器

上一節(jié)介紹了如何構(gòu)建神經(jīng)網(wǎng)絡(luò)、計算 loss 和更新網(wǎng)絡(luò)的權(quán)值參數(shù)，接下來需要做的就是實現(xiàn)一個圖片分類器。

4.1 訓(xùn)練數(shù)據(jù)

在訓(xùn)練分類器前，當(dāng)然需要考慮數(shù)據(jù)的問題。通常在處理如圖片、文本、語音或者視頻數(shù)據(jù)的時候，一般都采用標(biāo)準(zhǔn)的 Python 庫將其加載并轉(zhuǎn)成 Numpy 數(shù)組，然后再轉(zhuǎn)回為 PyTorch 的張量。

·對于圖像，可以采用 Pillow, OpenCV 庫；

·對于語音，有 scipy 和 librosa;

·對于文本，可以選擇原生 Python 或者 Cython 進(jìn)行加載數(shù)據(jù)，或者使用 NLTK 和 SpaCy 。

PyTorch 對于計算機視覺，特別創(chuàng)建了一個 torchvision 的庫，它包含一個數(shù)據(jù)加載器(data loader)，可以加載比較常見的數(shù)據(jù)集，比如 Imagenet, CIFAR10, MNIST 等等，然后還有一個用于圖像的數(shù)據(jù)轉(zhuǎn)換器(data transformers)，調(diào)用的庫是 torchvision.datasets 和 torch.utils.data.DataLoader 。

在本教程中，將采用 CIFAR10 數(shù)據(jù)集，它包含 10 個類別，分別是飛機、汽車、鳥、貓、鹿、狗、青蛙、馬、船和卡車。數(shù)據(jù)集中的圖片都是 3x32x32。一些例子如下所示：

4.2 訓(xùn)練圖片分類器

訓(xùn)練流程如下：

1.通過調(diào)用 torchvision 加載和歸一化 CIFAR10 訓(xùn)練集和測試集；

2.構(gòu)建一個卷積神經(jīng)網(wǎng)絡(luò)；

3.定義一個損失函數(shù)；

4.在訓(xùn)練集上訓(xùn)練網(wǎng)絡(luò)；

5.在測試集上測試網(wǎng)絡(luò)性能。

4.2.1 加載和歸一化 CIFAR10

首先導(dǎo)入必須的包：

import torch import torchvision import torchvision.transforms as transforms

torchvision 的數(shù)據(jù)集輸出的圖片都是 PILImage ，即取值范圍是 [0, 1] ，這里需要做一個轉(zhuǎn)換，變成取值范圍是 [-1, 1] , 代碼如下所示：

# 將圖片數(shù)據(jù)從 [0,1] 歸一化為 [-1, 1] 的取值范圍 transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])trainset = torchvision.datasets.CIFAR10(root='./data', train=True,download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,shuffle=True, num_workers=2)testset = torchvision.datasets.CIFAR10(root='./data', train=False,download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=4,shuffle=False, num_workers=2)classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck') Files already downloaded and verified Files already downloaded and verified

這里下載好數(shù)據(jù)后，可以可視化部分訓(xùn)練圖片，代碼如下：

import matplotlib.pyplot as plt import numpy as np# 展示圖片的函數(shù) def imshow(img):img = img / 2 + 0.5 # 非歸一化npimg = img.numpy()plt.imshow(np.transpose(npimg, (1, 2, 0)))plt.show()# 隨機獲取訓(xùn)練集圖片 dataiter = iter(trainloader) images, labels = dataiter.next()# 展示圖片 imshow(torchvision.utils.make_grid(images)) # 打印圖片類別標(biāo)簽 print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

[外鏈圖片轉(zhuǎn)存失敗(img-S87eezU5-1568535314521)(output_38_0.png)]

truck cat plane horse

展示圖片如下所示：

其類別標(biāo)簽為：

frog plane dog ship

4.2.2 構(gòu)建一個卷積神經(jīng)網(wǎng)絡(luò)

這部分內(nèi)容其實直接采用上一節(jié)定義的網(wǎng)絡(luò)即可，除了修改 conv1 的輸入通道，從 1 變?yōu)?3，因為這次接收的是 3 通道的彩色圖片。

import torch.nn as nn import torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(3, 6, 5)self.pool = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(6, 16, 5)self.fc1 = nn.Linear(16 * 5 * 5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)def forward(self, x):x = self.pool(F.relu(self.conv1(x)))x = self.pool(F.relu(self.conv2(x)))x = x.view(-1, 16 * 5 * 5)x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))x = self.fc3(x)return xnet = Net()

4.2.3 定義損失函數(shù)和優(yōu)化器

這里采用類別交叉熵函數(shù)和帶有動量的 SGD 優(yōu)化方法：

import torch.optim as optimcriterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4.2.4 訓(xùn)練網(wǎng)絡(luò)

第四步自然就是開始訓(xùn)練網(wǎng)絡(luò)，指定需要迭代的 epoch，然后輸入數(shù)據(jù)，指定次數(shù)打印當(dāng)前網(wǎng)絡(luò)的信息，比如 loss 或者準(zhǔn)確率等性能評價標(biāo)準(zhǔn)。

import time start = time.time() for epoch in range(2):running_loss = 0.0for i, data in enumerate(trainloader, 0):# 獲取輸入數(shù)據(jù)inputs, labels = data# 清空梯度緩存optimizer.zero_grad()outputs = net(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()# 打印統(tǒng)計信息running_loss += loss.item()if i % 2000 == 1999:# 每 2000 次迭代打印一次信息print('[%d, %5d] loss: %.3f' % (epoch + 1, i+1, running_loss / 2000))running_loss = 0.0 print('Finished Training! Total cost time in CPU: ', time.time()-start) [1, 2000] loss: 2.260 [1, 4000] loss: 1.915 [1, 6000] loss: 1.706 [1, 8000] loss: 1.565 [1, 10000] loss: 1.529 [1, 12000] loss: 1.451 [2, 2000] loss: 1.395 [2, 4000] loss: 1.378 [2, 6000] loss: 1.342 [2, 8000] loss: 1.314 [2, 10000] loss: 1.321 [2, 12000] loss: 1.272 Finished Training! Total cost time in CPU: 92.60148167610168

這里定義訓(xùn)練總共 2 個 epoch，訓(xùn)練信息如下，大概耗時為 92s。

4.2.5 測試模型性能

訓(xùn)練好一個網(wǎng)絡(luò)模型后，就需要用測試集進(jìn)行測試，檢驗網(wǎng)絡(luò)模型的泛化能力。對于圖像分類任務(wù)來說，一般就是用準(zhǔn)確率作為評價標(biāo)準(zhǔn)。

首先，我們先用一個 batch 的圖片進(jìn)行小小測試，這里 batch=4 ，也就是 4 張圖片，代碼如下：

dataiter = iter(testloader) images, labels = dataiter.next()# 打印圖片 imshow(torchvision.utils.make_grid(images)) print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

圖片和標(biāo)簽分別如下所示：

GroundTruth: cat ship ship plane

然后用這四張圖片輸入網(wǎng)絡(luò)，看看網(wǎng)絡(luò)的預(yù)測結(jié)果：

# 網(wǎng)絡(luò)輸出 outputs = net(images)# 預(yù)測結(jié)果 _, predicted = torch.max(outputs, 1) print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4))) Predicted: cat ship car ship

前面三張圖片都預(yù)測正確了，第四張圖片錯誤預(yù)測飛機為船。

接著，讓我們看看在整個測試集上的準(zhǔn)確率可以達(dá)到多少吧！

correct = 0 total = 0 with torch.no_grad():for data in testloader:images, labels = dataoutputs = net(images)_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total)) Accuracy of the network on the 10000 test images: 56 %

這里可能準(zhǔn)確率并不一定一樣，教程中的結(jié)果是 51% ，因為權(quán)重初始化問題，可能多少有些浮動，相比隨機猜測 10 個類別的準(zhǔn)確率(即 10%)，這個結(jié)果是不錯的，當(dāng)然實際上是非常不好，不過我們僅僅采用 5 層網(wǎng)絡(luò)，而且僅僅作為教程的一個示例代碼。

然后，還可以再進(jìn)一步，查看每個類別的分類準(zhǔn)確率，跟上述代碼有所不同的是，計算準(zhǔn)確率部分是 c = (predicted == labels).squeeze()，這段代碼其實會根據(jù)預(yù)測和真實標(biāo)簽是否相等，輸出 1 或者 0，表示真或者假，因此在計算當(dāng)前類別正確預(yù)測數(shù)量時候直接相加，預(yù)測正確自然就是加 1，錯誤就是加 0，也就是沒有變化。

class_correct = list(0. for i in range(10)) class_total = list(0. for i in range(10)) with torch.no_grad():for data in testloader:images, labels = dataoutputs = net(images)_, predicted = torch.max(outputs, 1)c = (predicted == labels).squeeze()for i in range(4):label = labels[i]class_correct[label] += c[i].item()class_total[label] += 1for i in range(10):print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i])) Accuracy of plane : 57 % Accuracy of car : 60 % Accuracy of bird : 40 % Accuracy of cat : 34 % Accuracy of deer : 38 % Accuracy of dog : 52 % Accuracy of frog : 70 % Accuracy of horse : 65 % Accuracy of ship : 77 % Accuracy of truck : 68 %

4.3 在 GPU 上訓(xùn)練

深度學(xué)習(xí)自然需要 GPU 來加快訓(xùn)練速度的。所以接下來介紹如果是在 GPU 上訓(xùn)練，應(yīng)該如何實現(xiàn)。

首先，需要檢查是否有可用的 GPU 來訓(xùn)練，代碼如下：

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) cuda:0

輸出結(jié)果表明你的第一塊 GPU 顯卡或者唯一的 GPU 顯卡是空閑可用狀態(tài)，否則會打印 cpu 。

既然有可用的 GPU ，接下來就是在 GPU 上進(jìn)行訓(xùn)練了，其中需要修改的代碼如下，分別是需要將網(wǎng)絡(luò)參數(shù)和數(shù)據(jù)都轉(zhuǎn)移到 GPU 上：

net.to(device) inputs, labels = inputs.to(device), labels.to(device)

修改后的訓(xùn)練部分代碼：

import time # 在 GPU 上訓(xùn)練注意需要將網(wǎng)絡(luò)和數(shù)據(jù)放到 GPU 上 net.to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)start = time.time() for epoch in range(2):running_loss = 0.0for i, data in enumerate(trainloader, 0):# 獲取輸入數(shù)據(jù)inputs, labels = datainputs, labels = inputs.to(device), labels.to(device)# 清空梯度緩存optimizer.zero_grad()outputs = net(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()# 打印統(tǒng)計信息running_loss += loss.item()if i % 2000 == 1999:# 每 2000 次迭代打印一次信息print('[%d, %5d] loss: %.3f' % (epoch + 1, i+1, running_loss / 2000))running_loss = 0.0 print('Finished Training! Total cost time in GPU: ', time.time() - start) [1, 2000] loss: 1.220 [1, 4000] loss: 1.216 [1, 6000] loss: 1.198 [1, 8000] loss: 1.172 [1, 10000] loss: 1.181 [1, 12000] loss: 1.197 [2, 2000] loss: 1.113 [2, 4000] loss: 1.109 [2, 6000] loss: 1.099 [2, 8000] loss: 1.091 [2, 10000] loss: 1.122 [2, 12000] loss: 1.113 Finished Training! Total cost time in GPU: 135.38129496574402

注意，這里調(diào)用 net.to(device) 后，需要定義下優(yōu)化器，即傳入的是 CUDA 張量的網(wǎng)絡(luò)參數(shù)。訓(xùn)練結(jié)果和之前的類似，而且其實因為這個網(wǎng)絡(luò)非常小，轉(zhuǎn)移到 GPU 上并不會有多大的速度提升，而且我的訓(xùn)練結(jié)果看來反而變慢了，也可能是因為我的筆記本的 GPU 顯卡問題。

如果需要進(jìn)一步提升速度，可以考慮采用多 GPUs，也就是下一節(jié)的內(nèi)容。

本小節(jié)教程：

https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html

本小節(jié)的代碼：

https://github.com/ccc013/DeepLearning_Notes/blob/master/Pytorch/practise/train_classifier_example.ipynb

5. 數(shù)據(jù)并行

這部分教程將學(xué)習(xí)如何使用 DataParallel 來使用多個 GPUs 訓(xùn)練網(wǎng)絡(luò)。

首先，在 GPU 上訓(xùn)練模型的做法很簡單，如下代碼所示，定義一個 device 對象，然后用 .to() 方法將網(wǎng)絡(luò)模型參數(shù)放到指定的 GPU 上。

這部分教程將學(xué)習(xí)如何使用 DataParallel 來使用多個 GPUs 訓(xùn)練網(wǎng)絡(luò)。

首先，在 GPU 上訓(xùn)練模型的做法很簡單，如下代碼所示，定義一個 device 對象，然后用 .to() 方法將網(wǎng)絡(luò)模型參數(shù)放到指定的 GPU 上。

device = torch.device(“cuda:0”)
model.to(device)

接著就是將所有的張量變量放到 GPU 上：

mytensor = my_tensor.to(device)

注意，這里 my_tensor.to(device) 是返回一個 my_tensor 的新的拷貝對象，而不是直接修改 my_tensor 變量，因此你需要將其賦值給一個新的張量，然后使用這個張量。

Pytorch 默認(rèn)只會采用一個 GPU，因此需要使用多個 GPU，需要采用 DataParallel ，代碼如下所示：

model = nn.DataParallel(model)

這代碼也就是本節(jié)教程的關(guān)鍵，接下來會繼續(xù)詳細(xì)介紹。

5.1 導(dǎo)入和參數(shù)

首先導(dǎo)入必須的庫以及定義一些參數(shù)：

import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader# Parameters and DataLoaders input_size = 5 output_size = 2batch_size = 30 data_size = 100device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

這里主要定義網(wǎng)絡(luò)輸入大小和輸出大小，batch 以及圖片的大小，并定義了一個 device 對象。

5.2 構(gòu)建一個假數(shù)據(jù)集

接著就是構(gòu)建一個假的(隨機)數(shù)據(jù)集。實現(xiàn)代碼如下：

class RandomDataset(Dataset):def __init__(self, size, length):self.len = lengthself.data = torch.randn(length, size)def __getitem__(self, index):return self.data[index]def __len__(self):return self.lenrand_loader = DataLoader(dataset=RandomDataset(input_size, data_size),batch_size=batch_size, shuffle=True)

5.3 簡單的模型

接下來構(gòu)建一個簡單的網(wǎng)絡(luò)模型，僅僅包含一層全連接層的神經(jīng)網(wǎng)絡(luò)，加入 print() 函數(shù)用于監(jiān)控網(wǎng)絡(luò)輸入和輸出 tensors 的大小：

class Model(nn.Module):# Our modeldef __init__(self, input_size, output_size):super(Model, self).__init__()self.fc = nn.Linear(input_size, output_size)def forward(self, input):output = self.fc(input)print("\tIn Model: input size", input.size(),"output size", output.size())return output

5.4 創(chuàng)建模型和數(shù)據(jù)平行

這是本節(jié)的核心部分。首先需要定義一個模型實例，并且檢查是否擁有多個 GPUs，如果是就可以將模型包裹在 nn.DataParallel ，并調(diào)用 model.to(device) 。代碼如下：

model = Model(input_size, output_size) if torch.cuda.device_count() > 1:print("Let's use", torch.cuda.device_count(), "GPUs!")# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUsmodel = nn.DataParallel(model)model.to(device) Model((fc): Linear(in_features=5, out_features=2, bias=True) )

5.5 運行模型

接著就可以運行模型，看看打印的信息：

for data in rand_loader:input = data.to(device)output = model(input)print("Outside: input size", input.size(),"output_size", output.size()) In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2]) Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

5.6 運行結(jié)果

如果僅僅只有 1 個或者沒有 GPU ，那么 batch=30 的時候，模型會得到輸入輸出的大小都是 30。但如果有多個 GPUs，那么結(jié)果如下：

2 GPUs

# on 2 GPUs
Let’s use 2 GPUs!
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

3 GPUs

Let’s use 3 GPUs!
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

8 GPUs

Let’s use 8 GPUs!
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

5.7 總結(jié)

DataParallel 會自動分割數(shù)據(jù)集并發(fā)送任務(wù)給多個 GPUs 上的多個模型。然后等待每個模型都完成各自的工作后，它又會收集并融合結(jié)果，然后返回。

更詳細(xì)的數(shù)據(jù)并行教程：

https://pytorch.org/tutorials/beginner/former_torchies/parallelism_tutorial.html

本小節(jié)教程：

https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html

總結(jié)

以上是生活随笔為你收集整理的60分钟入门pytorch的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。