1. Tensor 數據類型

Tensor 有不同的數據類型，如下表所示，每種類型都有 CPU 和 GPU 版本（HalfTensor）除外，默認的 tensor 是數據類型是 FloatTensor，只能通過 t.set_default_tensor_type 修改 tensor 為浮點類型，（如果默認類型為 GPU tensor，則所有的操作都在 GPU 上進行）。

獲取 torch 默認的數據類型。

In [113]: import torch as tIn [114]: t.get_default_dtype()                                                                                                                                      
Out[114]: torch.float32

HalfTensor 是專門為 GPU 版本設計的，同樣的元素個數顯存只有 FloatTensor 的一半，可以緩解 GPU 顯存不足問題，但由于 HalfTensor 能表示的數值大小和精度有限，有可能出現溢出等問題。

使用 t.set_default_tensor_type 將默認數據類型修改為 IntTensor 時會報錯。

In [124]: t.set_default_tensor_type(t.IntTensor)                                                                                                                     
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-124-434c3566c688> in <module>
----> 1 t.set_default_tensor_type(t.IntTensor)/usr/local/lib/python3.6/dist-packages/torch/__init__.py in set_default_tensor_type(t)204     if isinstance(t, _string_classes):205         t = _import_dotted_name(t)
--> 206     _C._set_default_tensor_type(t)207 208 TypeError: only floating-point types are supported as the default type

只能設置為 FloatTensor 類型。

In [125]: t.set_default_tensor_type(t.FloatTensor) 

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）

2. 數據類型之間轉換

各數據類型之間可以相互轉換，type(new_type) 是通用的做法，同時還有 float/long/half 等快捷方法。

In [101]: a = t.ones(2,3)                                                                                                                                            In [102]: a                                                                                                                                                          
Out[102]: 
tensor([[1., 1., 1.],[1., 1., 1.]])In [103]: a.type()                                                                                                                                                   
Out[103]: 'torch.FloatTensor'In [104]: b = a                                                                                                                                                      In [105]: b.int()                                                                                                                                                    
Out[105]: 
tensor([[1, 1, 1],[1, 1, 1]], dtype=torch.int32)In [106]: a.type(t.IntTensor)      # 等價于 a.int()                                                                                                                                  
Out[106]: 
tensor([[1, 1, 1],[1, 1, 1]], dtype=torch.int32)

3. CPU 和 GPU 之間轉換

CPU tensor 和 GPU tensor 之間的互相轉換可以通過 tensor.cuda 和 tensor.cpu 方法來實現。

In [115]: a = t.ones(2,3)                                                                                                                                            In [116]: a.type()                                                                                                                                                   
Out[116]: 'torch.FloatTensor'In [117]: a                                                                                                                                                          
Out[117]: 
tensor([[1., 1., 1.],[1., 1., 1.]])In [118]: a.cuda()                                                                                                                                                   
Out[118]: 
tensor([[1., 1., 1.],[1., 1., 1.]], device='cuda:0')In [119]: b = a.cuda()                                                                                                                                               In [120]: b                                                                                                                                                          
Out[120]: 
tensor([[1., 1., 1.],[1., 1., 1.]], device='cuda:0')In [121]: b.type()                                                                                                                                                   
Out[121]: 'torch.cuda.FloatTensor'In [122]: b.cpu()                                                                                                                                                    
Out[122]: 
tensor([[1., 1., 1.],[1., 1., 1.]])In [123]: b.cpu().type()                                                                                                                                             
Out[123]: 'torch.FloatTensor'In [124]: 

總結

以上是生活随笔為你收集整理的PyTorch 笔记（03）— Tensor 数据类型分类（默认数据类型、CPU tensor、GPU tensor、CPU 和 GPU 之间的转换、数据类型之间转换）的全部內容，希望文章能夠幫你解決所遇到的問題。

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