編者按：DataCamp的Sayak Paul帶你入門張量、PyTorch。
在深度學習中，常常看到張量是數據結構的基石這一說法。Google的機器學習庫TensorFlow甚至都以張量（tensor）命名。張量是線性代數中用到的一種數據結構，類似向量和矩陣，你可以在張量上進行算術運算。
PyTorch（點擊閱讀）則是由Facebook創建的python包，提供兩個高層特性：1) 類似Numpy的基於GPU加速的張量運算 2) 在基於回放（tape-based）的自動微分系統之上構建的深度神經網絡。
本教程將介紹什麼是張量，如何在PyTorch中操作張量：
張量介紹
PyTorch介紹
PyTorch安裝步驟
PyTorch下的一些張量操作
基於PyTorch實現一個簡單的神經網絡
閒話少敘，讓我們開始介紹張量吧。
張量是向量和矩陣的推廣，可以理解為多維數組。知名的《深度學習》（Goodfellow等編寫）是這樣介紹張量的：
在一般意義上，以基於可變數目的軸的規則網格組織的一組數字稱為張量。
標量是零階張量。向量是一階張量，矩陣是二階張量。
下面是張量的示意圖：
現在讓我們以更清晰易懂的方式構建張量背後的直覺。
張量是現代機器學習的基本構建。它是一個數據容器，大多數情況下包含數字，有時可能包含字符串（不過這罕見）。所以可以把張量想像成一桶數字。
人們經常混用張量和多維數組。不過有時需要嚴格區分兩者，如StackExchange指出：
張量和多維數組是不同類型的對象。前者是一種函數，後者是適宜在坐標系統中表示張量的一種數據結構。
在數學上，張量由多元線性函數定義。一個多元線性函數包含多個向量變量。張量域是張量值函數。更嚴謹的數學解釋，可以參考https://math.stackexchange.com/q/10282
所以，張量是需要定義的函數或容器。實際上，當數據傳入時，計算才真正發生。當不需要嚴格區分數組和張量的時候，數組或多維數組(1D, 2D, …, ND)一般可以視作張量。
現在我們稍微講下張量表述（Tensor notation）。
張量表述和矩陣類似，一般用大寫字母表示張量，帶整數下標的小寫字母表示張量中的標量值。
標量、向量、矩陣的許多運算同樣適用於張量。
張量和張量代數是物理和工程領域廣泛使用的工具。機器學習的許多技術，深度學習模型的訓練和操作，常常使用張量這一術語進行描述。
PyTorch是一個非常靈活的基於Python的深度學習研究平臺。
PyTorch特性
Kirill Dubovikov寫的PyTorch vs TensorFlow — spotting the difference比較了PyTorch和TensorFlow這兩個框架。如果你想了解TensorFlow，可以看看Karlijn Willems寫的教程TensorFlow Tutorial For Beginners。
PyTorch的安裝很簡單。如果你的顯卡支持，可以安裝GPU版本的PyTorch。
你可以使用pip安裝torch、torchvision這兩個包，也可以使用conda安裝pytorch torchvision這兩個包。注意，Windows平臺上，PyTorch不支持Python 2.7，需要基於Python 3.5以上的版本安裝。
具體的安裝命令可以通過PyTorch官網查詢： https://pytorch.org/get-started/locally/
好了，下面讓我們直接深入PyTorch下的一些張量算術。
PyTorch下的一些張量操作首先，導入所需的庫：
import torch
如果出現報錯，說明PyTorch沒有安裝成功，請參考上一節重新安裝。
現在，我們構造一個5×3的矩陣：
x = torch.rand(5, 3)
print(x)
輸出：
tensor([[ 0.5991, 0.9365, 0.6120],
[ 0.3622, 0.1408, 0.8811],
[ 0.6248, 0.4808, 0.0322],
[ 0.2267, 0.3715, 0.8430],
[ 0.0145, 0.0900, 0.3418]])
再構造一個5×3的矩陣，不過這次用零初始化，並指定數據類型為long：
x = torch.zeros(5, 3, dtype=torch.long)
print(x)
輸出：
tensor([[ 0, 0, 0],
[ 0, 0, 0],
[ 0, 0, 0],
[ 0, 0, 0],
[ 0, 0, 0]])
構造張量時直接提供數據：
x = torch.tensor([5.5, 3])
print(x)
輸出：
tensor([ 5.5000, 3.0000])
如果你想檢驗下自己是否理解了PyTorch中的張量，那可以思考下上面的張量x是什麼類別的。
基於已有張量，可以創建新張量——新張量會復用輸入張量的屬性，比如dtype（數據類型），除非另外給出新值：
x = x.new_ones(5, 3, dtype=torch.double)
print(x)
x = torch.randn_like(x, dtype=torch.float)
print(x)
輸出：
tensor([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=torch.float64)
tensor([[-1.2174, 1.1807, 1.4249],
[-1.1114, -0.8098, 0.4003],
[ 0.0780, -0.5011, -1.0985],
[ 1.8160, -0.3778, -0.8610],
[-0.7109, -2.0509, -1.2079]])
獲取張量的尺寸：
print(x.size())
輸出：
torch.Size([5, 3])
注意，torch.Size事實上是一個元組，支持所有元組操作。
現在，讓我們看下張量的加法。
張量加法
兩個張量分素相加，得到維度一致的張量，結果張量中每個標量的值是相應標量的和。
y = torch.rand(5, 3)
print(x)
print(y)
print(x + y)
輸出：
tensor([[-1.2174, 1.1807, 1.4249],
[-1.1114, -0.8098, 0.4003],
[ 0.0780, -0.5011, -1.0985],
[ 1.8160, -0.3778, -0.8610],
[-0.7109, -2.0509, -1.2079]])
tensor([[ 0.8285, 0.7619, 0.1147],
[ 0.1624, 0.8994, 0.6119],
[ 0.2802, 0.2950, 0.7098],
[ 0.8132, 0.3382, 0.4383],
[ 0.6738, 0.2022, 0.3264]])
tensor([[-0.3889, 1.9426, 1.5396],
[-0.9490, 0.0897, 1.0122],
[ 0.3583, -0.2061, -0.3887],
[ 2.6292, -0.0396, -0.4227],
[-0.0371, -1.8487, -0.8815]])
除了使用+運算符外，也可以調用torch.add方法（兩者是等價的）：
print(torch.add(x, y))
下面我們來看張量減法。
張量減法
兩個張量分素相減，得到維度一致的張量，結果張量中每個標量的值是相應標量之差。
接著我們將討論張量相乘。
張量乘法
假設mat1是一個(n×m)的張量，mat2是一個(m×p)的張量，兩者相乘，將得到一個(n×p)的張量。
mat1 = torch.randn(2, 3)
mat2 = torch.randn(3, 3)
print(mat1)
print(mat2)
print(torch.mm(mat1, mat2))
輸出：
tensor([[ 1.9490, -0.6503, -1.9448],
[-0.7126, 1.0519, -0.4250]])
tensor([[ 0.0846, 0.4410, -0.0625],
[-1.3264, -0.5265, 0.2575],
[-1.3324, 0.6644, 0.3528]])
tensor([[ 3.6185, -0.0901, -0.9753],
[-0.8892, -1.1504, 0.1654]])
注意，torch.mm()不支持廣播（broadcast）。
廣播
「廣播」這一術語用於描述如何在形狀不一的數組上應用算術運算。在滿足特定限制的前提下，較小的數組「廣播至」較大的數組，使兩者形狀互相兼容。廣播提供了一個向量化數組操作的機制，這樣遍歷就發生在C層面，而不是Python層面。廣播可以避免不必要的數據複製，通常導向高效的算法實現。不過，也存在不適用廣播的情形（可能導致拖慢計算過程的低效內存使用）。
可廣播的一對張量需滿足以下規則：
讓我們通過幾段代碼來理解PyTorch的廣播機制。
x=torch.empty(5,7,3)
y=torch.empty(5,7,3)
相同形狀的張量總是可廣播的，因為總能滿足以上規則。
x=torch.empty((0,))
y=torch.empty(2,2)
不可廣播（x不滿足第一條規則）。
# 為了清晰易讀，可以對齊尾部
x=torch.empty(5,3,4,1)
y=torch.empty( 3,1,1)
x和y可廣播：
倒數第一個維度：兩者的尺寸均為1
倒數第二個維度：y尺寸為1
倒數第三個維度：兩者尺寸相同
倒數第四個維度：y該維度不存在
但下面一對就不可廣播了：
x=torch.empty(5,2,4,1)
y=torch.empty( 3,1,1)
這是因為倒數第三個維度：2 != 3
現在你對「可廣播」這一概念已經有所了解了，讓我們看下，廣播後的張量是什麼樣的。
如果張量x和張量y是可廣播的，那麼廣播後的張量尺寸按照如下方法計算：
如果x和y的維數不等，在維數較少的張量上添加尺寸為1的維度。結果維度尺寸是x和y相應維度尺寸的較大者。例如：
x=torch.empty(5,1,4,1)
y=torch.empty( 3,1,1)
(x+y).size()
輸出：
torch.Size([5, 3, 4, 1])
再如：
x=torch.empty(1)
y=torch.empty(3,1,7)
(x+y).size()
輸出：
torch.Size([3, 1, 7])
再看一個不可廣播的例子：
x=torch.empty(5,2,4,1)
y=torch.empty(3,1,1)
(x+y).size()
報錯：
RuntimeError Traceback (most recent call last)
<ipython-input-17-72fb34250db7> in <module>()
1 x=torch.empty(5,2,4,1)
2 y=torch.empty(3,1,1)
----> 3 (x+y).size()
RuntimeError: The size of tensor a (2) must match the size of tensor b (3) at non-singleton dimension 1
你現在應該已經掌握了廣播這個概念了！
張量乘積是最常見的張量乘法，但也存在其他種類的張量乘法，例如張量點積和張量縮並。
藉助Numpy橋，PyTorch張量和NumPy數組之間的互相轉換極其迅速。下面就讓我們來了解一下這個概念。
NumPy橋
NumPy橋使得PyTorch張量和NumPy數組共享底層內存地址，對其中之一的修改會反映到另一個上。
轉換PyTorch張量至NumPy數組。
a = torch.ones(5)
b = a.numpy()
print(a)
print(b)
輸出：
tensor([ 1., 1., 1., 1., 1.])
[1. 1. 1. 1. 1.]
在這一節中，我們討論了一些基本的張量算術，例如加法、減法、張量乘積。下一節我們將使用PyTorch實現一個基本的神經網絡。
如果你想要溫習一下神經網絡的概念，可以參考以下文章：
在實現神經網絡之前，我們先來討論一下自動微分，這是PyTorch下所有神經網絡的核心，在進行反向傳播計算梯度時尤其有用。
PyTorch的autograd模塊為張量的所有運算提供了自動微分。這是一個define-by-run框架，也就是說，反向傳播由代碼如何運行定義，每個迭代都可以不一樣。
讓我們直接用代碼展示自動微分是如何工作的。
x = torch.ones(2, 2, requires_grad=True)
print(x)
輸出：
tensor([[ 1., 1.],
[ 1., 1.]])
進行加法運算：
y = x + 2
print(y)
輸出：
tensor([[ 3., 3.],
[ 3., 3.]])
再進行一些運算：
z = y * y * 3
out = z.mean()
print(z)
print(out)
輸出：
tensor([[ 27., 27.],
[ 27., 27.]])
tensor(27.)
現在讓我們進行反向傳播：
out.backward()
print(x.grad)
自動微分給出的梯度為：
tensor([[ 4.5000, 4.5000],
[ 4.5000, 4.5000]])
感興趣的讀者可以手工驗證下梯度。
了解了PyTorch如何進行自動微分之後，讓我們使用PyTorch編碼一個簡單的神經網絡。
我們將創建一個簡單的神經網絡，包括一個隱藏層，一個輸出層。隱藏層使用ReLU激活，輸出層使用sigmoid激活。
構建神經網絡需要引入torch.nn模塊：
import torch.nn as nn
接著定義網絡層尺寸和batch尺寸：
n_in, n_h, n_out, batch_size = 10, 5, 1, 10
現在生成一些輸入數據x和目標數據y，並使用PyTorch張量存儲這些數據。
x = torch.randn(batch_size, n_in)
y = torch.tensor([[1.0], [0.0], [0.0], [1.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]])
接下來，只需一行代碼就可以定義我們的模型：
model = nn.Sequential(nn.Linear(n_in, n_h),
nn.ReLU(),
nn.Linear(n_h, n_out),
nn.Sigmoid())
我們創建了一個輸入 -> 線性 -> relu -> 線性 -> sigmoid的模型。對於需要更多自定義功能的更加複雜的模型，可以定義一個類，具體請參考PyTorch文檔。
現在，我們需要構造損失函數。我們將使用均方誤差：
criterion = torch.nn.MSELoss()
然後定義優化器。我們將使用強大的隨機梯度下降算法，學習率定為0.01.model.parameters()會返回一個模型參數（權重、偏置）上的迭代器。
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
下面我們跑50個epoch，這依次包括前向傳播、損失計算、反向傳播和參數更新。
for epoch in range(50):
# 前向傳播
y_pred = model(x)
# 計算並列印損失
loss = criterion(y_pred, y)
print('epoch: ', epoch,' loss: ', loss.item())
# 梯度歸零
optimizer.zero_grad()
# 反向傳播
loss.backward()
# 更新參數
optimizer.step()
輸出：
epoch: 0 loss: 0.2399429827928543
epoch: 1 loss: 0.23988191783428192
epoch: 2 loss: 0.23982088267803192
epoch: 3 loss: 0.2397598922252655
epoch: 4 loss: 0.23969893157482147
epoch: 5 loss: 0.23963800072669983
epoch: 6 loss: 0.23957709968090057
epoch: 7 loss: 0.23951618373394012
epoch: 8 loss: 0.23945537209510803
epoch: 9 loss: 0.23939454555511475
epoch: 10 loss: 0.23933371901512146
epoch: 11 loss: 0.23927298188209534
epoch: 12 loss: 0.23921218514442444
epoch: 13 loss: 0.23915143311023712
epoch: 14 loss: 0.2390907108783722
epoch: 15 loss: 0.23903003334999084
epoch: 16 loss: 0.23896940052509308
epoch: 17 loss: 0.23890872299671173
epoch: 18 loss: 0.23884813487529755
epoch: 19 loss: 0.23878750205039978
epoch: 20 loss: 0.23872694373130798
epoch: 21 loss: 0.2386663407087326
epoch: 22 loss: 0.2386058121919632
epoch: 23 loss: 0.23854532837867737
epoch: 24 loss: 0.23848481476306915
epoch: 25 loss: 0.23842433094978333
epoch: 26 loss: 0.2383638620376587
epoch: 27 loss: 0.23830339312553406
epoch: 28 loss: 0.2382429838180542
epoch: 29 loss: 0.23818258941173553
epoch: 30 loss: 0.2381247729063034
epoch: 31 loss: 0.2380656749010086
epoch: 32 loss: 0.23800739645957947
epoch: 33 loss: 0.2379491776227951
epoch: 34 loss: 0.2378900945186615
epoch: 35 loss: 0.23783239722251892
epoch: 36 loss: 0.23777374625205994
epoch: 37 loss: 0.23771481215953827
epoch: 38 loss: 0.23765745759010315
epoch: 39 loss: 0.23759838938713074
epoch: 40 loss: 0.23753997683525085
epoch: 41 loss: 0.2374821901321411
epoch: 42 loss: 0.23742322623729706
epoch: 43 loss: 0.23736533522605896
epoch: 44 loss: 0.23730707168579102
epoch: 45 loss: 0.23724813759326935
epoch: 46 loss: 0.23719079792499542
epoch: 47 loss: 0.23713204264640808
epoch: 48 loss: 0.23707345128059387
epoch: 49 loss: 0.2370160073041916
PyTorch的寫法很清晰，配上注釋，應該不難理解。如果仍有不解之處，可以參考下面的講解：
y_pred獲取模型一次前向傳播的預測值。y_pred和目標變量y一起傳給criterion以計算損失。
接著，optimizer.zero_grad()清空上一次迭代的梯度。
接下來的loss.backward()集中體現了PyTorch的神奇之處——這裡用到了PyTorch的Autograd（自動計算梯度）特性。Autograd基於動態創建的計算圖自動計算所有參數上的梯度。總的來說，這一步進行的是梯度下降和反向傳播。
最後，我們調用optimizer.step()，使用新的梯度更新一次所有參數。
恭喜你讀到了這篇長文的結尾。這篇文章從張量講到了自動微分，同時基於PyTorch及其張量系統實現了一個簡單的神經網絡。
如果你想了解更多關於PyTorch的內容，或想進一步深入，請閱讀PyTorch的官方文檔和教程，這些文檔和教程寫得非常好。你可以從PyTorch官網找到這些文檔和教程。
撰寫這篇教程的時候，我參考了以下內容：
如果有問題要問，或者有想法要討論，歡迎留言！
如果你打算進一步學習Python，可以參加DataCamp的Statistical Thinking in Python課程。
原文地址：https://www.datacamp.com/community/tutorials/investigating-tensors-pytorch