作為PyTorch中執行深度學習的基本數據類型，張量（Tensor）也擁有非常多的數學運算函數和方法，以及對應的一系列計算規則。在PyTorch中，能夠作用與Tensor的運算，被統一稱作為算子。並且相比於NumPy，PyTorch給出了更加規範的算子（運算）的分類，從而方便用戶在不同場景下調用不同類型的算子（運算）。
由於譜運算（Spectral Ops）前期不會涉及，而要理解傅立葉變換本身需要更多額外的數學基礎，而很多其他運算，我們在前面介紹張量的基本方法時已經介紹，因此接下來將主要圍繞逐點運算、規約運算、比較運算和線性代數運算四塊進行講解，而線性代數部分由於涉及到大量的數學內容，因此將放在後面單獨進行講解。
In [1]:
import torchimport numpy as np關於數學運算的另一種分類方法，是根據運算使用場景進行分類，如基礎數學運算、數理統計運算等。由於PyTorch官網是按照六類算子進行的分類，因此本節將結合兩種分類方法進行講解。1.1 一、張量的廣播（Broadcast）特性 在具體介紹張量的運算操作之前，我們先要了解張量的運算規則，其中最重要的一點，就是張量具備和NumPy相同的廣播特性，也就是允許不同形狀的張量之間進行計算。1.1.1 1.相同形狀的張量計算 根據官網說法，「same shapes are always broadcastable」，相同形狀數組總是可以進行廣播計算。這裡簡單強調一下，雖然我們往往覺得不同形狀之間的張量計算才是應用到廣播特性，但其實相同形狀的張量計算，儘管是對應位置元素進行計算，但本質上也是應用到了廣播特性。In [2]:
t1 = torch.arange(3)t1Out[2]:tensor([0, 1, 2])In [3]:
t1 + t1 Out[3]:tensor([0, 2, 4])思考：如果是兩個list相加，是什麼結果？1.1.2 2.不同形狀的張量計算 廣播的特性是在不同形狀的張量進行計算時，一個或多個張量通過隱式轉化，轉化成相同形狀的兩個張量，從而完成計算的特性。但並非任何兩個不同形狀的張量都可以通過廣播特性進行計算，因此，我們需要了解廣播的基本規則及其核心依據。1.1.2.1 2.1 標量和任意形狀的張量 標量可以和任意形狀的張量進行計算，計算過程就是標量和張量的每一個元素進行計算。In [8]:
t1 + 1 Out[8]:tensor([1, 2, 3])In [9]:
t1 + torch.tensor(1)Out[9]:tensor([1, 2, 3])In [10]:
t2 = torch.zeros((3, 4))t2Out[10]:tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])In [11]:
t2 + 1Out[11]:tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])1.1.2.2 2.2 相同維度、不同形狀的張量之間計算 對於不同形狀的張量計算，我們首先需要回顧張量的形狀屬性，並深化對其的理解。 首先，我們都知道，張量的形狀可以用.shape屬性查看In [45]:
t2.shapeOut[45]:torch.Size([3, 4]) 對於返回結果，我們可以看成是一個序列，代表著張量各維度的信息。當然，對於二維張量，由於我們可以將其視作一個矩陣，因此我們可以說t2是一個擁有三行四列的二維張量，但這種理解方式對於更高維度張量就存在一定的局限，因此我們需要樹立另外一種理解方法，那就是：t2是由3個一維張量組成，並且該一維張量、每個都包含四個元素。類似的，我們可以創建更高維度張量並對其形狀進行解釋。In [46]:
t3 = torch.zeros(3, 4, 5)t3Out[46]:tensor([[[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]])In [47]:
t3.shapeOut[47]:torch.Size([3, 4, 5])我們可以將t3解釋為：t3是3個二維張量組成了三維張量，並且這些每個二維張量，都是由四個包含五個元素的一維張量所組成。由二維拓展至三維，即可拓展至N維。接下來，我們以t2為例，來探討相同維度、不同形狀的張量之間的廣播規則。In [48]:
t2Out[48]:tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])In [49]:
t2.shapeOut[49]:torch.Size([3, 4])In [51]:
t21 = torch.ones(1, 4)t21Out[51]:tensor([[1., 1., 1., 1.]])t21的形狀是（1， 4），和t2的形狀（3， 4）在第一個分量上取值不同，但該分量上t21取值為1，因此可以廣播，也就可以進行計算In [52]:
t21 + t2Out[52]:tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])而t21和t2的實際計算過程如下： 注意理解：此處的廣播相當於將t22的形狀（1， 4）拓展成了t2的（3， 4），也就是複製了第一行三次，然後二者進行相加。當然，也可以理解成t22的第一行和t2的三行分別進行了相加。In [53]:
t22 = torch.ones(3, 1)t22Out[53]:tensor([[1.], [1.], [1.]])In [54]:
t2Out[54]:tensor([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]])In [55]:
t2.shapeOut[55]:torch.Size([3, 4])In [57]:
t22 + t2 Out[57]:tensor([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])t2和t22實際計算過程如下： In [62]:
t23 = torch.ones(2, 4)t23.shapeOut[62]:torch.Size([2, 4])In [63]:
t2.shapeOut[63]:torch.Size([3, 4])註：此時t2和t23的形狀第一個分量維度不同，但二者取值均不為1，因此無法廣播In [61]:
t2 + t23. . .In [73]:
t24 = torch.arange(3).reshape(3, 1)t24Out[73]:tensor([[0], [1], [2]])In [74]:
t25 = torch.arange(3).reshape(1, 3)t25Out[74]:tensor([[0, 1, 2]])此時，t24的形狀是（3， 1），而t25的形狀是（1， 3），二者的形狀在兩個份量上均不相同，但都有存在1的情況，因此也是可以廣播的In [76]:
t24 + t25Out[76]:tensor([[0, 1, 2], [1, 2, 3], [2, 3, 4]])二者計算過程如下： 三維張量的廣播In [64]:
t3 = torch.zeros(3, 4, 5)t3. . .In [36]:
t31 = torch.ones(3, 4, 1)t31. . .In [35]:
t3 + t31. . .In [39]:
t32 = torch.ones(3, 1, 5)t32. . .In [38]:
t32 + t3. . .兩個張量的形狀上有兩個分量不同時，只要不同的分量仍然有一個取值為1，則仍然可以廣播In [40]:
t3.shapeOut[40]:torch.Size([3, 4, 5])In [43]:
t33 = torch.ones(1, 1, 5)t33Out[43]:tensor([[[1., 1., 1., 1., 1.]]])In [42]:
t3 + t33. . .t3和t33計算過程如下 註：此處標註的兩次廣播，我們也可認為上述全部過程的實現是一次「大的」廣播。同時，此處最開始的t33也就相當於一個一維的、包含五個元素的張量，因此上述過程也可視為一個一維張量和一個三維張量計算時的廣播過程。1.1.2.3 2.3 不同維度的張量計算過程中廣播 在理解相同維度、不同形狀的張量廣播之後，對於不同維度的張量之間的廣播其實就會容易很多，因為對於不同維度的張量，我們首先可以將低維的張量升維，然後依據相同維度不同形狀的張量廣播規則進行廣播。而低維向量的升維也非常簡單，只需將更高維度方向的形狀填充為1即可，例如：In [79]:
t2 = torch.arange(4).reshape(2, 2)t2Out[79]:tensor([[0, 1], [2, 3]])In [81]:
t2.reshape(1, 2, 2)Out[81]:tensor([[[0, 1], [2, 3]]])轉化之後表示只包含一個二維張量的三維張量，且二維張量就是t2In [82]:
t2.reshape(1, 1, 2, 2)Out[82]:tensor([[[[0, 1], [2, 3]]]])轉化之後表示只包含一個三維張量的四維張量，且三維張量只包含一個二維張量，且二維張量就是t2In [83]:
t3 = torch.zeros(3, 2, 2)t3和t2的計算過程，就相當於形狀為（1，2，2）和（3，2，2）的兩個張量進行計算In [84]:
t3 + t2Out[84]:tensor([[[0., 1.], [2., 3.]],
[[0., 1.], [2., 3.]],
[[0., 1.], [2., 3.]]])In [85]:
t3 + t2.reshape(1, 2, 2)Out[85]:tensor([[[0., 1.], [2., 3.]],
[[0., 1.], [2., 3.]],
[[0., 1.], [2., 3.]]])思考：形狀為（2，1）的張量和形狀為（3，2，3）的張量可以進行廣播計算麼？計算過程是怎樣的？1.2 二、逐點運算（Pointwise Ops） PyTorch中逐點運算大部分都是可以針對Tensor中每個元素都進行的數學科學運算，並且都是較為通用的數學科學運算，和NumPy中針對Array的科學運算類似。在PyTorch中文文檔中有全部運算符的相關介紹，此處僅針對常用計算函數進行介紹。 逐點運算主要包括數學基本運算、數值調整運算和數據科學運算三塊，相關函數如下：
Tensor基本數學運算
函數描述torch.add(t1，t2 ) t1、t2兩個張量逐個元素相加，等效於t1+t2 torch.subtract(t1，t2) t1、t2兩個張量逐個元素相減，等效於t1-t2 torch.multiply(t1，t2) t1、t2兩個張量逐個元素相乘，等效於t1*t2 torch.divide(t1，t2) t1、t2兩個張量逐個元素相除，等效於t1/t2 In [87]:
t1 = torch.tensor([1, 2])t1Out[87]:tensor([1, 2])In [88]:
t2 = torch.tensor([3, 4])t2Out[88]:tensor([3, 4])In [89]:
torch.add(t1, t2)Out[89]:tensor([4, 6])In [90]:
t1 + t2Out[90]:tensor([4, 6])In [91]:
t1 / t2Out[91]:tensor([0.3333, 0.5000])
Tensor數值調整函數
函數描述torch.abs(t) 返回絕對值 torch.ceil(t) 向上取整 torch.floor(t) 向下取整 torch.round(t) 四捨五入取整 torch.neg(t) 返回相反的數 In [2]:
t = torch.randn(5)tOut[2]:tensor([-0.5184, -0.4910, -0.1381, -0.2500, -0.4295])In [3]:
torch.round(t)Out[3]:tensor([-1., -0., -0., -0., -0.])In [4]:
torch.abs(t)Out[4]:tensor([0.5184, 0.4910, 0.1381, 0.2500, 0.4295])In [5]:
torch.neg(t)Out[5]:tensor([0.5184, 0.4910, 0.1381, 0.2500, 0.4295])註：雖然此類型函數是數值調整函數，但並不會對原對象進行調整，而是輸出新的結果。In [7]:
t Out[7]:tensor([-0.5184, -0.4910, -0.1381, -0.2500, -0.4295])而若要對原對象本身進行修改，則可考慮使用方法_()的表達形式，對對象本身進行修改。此時方法就是上述同名函數。In [8]:
t.abs_()Out[8]:tensor([0.5184, 0.4910, 0.1381, 0.2500, 0.4295])In [9]:
tOut[9]:tensor([0.5184, 0.4910, 0.1381, 0.2500, 0.4295])In [10]:
t.neg_()Out[10]:tensor([-0.5184, -0.4910, -0.1381, -0.2500, -0.4295])In [11]:
tOut[11]:tensor([-0.5184, -0.4910, -0.1381, -0.2500, -0.4295])除了上述數值調整函數有對應的同名方法外，本節介紹的許多科學計算都有同名方法。In [12]:
t.exp_()Out[12]:tensor([0.5955, 0.6120, 0.8710, 0.7788, 0.6508])In [13]:
tOut[13]:tensor([0.5955, 0.6120, 0.8710, 0.7788, 0.6508])
Tensor常用科學計算
數學運算函數數學公式描述冪運算 torch.exp(t) $ y_{i} = e^{x_{i}} $ 返回以e為底、t中元素為冪的張量 torch.expm1(t) $ y_{i} = e^{x_{i}} $ - 1 對張量中的所有元素計算exp（x） - 1 torch.exp2(t) $ y_{i} = 2^{x_{i}} $ 逐個元素計算2的t次方。 torch.pow(t,n) $\text{out}_i = x_i ^ \text{exponent} $ 返回t的n次冪 torch.sqrt(t) $ \text{out}_{i} = \sqrt{\text{input}_{i}} $ 返回t的平方根 torch.square(t) $ \text{out}_i = x_i ^ \text{2} $ 返回輸入的元素平方。 對數運算 torch.log10(t) $ y_{i} = \log_{10} (x_{i}) $ 返回以10為底的t的對數 torch.log(t) $ y_{i} = \log_{e} (x_{i}) $ 返回以e為底的t的對數 torch.log2(t) $ y_{i} = \log_{2} (x_{i}) $ 返回以2為底的t的對數 torch.log1p(t) $ y_i = \log_{e} (x_i $ + 1) 返回一個加自然對數的輸入數組。 三角函數運算 torch.sin(t) 三角正弦。 torch.cos(t) 元素餘弦。 torch.tan(t) 逐元素計算切線。 tensor的大多數科學計算只能作用於tensor對象In [124]:
torch.pow(2, 2). . .In [125]:
torch.pow(torch.tensor(2), 2)Out[125]:tensor(4)理解：相比於Python原生數據類型，張量是一類更加特殊的對象，例如張量可以指定運行在CPU或者GPU上，因此很多張量的科學計算函數都不允許張量和Python原生的數值型對象混合使用。tensor的大多數科學運算具有一定的靜態性 所謂靜態性，指的是對輸入的張量類型有明確的要求，例如部分函數只能輸入浮點型張量，而不能輸入整型張量。In [102]:
t = torch.arange(1, 4)t.dtypeOut[102]:torch.int64In [103]:
torch.exp(t)RuntimeError Traceback (most recent call last)<ipython-input-103-ad3d5759497c> in <module>----> 1 torch.exp(t)
RuntimeError: exp_vml_cpu not implemented for 'Long'
需要注意的是，雖然Python是動態編譯的程式語言，但在PyTorch中，由於會涉及GPU計算，因此很多時候元素類型不會在實際執行函數計算時進行調整。此處的科學運算大多數都要求對象類型是浮點型，我們需要提前進行類型轉化。In [104]:
t1 = t.float()t1Out[104]:tensor([1., 2., 3.])In [22]:
torch.exp(t1)Out[22]:tensor([ 2.7183, 7.3891, 20.0855])In [24]:
torch.expm1(t1)Out[24]:tensor([ 1.7183, 6.3891, 19.0855])注，此處返回結果是$e^{t} - 1$，在數值科學計算中，expm1函數和log1p函數是一對對應的函數關係，後面再介紹log1p的時候會講解這對函數的實際作用。In [25]:
torch.exp2(t1)Out[25]:tensor([2., 4., 8.])In [26]:
torch.pow(t, 2)Out[26]:tensor([1, 4, 9])注意區分2的t次方和t的2次方In [28]:
torch.square(t)Out[28]:tensor([1, 4, 9])In [38]:
torch.sqrt(t1)Out[38]:tensor([1.0000, 1.4142, 1.7321])In [39]:
torch.pow(t1, 0.5)Out[39]:tensor([1.0000, 1.4142, 1.7321])開根號也就相當於0.5次冪In [30]:
torch.log10(t1)Out[30]:tensor([0.0000, 0.3010, 0.4771])In [31]:
torch.log(t1)Out[31]:tensor([0.0000, 0.6931, 1.0986])In [36]:
torch.log2(t1)Out[36]:tensor([0.0000, 1.0000, 1.5850])同時，我們也可簡單回顧冪運算和對數運算之間的關係In [34]:
torch.exp(torch.log(t1))Out[34]:tensor([1., 2., 3.])In [37]:
torch.exp2(torch.log2(t1))Out[37]:tensor([1., 2., 3.])In [7]:
a = torch.tensor(-1).float()aOut[7]:tensor(-1.)In [8]:
torch.exp2(torch.log2(a))Out[8]:tensor(nan)排序運算：sort 在PyTorch中，sort排序函數將同時返回排序結果和對應的索引值的排列。In [222]:
t = torch.tensor([1.0, 3.0, 2.0])tOut[222]:tensor([1., 3., 2.])In [225]:
torch.sort(t)Out[225]:torch.return_types.sort(values=tensor([1., 2., 3.]),indices=tensor([0, 2, 1]))In [226]:
torch.sort(t, descending=True)Out[226]:torch.return_types.sort(values=tensor([3., 2., 1.]),indices=tensor([1, 2, 0]))1.3 三、規約運算 規約運算指的是針對某張量進行某種總結，最後得出一個具體總結值的函數。此類函數主要包含了數據科學領域內的諸多統計分析函數，如均值、極值、方差、中位數函數等等。
Tensor統計分析函數
函數描述torch.mean(t) 返回張量均值 torch.var(t) 返回張量方差 torch.std(t) 返回張量標準差 torch.var_mean(t) 返回張量方差和均值 torch.std_mean(t) 返回張量標準差和均值 torch.max(t) 返回張量最大值 torch.argmax(t) 返回張量最大值索引 torch.min(t) 返回張量最小值 torch.argmin(t) 返回張量最小值索引 torch.median(t) 返回張量中位數 torch.sum(t) 返回張量求和結果 torch.logsumexp(t) 返回張量各元素求和結果，適用於數據量較小的情況 torch.prod(t) 返回張量累乘結果 torch.dist(t1, t2) 計算兩個張量的閔式距離，可使用不同範式 torch.topk(t) 返回t中最大的k個值對應的指標 In [199]:
t = torch.arange(10).float()tOut[199]:tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])In [200]:
torch.mean(t)Out[200]:tensor(4.5000)In [201]:
torch.std_mean(t)Out[201]:(tensor(3.0277), tensor(4.5000))In [202]:
torch.max(t)Out[202]:tensor(9.)In [203]:
torch.argmax(t)Out[203]:tensor(9)In [204]:
torch.median(t)Out[204]:tensor(4.)In [205]:
torch.sum(t)Out[205]:tensor(45.)In [206]:
torch.prod(t)Out[206]:tensor(0.)In [207]:
torch.prod(torch.tensor([1, 2, 3]))Out[207]:tensor(6)In [208]:
t1 = torch.tensor([1.0, 2])t1Out[208]:tensor([1., 2.])In [209]:
t2 = torch.tensor([3.0, 4])t2Out[209]:tensor([3., 4.])In [212]:
tOut[212]:tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])torch.topk(t, 2)dist計算距離 dist函數可計算閔式距離（閔可夫斯基距離），通過輸入不同的p值，可以計算多種類型的距離，如歐式距離、街道距離等。閔可夫斯基距離公式如下：$ D(x,y) = (\sum^{n}_{u=1}|x_u-y_u|^{p})^{1/p}$p取值為2時，計算歐式距離In [157]:
torch.dist(t1, t2, 2)Out[157]:tensor(2.8284)In [158]:
torch.sqrt(torch.tensor(8.0))Out[158]:tensor(2.8284)p取值為1時，計算街道距離In [159]:
torch.dist(t1, t2, 1)Out[159]:tensor(4.)規約運算的維度 由於規約運算是一個序列返回一個結果，因此若是針對高維張量，則可指定某維度進行計算。In [9]:
t2 = torch.arange(12).float().reshape(3, 4)t2Out[9]:tensor([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]])In [229]:
t2.shapeOut[229]:torch.Size([3, 4])In [192]:
torch.sum(t2, dim = 0)Out[192]:tensor([12., 15., 18., 21.])In [193]:
torch.sum(t2, dim = 1)Out[193]:tensor([ 6., 22., 38.])In [19]:
t3 = torch.arange(24).float().reshape(2, 3, 4)t3Out[19]:tensor([[[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.]],
[[12., 13., 14., 15.], [16., 17., 18., 19.], [20., 21., 22., 23.]]])In [20]:
t3.shapeOut[20]:torch.Size([2, 3, 4])In [21]:
torch.sum(t3, dim = 0)Out[21]:tensor([[12., 14., 16., 18.], [20., 22., 24., 26.], [28., 30., 32., 34.]])In [197]:
torch.sum(t3, dim = 1)Out[197]:tensor([[12., 15., 18., 21.], [48., 51., 54., 57.]])In [198]:
torch.sum(t3, dim = 2)Out[198]:tensor([[ 6., 22., 38.], [54., 70., 86.]])理解：dim參數和shape返回結果一一對應。二維張量的排序和上述過程類似，在進行排序過程中，二維張量也可以按行或者按列進行排序In [246]:
t22 = torch.randn(3, 4) t22Out[246]:tensor([[ 0.0274, -1.1111, -0.0721, 0.0524], [-0.1148, -1.5132, -0.0838, 0.4069], [-0.9713, -0.9050, -0.4375, -0.6726]])In [247]:
torch.sort(t22)Out[247]:torch.return_types.sort(values=tensor([[-1.1111, -0.0721, 0.0274, 0.0524], [-1.5132, -0.1148, -0.0838, 0.4069], [-0.9713, -0.9050, -0.6726, -0.4375]]),indices=tensor([[1, 2, 0, 3], [1, 0, 2, 3], [0, 1, 3, 2]]))In [249]:
torch.sort(t22, dim = 1, descending=True)Out[249]:torch.return_types.sort(values=tensor([[ 0.0524, 0.0274, -0.0721, -1.1111], [ 0.4069, -0.0838, -0.1148, -1.5132], [-0.4375, -0.6726, -0.9050, -0.9713]]),indices=tensor([[3, 0, 2, 1], [3, 2, 0, 1], [2, 3, 1, 0]]))1.3.1 四、比較運算 比較運算是一類較為簡單的運算類型，和Python原生的布爾運算類似，常用於不同張量之間的邏輯運算，最終返回邏輯運算結果（邏輯類型張量）。基本比較運算函數如下所示：
Tensor比較運算函數
函數描述torch.eq(t1, t2) 比較t1、t2各元素是否相等，等效== torch.equal(t1, t2) 判斷兩個張量是否是相同的張量 torch.gt(t1, t2) 比較t1各元素是否大於t2各元素，等效> torch.lt(t1, t2) 比較t1各元素是否小於t2各元素，等效< torch.ge(t1, t2) 比較t1各元素是否大於或等於t2各元素，等效>= torch.le(t1, t2) 比較t1各元素是否小於等於t2各元素，等效<= torch.ne(t1, t2) 比較t1、t2各元素是否不相同，等效!= In [214]:
t1 = torch.tensor([1.0, 3, 4])In [215]:
t2 = torch.tensor([1.0, 2, 5])In [216]:
t1 == t2Out[216]:tensor([ True, False, False])In [217]:
torch.equal(t1, t2) Out[217]:FalseIn [218]:
torch.eq(t1, t2)Out[218]:tensor([ True, False, False])In [219]:
t1 > t2Out[219]:tensor([False, True, False])In [220]:
t1 >= t2Out[220]:tensor([ True, True, False])