pytorch創建tensor數據

一、傳入數據

tensor只能傳入數據

可以傳入現有的數據列表或矩陣

import torch
# 當是標量時候，即只有一個數據時候，[]括號是可以省略的
torch.tensor(2)
# 輸出：
    tensor(2)

# 如果是向量或矩陣，必須有[]括號
torch.tensor([2, 3])
# 輸出：
    tensor([2, 3])

Tensor可以傳入數據、維度。

建議tensor給數據，Tensor給維度，不然容易把維度和數據搞混淆

# 沒有[]時候是指維度，數據是隨機初始化的，都接近於0
torch.Tensor(4)
# 輸出：
    tensor([0., 0., 0., 0.])

# 當有[]時候是指數據
torch.Tensor([2])
# 輸出：
      tensor([2.])

```python
# float類型
torch.FloatTensor(3)
# 輸出：
      tensor([0., 0., 0.])

# double類型。
# 一般在增強學習里面用Double類型，因為增強學習對數據精度要求更高。
# 其他地方一般用float類型就夠了。精度越高消耗的資源也會越多。
torch.DoubleTensor(3)
# 輸出：
    tensor([3.5825e+246, 2.0475e+161, 3.1725e+180], dtype=torch.float64)

二、傳入維度的方法

rand

# 傳入維度，隨機生成相應維度數據
# 生成的數是0~1之間的，隨機分布的數據（均勻分布）
# 默認是N(0, 1)均值為0，方差為1
# 推薦使用rand方法初始化數據
torch.rand(2, 3, 2)
# 輸出：
    tensor([[[0.0316, 0.3464],
             [0.2537, 0.3074],
             [0.4512, 0.5535]],
    
            [[0.5645, 0.9134],
             [0.7151, 0.2645],
             [0.9773, 0.6580]]])

# 維度可以加括號
torch.rand([2, 3, 2])
# 輸出：
    tensor([[[0.3623, 0.7754],
             [0.7515, 0.0527],
             [0.2006, 0.6329]],
    
            [[0.7246, 0.0875],
             [0.8303, 0.2042],
             [0.7149, 0.2826]]])

rand_like

a  = torch.ones(2, 3)
a
# 輸出：
    tensor([[1., 1., 1.],
            [1., 1., 1.]])

# 根據a數據的shape來生成隨機數據
# 另外還有：ones_like、zeros_like等。
torch.rand_like(a)
# 輸出：
    tensor([[0.6721, 0.8581, 0.2823],
            [0.0510, 0.9334, 0.8291]])

randint

# 生成1~10之間隨機整數
# [2, 5]是維度
torch.randint(1, 10, [2, 5]) 
# 輸出：
    tensor([[8, 2, 5, 5, 2],
            [5, 7, 8, 1, 7]])

normal

# 生成正態分布數據
# 維度2行3列
# 均值為4
# 方差0.6-0.1的數據。方差數據量需要與維度數據量相等：
# 比如此處是2*3=6個數據。方差就是6個數據。
torch.normal(mean=torch.full([2, 3], 4), std=torch.arange(0.6, 0, -0.1))
# 輸出：
    tensor([[3.7889, 3.9049, 3.9840],
            [4.1137, 3.9285, 4.0589]])

full

# 生成給定維度，全部數據相等的數據
torch.full([2, 3], 7)
# 輸出：
    tensor([[7., 7., 7.],
            [7., 7., 7.]])

# 也可以給定空維度，生成標量
torch.full([], 7)
# 輸出：
    tensor(7.)

# 一維，長度為1的向量
torch.full([1], 7)
# 輸出：
    tensor([7.])

arange

也可以用 range()，但不推薦

# 生成[0, 10)的tensor
torch.arange(0, 10)
# 輸出：
    tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 生成[0, 10)間隔為2的tensor
torch.arange(0, 10, 2)
# 輸出：
    tensor([0, 2, 4, 6, 8])

linspace

# 將[0，10]等分切割成4份
torch.linspace(0, 10, steps=4)
# 輸出：
    tensor([ 0.0000,  3.3333,  6.6667, 10.0000])

ones

# 給定維度，生成全為1的數據
c = torch.ones(3, 3)
c
# 輸出：
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

ones_like

torch.ones_like(c)
# 輸出：
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

zeros

# 生成全為0的tensor
a = torch.zeros(3, 3) 
a
# 輸出：
    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])

zeros_like

torch.zeros_like(a)
# 輸出：
    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])

eye

 torch.eye(3, 3)  # 生成對角矩陣
# 輸出：
    tensor([[1., 0., 0.],
            [0., 1., 0.],
            [0., 0., 1.]])

 torch.eye(3, 4)  # 若不是方陣，最后多的列會用0填充
# 輸出：
    tensor([[1., 0., 0., 0.],
            [0., 1., 0., 0.],
            [0., 0., 1., 0.]])

empty

# 給定維度，隨機生成未初始化的數據
# 非常不規則，可能出現非常大，非常小的情況，盡量要覆蓋完成數據
torch.empty(1, 2)
# 輸出：
    tensor([[        inf, 6.9533e-310]])

randperm

生成隨機排序的整數序列

torch.randperm(10)  # 相當於[0, 10) 的隨機排序
# 輸出：
    tensor([0, 5, 3, 9, 8, 1, 2, 6, 7, 4])

# 定義a、b兩個維度相等的數據
a = torch.rand(2, 3)
a
# 輸出：
    tensor([[0.5030, 0.5566, 0.5968],
            [0.9044, 0.5012, 0.2717]])
b = torch.rand(2, 3)
b
# 輸出：
    tensor([[0.4264, 0.5325, 0.4145],
            [0.6967, 0.1065, 0.0063]])

# 隨機生成2個維度數據
idx = torch.randperm(2)
idx
# 輸出：
    tensor([1, 0])

# 相當於a、b同時根據隨機生成的維度排序+
a[idx]
# 輸出：
    tensor([[0.9044, 0.5012, 0.2717],
            [0.5030, 0.5566, 0.5968]])
b[idx]
# 輸出：
    tensor([[0.6967, 0.1065, 0.0063],
            [0.4264, 0.5325, 0.4145]])

三、數據維度查看

# 生成數據
a = torch.Tensor(2, 3, 4)
a
# 輸出：
    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.]]])

a.shape  # 注意shape沒有括號
# 輸出：
    torch.Size([2, 3, 4])

a.size()  # 與shape等價
# 輸出：
    torch.Size([2, 3, 4])

a.dim()  # 表示維度
# 輸出：
    3

len(a)  # 查看第一維度數據大小
# 輸出：
    2

tensor數據內存大小查看

a.numel()
# 輸出：
  24  

四、pytorch數據類型

1. 標量：
   可以理解為常量，沒有方向的向量（只有數值，沒有方向），dimension=0
   常用於計算loss。預測值與真實值之間誤差計算出來就是標量

2. 張量：
   張量與標量的區別：張量有方向（維度）
   二維：適合線性batch輸入，比如：torch.randn(2, 3) # 隨機生成2行3列的張量。
   三維：torch.rand(1, 2, 3)；三維適合RNN，[10, 20, 100] 20個句子，10個單詞，每個單詞用一個100維的向量表示
   四維：torch.rand(2, 3, 28, 28) 2張照片，3個通道，照片大小28(h)*28(w)；

3. pytorch數據類型：
   pytorch只支持數字類型數據，不支持字符串類型數據。
   如果要用pytorch來表示string，就將string轉換為數字編碼（或矩陣、向量）來處理。常用方法：One-hot，Embedding（Word2vec, glove）

tensor和numpy類型互換：

直接將tensor轉換為numpy

a = torch.Tensor([2, 3])
a
# 輸出：
    tensor([2., 3.])

a.numpy()
# 輸出：
   array([2., 3.]) 

將numpy數據轉換為張量

import numpy as np

a = np.array([3, 4])
a
# 輸出：
    array([3, 4])

torch.from_numpy(a)  
# 輸出：
    tensor([3, 4], dtype=torch.int32)

1. tensor數據類型查看

a = torch.Tensor(2)
a.type()  # 查看tensor的數值類型
# 輸出：
    'torch.DoubleTensor'

type(a)  # 返回數據類型是tensor，但是不會返回具體的數值類型
# 輸出：
    torch.Tensor

2. 判斷數字類型是否是指定類型

a = torch.Tensor(2)
# 判斷a的數值類型是否是float
isinstance(a, torch.FloatTensor), isinstance(a, torch.DoubleTensor)
# 輸出：
    (False, True)

# GPU與CPU數據比較
b = a.cuda()  # 將b布置在GPU上。（數據默認是布置在CPU上的）
# CPU和GPU數據不能直接比較
isinstance(b, torch.FloatTensor), isinstance(b, torch.DoubleTensor)
# 輸出：
    (False, False)

# 若要進行比較，需要將數據轉換為GPU
isinstance(b, torch.cuda.FloatTensor), isinstance(b, torch.cuda.DoubleTensor)
# 輸出：
    (False, True)

設置默認數據類型

1. 設置默認數據類型前

# Tensor默認是Float類型
a = torch.Tensor(2)
a.type()  # 查看數據類型
# 輸出：
    'torch.FloatTensor'

a = torch.Tensor([2.])
a.type()
# 輸出：
   'torch.FloatTensor' 

# tensor傳入整數默認是LongTensor類型
a = torch.tensor(2)
a.type()
# 輸出：
    'torch.LongTensor'

# 傳入小數，是Float類型
a = torch.tensor(2.)
a.type()
# 輸出：
   'torch.FloatTensor' 

2. 設置默認數據類型后

# 設置默認tensor數據類型
torch.set_default_tensor_type(torch.DoubleTensor)

# 即使設置了默認數據類型是double，但是給定的數據中至少要有一個是小數，不然設置會無效
a = torch.tensor([2, 3])
a.type()
# 輸出：
    'torch.LongTensor'    

# 加了小數后，數據類型就是設置的默認double類型
b = torch.tensor([2., 3])
b.type()
# 輸出：
    'torch.DoubleTensor'