[[406246]]

什么是 PyTorch?

PyTorch是一個基于Python的科學計算包，提供最大靈活性和速度的深度學習研究平臺。

張量

張量類似于NumPy 的n 維數組，此外張量也可以在 GPU 上使用以加速計算。

讓我們構造一個簡單的張量并檢查輸出。首先讓我們看看我們如何構建一個 5×3 的未初始化矩陣：

import torch 
x = torch.empty(5, 3) 
print(x) 

輸出如下：

tensor([[2.7298e+32, 4.5650e-41, 2.7298e+32], 
        [4.5650e-41, 0.0000e+00, 0.0000e+00], 
        [0.0000e+00, 0.0000e+00, 0.0000e+00], 
        [0.0000e+00, 0.0000e+00, 0.0000e+00], 
        [0.0000e+00, 0.0000e+00, 0.0000e+00]]) 

現在讓我們構造一個隨機初始化的矩陣：

x = torch.rand(5, 3) 
print(x) 

輸出：

tensor([[1.1608e-01, 9.8966e-01, 1.2705e-01], 
        [2.8599e-01, 5.4429e-01, 3.7764e-01], 
        [5.8646e-01, 1.0449e-02, 4.2655e-01], 
        [2.2087e-01, 6.6702e-01, 5.1910e-01], 
        [1.8414e-01, 2.0611e-01, 9.4652e-04]]) 

直接從數據構造張量：

x = torch.tensor([5.5, 3]) 
print(x) 

輸出：

tensor([5.5000, 3.0000]) 

創建一個統一的長張量。

x = torch.LongTensor(3, 4) 
x 
 
tensor([[94006673833344,   210453397554,   206158430253,   193273528374], 
        [  214748364849,   210453397588,   249108103216,   223338299441], 
        [  210453397562,   197568495665,   206158430257,   240518168626]]) 

「浮動張量。」

x = torch.FloatTensor(3, 4) 
x 
 
tensor([[-3.1152e-18,  3.0670e-41,  3.5032e-44,  0.0000e+00], 
        [        nan,  3.0670e-41,  1.7753e+28,  1.0795e+27], 
        [ 1.0899e+27,  2.6223e+20,  1.7465e+19,  1.8888e+31]]) 

「在范圍內創建張量」

torch.arange(10, dtype=torch.float) 
 
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) 

「重塑張量」

x = torch.arange(10, dtype=torch.float)  
x 
 
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) 

使用 .view重塑張量。

x.view(2, 5) 
 
tensor([[0., 1., 2., 3., 4.], 
        [5., 6., 7., 8., 9.]]) 

-1根據張量的大小自動識別維度。

x.view(5, -1) 
 
tensor([[0., 1.], 
        [2., 3.], 
        [4., 5.], 
        [6., 7.], 
        [8., 9.]]) 

「改變張量軸」

改變張量軸：兩種方法view和permute

view改變張量的順序，而permute只改變軸。

x1 = torch.tensor([[1., 2., 3.], [4., 5., 6.]]) 
print("x1: \n", x1) 
print("\nx1.shape: \n", x1.shape) 
print("\nx1.view(3, -1): \n", x1.view(3 , -1)) 
print("\nx1.permute(1, 0): \n", x1.permute(1, 0)) 
 
 
x1:  
 tensor([[1., 2., 3.], 
        [4., 5., 6.]]) 
 
x1.shape:  
 torch.Size([2, 3]) 
 
x1.view(3, -1):  
 tensor([[1., 2.], 
        [3., 4.], 
        [5., 6.]]) 
 
x1.permute(1, 0):  
 tensor([[1., 4.], 
        [2., 5.], 
        [3., 6.]]) 

張量運算

在下面的示例中，我們將查看加法操作：

y = torch.rand(5, 3) 
print(x + y) 

輸出：

tensor([[0.5429, 1.7372, 1.0293], 
        [0.5418, 0.6088, 1.0718], 
        [1.3894, 0.5148, 1.2892], 
        [0.9626, 0.7522, 0.9633], 
        [0.7547, 0.9931, 0.2709]]) 

調整大小：如果你想調整張量的形狀，你可以使用“torch.view”：

x = torch.randn(4, 4) 
y = x.view(16) 
# 大小-1是從其他維度推斷出來的 
z = x.view(-1, 8)  
print(x.size(), y.size(), z.size()) 

輸出：

torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8]) 

PyTorch 和 NumPy的轉換

NumPy 是Python 編程語言的庫，增加了對大型、多維數組和矩陣的支持，以及對這些數組進行操作的大量高級數學函數集合。

將Torch中Tensor 轉換為 NumPy 數組，反之亦然是輕而易舉的!

Torch Tensor 和 NumPy 數組將共享它們的底層內存位置 ，改變一個將改變另一個。

「將 Torch 張量轉換為 NumPy 數組：」

a = torch.ones(5) 
print(a) 

輸出：tensor([1., 1., 1., 1., 1.])

b = a.numpy() 
print(b) 

輸出：[1., 1., 1., 1., 1.]

讓我們執行求和運算并檢查值的變化：

a.add_(1) 
print(a) 
print(b) 

輸出：

tensor([2., 2., 2., 2., 2.]) 
[2. 2. 2. 2. 2.] 

「將 NumPy 數組轉換為 Torch 張量：」

import numpy as no 
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) 

所以，正如你所看到的，就是這么簡單!

接下來在這個 PyTorch 教程博客上，讓我們看看PyTorch 的 AutoGrad 模塊。

AutoGrad

該autograd包提供自動求導為上張量的所有操作。

它是一個按運行定義的框架，這意味著您的反向傳播是由您的代碼運行方式定義的，并且每次迭代都可以不同。

• torch.autograd.function (函數的反向傳播)
• torch.autograd.functional (計算圖的反向傳播)
• torch.autograd.gradcheck (數值梯度檢查)
• torch.autograd.anomaly_mode (在自動求導時檢測錯誤產生路徑)
• torch.autograd.grad_mode (設置是否需要梯度)
• model.eval() 與 torch.no_grad()
• torch.autograd.profiler (提供 function 級別的統計信息)

「下面使用 Autograd 進行反向傳播。」

如果requires_grad=True，則 Tensor 對象會跟蹤它是如何創建的。

x = torch.tensor([1., 2., 3.], requires_grad = True) 
print('x: ', x) 
y = torch.tensor([10., 20., 30.], requires_grad = True) 
print('y: ', y) 
z = x + y  
print('\nz = x + y') 
print('z:', z) 
 
x:  tensor([1., 2., 3.], requires_grad=True) 
y:  tensor([10., 20., 30.], requires_grad=True) 
 
z = x + y 
z: tensor([11., 22., 33.], grad_fn=<AddBackward0>) 

因為requires_grad=True，z知道它是通過增加兩個張量的產生z = x + y。

s = z.sum() 
print(s) 
 
tensor(66., grad_fn=<SumBackward0>) 

s是由它的數字總和創建的。當我們調用.backward()，反向傳播從s開始運行。然后可以計算梯度。

s.backward() 
print('x.grad: ', x.grad) 
print('y.grad: ', y.grad) 
 
x.grad:  tensor([1., 1., 1.]) 
y.grad:  tensor([1., 1., 1.]) 

下面例子是計算log(x)的導數為1 / x

import torch 
x = torch.tensor([0.5, 0.75], requires_grad=True) 
# 1 / x  
y = torch.log(x[0] * x[1]) 
y.backward() 
x.grad # tensor([2.0000, 1.3333]) 

 【編輯推薦】