PyTorch 的安裝可以到官網 https://pytorch.org/，選擇適合自己機器以及安裝方式，執行對應的命令即可。
除了安裝 PyTorch 之外，建議也安裝 torchvision 包。torchvision 包是服務于 PyTorch 深度學習框架的，用來生成圖片、視頻數據集和一些流行的模型類和預訓練模型。

簡單來說，torchvision 由 torchvision.datasets 、torchvision.models 、torchvision.transforms 、torchvision.utils 四個模塊組成。

PyTorch 中的張量（Tensor）類似 NumPy 中的 ndarrays，之所以稱之為 Tensor 的另一個原因是它可以運行在 GPU 中，以加速運算。

PyTorch 中的 Tensor 也有自己的數據類型定義方式，常用的如下。

1. Tensor 基本數據類型

1.1 torch.FloatTensor

用于生成數據類型為浮點型的 Tensor，傳遞給 torch.FloatTensor 的參數可以是一個列表，也可以是一個維度值。

import torcha = torch.FloatTensor(2, 3)
b = torch.FloatTensor([1, 2, 3, 4])

輸出結果：

tensor([[2.3489e-37, 4.5835e-41, 2.3489e-37],[4.5835e-41, 4.4842e-44, 0.0000e+00]])tensor([1., 2., 3., 4.])

可以看到，打印輸出的兩組變量數據類型都顯示為浮點型，不同的是，前面的一組是按照我們指定的維度隨機生成的浮點型 Tensor 而另外一組是按我們給定的列表生成的浮點型 Tensor。

1.2 torch.IntTensor

用于生成數據類型為整型的 Tensor。傳遞給 torch.IntTensor 的參數可以是一個列表，也可以是一個維度值。

import torcha = torch.IntTensor(2, 3)
b = torch.IntTensor([1, 2, 3, 4])

輸出結果：

tensor([[1491430264,      32561, 1491430264],[     32561,  808464432,  808463205]], dtype=torch.int32)
tensor([1, 2, 3, 4], dtype=torch.int32)

可以看出輸出的數據類型都為整形（torch.int32）

1.3 torch.rand

用于生成數據類型為浮點型且維度指定的隨機 Tensor，和在 NumPy 中使用 numpy.rand 生成隨機數的方法類似，隨機生成的浮點數據在 0~1 區間均勻分布。

import torcha = torch.rand(2, 3)

輸出結果：

tensor([[0.6882, 0.4118, 0.2646],[0.0583, 0.2187, 0.8093]])

1.4 torch.randn

用于生成數據類型為浮點型且維度指定的隨機 Tensor，和在 NumPy 中使用 numpy.randn 生成隨機數的方法類似，隨機生成的浮點數的取值滿足均值為 0、方差為 1 的正態分布。

import torcha = torch.randn(2, 3)

輸出結果：

tensor([[ 0.2214, -0.0139, -0.0720],[ 0.2548, -1.3364,  0.3924]])

1.5 torch.arange

用于生成數據類型為浮點型且自定義起始范圍和結束范圍的 Tensor，所以傳遞給 torch.arange 的參數有三個，分別是范圍的起始值、范圍的結束值和步長，其中，步長用于指定從起始值到結束值的每步的數據間隔。

import torcha = torch.arange(1, 10, 2)

輸出結果：

tensor([1, 3, 5, 7, 9])

1.6 torch.zeros

用于生成數據類型為浮點型且維度指定的 Tensor，不過這個浮點型的 Tensor中的元素值全部為 0

import torcha = torch.zeros(2, 3, dtype=torch.int8)
print a

輸出結果：

tensor([[0, 0, 0],[0, 0, 0]], dtype=torch.int8)

2. Tensor 基本運算

2.1 torch.abs

將參數傳遞到 torch.abs 后返回輸入參數的絕對值作為輸出，輸入參數必須是一個 Tensor 數據類型的變量。

import torch
a = torch.randn(2, 3)
print a
b = torch.abs(a)
print b

輸出結果：

tensor([[ 0.4873,  0.8172,  0.2003],[ 0.6815,  1.5656, -0.8303]])
tensor([[0.4873, 0.8172, 0.2003],[0.6815, 1.5656, 0.8303]])

2.2 torch.add

將參數傳遞到 torch.add 后返回輸入參數的求和結果作為輸出，輸入參數既可以全部是 Tensor 數據類型的變量，也可以一個是 Tensor 數據類型的變量，另一個是標量。

a = torch.ones([2, 3])
print a
b = torch.add(a, 10)
print b
c = torch.randn([2, 3])
print c
d = torch.add(a, c)
print d

輸出結果：

tensor([[1., 1., 1.],[1., 1., 1.]])
tensor([[11., 11., 11.],[11., 11., 11.]])
tensor([[ 0.4276,  0.4618, -0.9449],[-1.4758, -1.3118, -0.2859]])
tensor([[ 1.4276,  1.4618,  0.0551],[-0.4758, -0.3118,  0.7141]])

2.3 torch.clamp

對輸入參數按照自定義的范圍進行裁剪，最后將參數裁剪的結果作為輸出。所以輸入參數一共有三個，分別是需要進行裁剪的 Tensor 數據類型的變量、裁剪的上邊界和裁剪的下邊界。

具體的裁剪過程是：使用變量中的每個元素分別和裁剪的上邊界及裁剪的下邊界的值進行比較，如果元素的值小于裁剪的下邊界的值，該元素就被重寫成裁剪的下邊界的值；同理,如果元素的值大于裁剪的上邊界的值，該元素就被重寫成裁剪的上邊界的值。

a = torch.randn(2,3)
print a
b = torch.clamp(a, -0.1, 0.1)
print b

輸出結果：

tensor([[-1.0129, -1.3094,  0.4644],[ 1.0542, -0.5259, -0.3575]])
tensor([[-0.1000, -0.1000,  0.1000],[ 0.1000, -0.1000, -0.1000]])

2.4 torch.div

將參數傳遞到 torch.div 后返回輸入參數的求商結果作為輸出，同樣，參與運算的參數可以全部是 Tensor 數據類型的變量，也可以是 Tensor 數據類型的變量和標量的組合。

a = torch.IntTensor([2,4,6,8,10])
print a
b = torch.div(a, 2)
print b
c = torch.IntTensor([2,4,6,8,10])
d = torch.div(a, c)
print d

輸出結果：

tensor([ 2,  4,  6,  8, 10], dtype=torch.int32)
tensor([1, 2, 3, 4, 5], dtype=torch.int32)
tensor([1, 1, 1, 1, 1], dtype=torch.int32)

2.5 torch.mul

將參數傳遞到 torch.mul 后返回輸入參數求積的結果作為輸出，參與運算的參數可以全部是 Tensor 數據類型的變量，也可以是 Tensor 數據類型的變量和標量的組合。

a = torch.IntTensor([2,4,6,8,10])
print a
b = torch.mul(a, 2)
print b
c = torch.IntTensor([2,4,6,8,10])
d = torch.mul(a, c)
print d

輸出結果：

tensor([ 2,  4,  6,  8, 10], dtype=torch.int32)
tensor([ 4,  8, 12, 16, 20], dtype=torch.int32)
tensor([  4,  16,  36,  64, 100], dtype=torch.int32)

2.6 torch.pow

將參數傳遞到 torch.pow 后返回輸入參數的求冪結果作為輸出，參與運算的參數可以全部是 Tensor 數據類型的變量，也可以是 Tensor 數據類型的變量和標量的組合。

a = torch.IntTensor([2,4,6,8,10])
print a
b = torch.pow(a, 2)
print b
c = torch.IntTensor([3,3,3,3,3])
d = torch.pow(a, c)
print d

輸出結果：

tensor([ 2,  4,  6,  8, 10], dtype=torch.int32)
tensor([  4,  16,  36,  64, 100], dtype=torch.int32)
tensor([   8,   64,  216,  512, 1000], dtype=torch.int32)

2.7 torch.mm

將參數傳遞到 torch.mm 后返回輸入參數的求積結果作為輸出，不過這個求積的方式和之前的 torch.mul 運算方式不太一樣， torch.mm 運用矩陣之間的乘法規則進行計算，所以被傳入的參數會被當作矩陣進行處理，參數的維度自然也要滿足矩陣乘法的前提條件，即前一個矩陣的行數必須和后一個矩陣的列數相等，否則不能進行計算。

a = torch.IntTensor([[1,2,3], [4,5,6]])
print a
b = torch.IntTensor([[1,2], [4,5], [7, 8]])
print b
c = torch.mm(a, b)
print c

輸出結果：

tensor([[1, 2, 3],[4, 5, 6]], dtype=torch.int32)
tensor([[1, 2],[4, 5],[7, 8]], dtype=torch.int32)
tensor([[30, 36],[66, 81]], dtype=torch.int32)

2.8 torch.mv

將參數傳遞到 torch.mv 后返回輸入參數的求積結果作為輸出，torch.mv 運用矩陣與向量之間的乘法規則進行計算，被傳入的參數中的第 1 個參數代表矩陣，第 2 個參數代表向量，順序不能顛倒。

a = torch.IntTensor([[1,0,0], [0,0,1]])
print a
b = torch.IntTensor([3,3,3])
print b
c = torch.mv(a, b)
print c

輸出結果：

tensor([[1, 0, 0],[0, 0, 1]], dtype=torch.int32)
tensor([3, 3, 3], dtype=torch.int32)
tensor([3, 3], dtype=torch.int32)

3. Tensor 與 NumPy

Tensor 可以與 NumPy 相互轉化。

• Tensor 轉化為 NumPy

In[2]: import torch
In[3]: a = torch.ones(5)
In[4]: a
Out[4]: tensor([1., 1., 1., 1., 1.])
In[5]: b = a.numpy()
In[6]: b
Out[6]: array([1., 1., 1., 1., 1.], dtype=float32)

• NumPy 轉化為 Tensor

In[7]: import numpy as np
In[8]: a = np.ones(5)
In[9]: a
Out[9]: array([1., 1., 1., 1., 1.])
In[10]: b = torch.from_numpy(a)
In[11]: b
Out[11]: tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

值得注意的是，Torch 中的 Tensor 和 NumPy 中的 Array 共享內存位置，一個改變，另一個也同樣改變。注意使用的是 b.add_() 。

In[15]: b.add_(1)
Out[15]: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
In[16]: a
Out[16]: array([2., 2., 2., 2., 2.])
In[17]: b
Out[17]: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

下面看使用 b.add() 發現 b 并沒有改變。

In[18]: b.add(2)
Out[18]: tensor([4., 4., 4., 4., 4.], dtype=torch.float64)
In[19]: a
Out[19]: array([2., 2., 2., 2., 2.])
In[20]: b
Out[20]: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

b.add_() 和 b.add() 的區別：
任何操作符都固定地在前面加上 _ 來表示替換。例如：y.copy_(x) ，y.t_()，都將改變 y。

4. Tensor 用 GPU 加速

Tensor 可以被移動到任何設備中，例如 GPU 以加速運算，使用 .to 方法即可。

x = torch.randn(1)
if torch.cuda.is_available():device = torch.device("cuda")            y = torch.ones_like(x, device=device)    # directly create a tensor on GPUx = x.to(device)                         z = x + yprint(z)print(z.to("cpu", torch.double))  

輸出：

tensor([ 2.0718], device='cuda:0')
tensor([ 2.0718], dtype=torch.float64)

總結

以上是生活随笔為你收集整理的PyTorch 安装和基本运算— Tensor 的数据类型（浮点型、整型、随机浮点型等）、基本运算（绝对值、求和、裁剪、求商、求积、求幂等）、Tensor 与 Numpy 转换的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。