PyTorch入門筆記-創建張量
- 2020 年 12 月 5 日
- AI
1. 從數組、列表對象創建
Numpy Array 數組和 Python List 列表是 Python 程序中間非常重要的數據載體容器，很多數據都是通過 Python 語言將數據加載至 Array 數組或者 List 列表容器，再轉換到 Tensor 類型。（為了方便描述，後面將 Numpy Array 數組稱為數組，將 Python List 列表稱為列表。）
PyTorch 從數組或者列表對象中創建 Tensor 有四種方式：
-
torch.Tensor -
torch.tensor -
torch.as_tensor -
torch.from_numpy
>>> import torch
>>> import numpy as np
>>> array = np.array([1, 2, 3])
>>> list = [4, 5, 6]
# 方式一：使用torch.Tensor類
>>> tensor_array_a = torch.Tensor(array)
>>> tensor_list_a = torch.Tensor(list)
>>> print(isinstance(tensor_array_a, torch.Tensor)
, tensor_array_a.type())
True torch.FloatTensor
>>> print(isinstance(tensor_list_a, torch.Tensor)
, tensor_list_a.type())
True torch.FloatTensor
# 方式二：使用torch.tensor函數
>>> tensor_array_b = torch.tensor(array)
>>> tensor_list_b = torch.tensor(list)
>>> print(isinstance(tensor_array_b, torch.Tensor)
, tensor_array_b.type())
True torch.LongTensor
>>> print(isinstance(tensor_list_b, torch.Tensor)
, tensor_list_b.type())
True torch.LongTensor
# 方式三：使用torch.as_tensor函數
>>> tensor_array_c = torch.as_tensor(array)
>>> tensor_list_c = torch.as_tensor(list)
>>> print(isinstance(tensor_array_c, torch.Tensor)
, tensor_array_c.type())
True torch.LongTensor
>>> print(isinstance(tensor_list_c, torch.Tensor)
, tensor_list_c.type())
True torch.LongTensor
# 方式四：使用torch.from_numpy函數
>>> tensor_array_d = torch.from_numpy(array)
# tensor_list_d = torch.from_numpy(list) error code
>>> print(isinstance(tensor_array_d, torch.Tensor)
, tensor_array_d.type())
True torch.LongTensor
# print(isinstance(tensor_list_d, torch.Tensor)
# , tensor_list_d.type())
通過上面代碼的執行結果可以簡單歸納出四種創建 Tensor 方式的差異：
-
只有 torch.Tensor 是類，其餘的三種方式都是函數； -
torch.Tensor、torch.tensor 和 torch.as_tensor 三種方式可以將數組和列錶轉換為 Tensor，但是 torch.from_numpy 只能將數組轉換為 Tensor（為 torch.from_numpy 函數傳入列表，程序會報錯）； -
從程序的輸出結果可以看出，四種方式最終都將數組或列錶轉換為 Tensor（使用 isinstance 返回的結果都為 True），**但是轉換後的 Tensor 數據類型卻有所不同，在上一小節區分 torch.Tensor 和 torch.tensor 的時候提到過，當接收數據內容時，torch.Tensor 創建的 Tensor 會使用默認的全局數據類型，而 torch.tensor 創建的 Tensor 會使用根據傳入數據推斷出的數據類型。**可以通過 torch.get_default_dtype()來獲取當前的全局數據類型，也可以通過torch.set_default_dtype(torch.XXXTensor)來設置當前環境默認的全局數據類型；
>>> import torch
>>> import numpy as np
>>> array = np.array([1, 2, 3])
>>> print(array)
int64
# 獲取當前全局環境的數據類型
>>> print(torch.get_default_dtype())
torch.float32
# 方式一：使用torch.Tensor類
>>> tensor_array_a = torch.Tensor(array)
>>> print(tensor_array_a.type())
torch.FloatTensor
# 方式二：使用torch.tensor函數
>>> tensor_array_b = torch.tensor(array)
>>> print(tensor_array_b.type())
torch.LongTensor
# 設置當前全局環境的數據類型為torch.DoubleTensor
>>> torch.set_default_tensor_type(torch.DoubleTensor)
>>> tensor_array_a = torch.Tensor(array)
>>> print(tensor_array_a.type())
torch.DoubleTensor
>>> tensor_array_b = torch.tensor(array)
>>> print(tensor_array_b.type())
torch.LongTensor
**PyTorch 默認的全局數據類型為 torch.float32，因此使用 torch.Tensor 類創建 Tensor 的數據類型和默認的全局數據類型一致，為 torch.FloatTensor，而使用 torch.tensor 函數創建的 Tensor 會根據傳入的數組和列表中元素的數據類型進行推斷，此時 np.array([1, 2, 3]) 數組的數據類型為 int64，因此使用 torch.tensor 函數創建的 Tensor 的數據類型為 torch.LongTensor。**使用 torch.set_default_tensor_type(torch.DoubleTensor) 更改了默認的全局數據類型之後，使用 torch.Tensor 生成的 Tensor 數據類型會變成更改後的數據類型，而使用 torch.tensor 函數生成的 Tensor 數據類型依然沒有改變，「當然可以在使用 torch.tensor 函數創建 Tensor 的時候指定 dtype 參數來生成指定類型的 Tensor。」
PyTorch 提供了這麼多方式從數組和列表中創建 Tensor。一般來說，不推薦使用 torch.Tensor 類，因為不僅可以為 torch.Tensor 傳入數據還可以傳入形狀（torch.tensor 只能傳入數據，這樣單一的功能可以防止出錯），當為 torch.Tensor 傳入形狀時會生成指定形狀且包含未初始化數據的 Tensor，如果忘記替換掉這些未初始化的值，直接輸入到神經網絡中，可能會讓神經網絡輸出 NAN 或者 INF。「如果不考慮性能的話，推薦使用 torch.tensor。如果考慮性能，推薦使用 torch.as_tensor（torch.from_numpy 只能接受數組類型），因為使用 torch.as_tensor 生成的 tensor 會和數組共享內存，從而節省內存的開銷。」
2. 創建全 0 或全 1 的張量
創建元素值為全 0 或全 1 的張量是非常常見的初始化手段，通過 torch.zeros() 和 torch.ones() 函數即可創建任意形狀，且元素值全為 0 或全為 1 的張量。
torch.zeros(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)和torch.ones(*size, out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False) 兩個函數的參數相同，這裡簡單介紹一下這些參數：
-
*size: 定義輸出張量形狀的整數序列，這個整數序列可以是列表和數組之類的集合也可以是整數的 torch.Size（執行 tensor.size() 獲取 tensor 形狀的結果為 torch.Size）； -
out = None（可選參數）: 指定輸出的張量。比如執行 torch.zeros([2, 2], out = tensor_a)，相當於執行tensor_a = torch.zeros([2, 2])； -
dtype = None（可選參數）:指定返回張量的數據類型，默認（dtype = None）使用全局默認的數據類型，我們可以使用 torch.get_default_tensor_type() 獲取全局默認的數據類型，同時可以通過 torch.set_default_tensor_type(torch.XXXTensor) 更改全局默認的數據類型為 torch.XXXTensor； -
layout = torch.strided（可選參數）: 定義張量在物理設備中的存儲結構，torch.layout 可選的參數值有 torch.strided（默認）或 torch.sparse_coo，分別對應順序存儲和離散存儲。「通常情況下，如果張量中的元素值 0 比較少為稠密張量，則指定 layout = torch.strided。如果張量中的元素值中 0 比較多為稀疏張量，則指定 layout = torch.sparse_coo」； -
device = None（可選參數）: 指定張量所在的計算設備是 CPU 還是 GPU； -
requires_grad=False（可選參數）: 指定此張量是否需要記錄梯度；
torch.zeros() 和 torch.ones() 兩個函數中只有 *size 參數為必須指定的參數，其餘參數都是可選參數，因此接下來只關注指定 *size 參數的 torch.zeros(*size) 和 torch.ones(*size)。
>>> import torch
>>> # 創建全為0或1的0D張量(標量)
>>> scalar_zero = torch.zeros([])
>>> scalar_one = torch.ones([])
>>> print("張量的維度:{}，張量的值:{}".
format(scalar_zero.dim(), scalar_zero))
張量的維度:0，張量的值:0.0
>>> print("張量的維度:{}，張量的值:{}".
format(scalar_one.dim(), scalar_one))
張量的維度:0，張量的值:1.0
>>> # 創建全為0或1的1D張量(向量)
>>> vec_zero = torch.zeros([3])
>>> vec_one = torch.ones([3])
>>> print("張量的維度:{}，張量的值:{}".
format(vec_zero.dim(), vec_zero))
張量的維度:1，張量的值:tensor([0., 0., 0.])
>>> print("張量的維度:{}，張量的值:{}".
format(vec_one.dim(), vec_one))
張量的維度:1，張量的值:tensor([1., 1., 1.])
>>> # 創建全為0或1的2D張量(矩陣)
>>> mat_zero = torch.zeros([2, 2])
>>> mat_one = torch.ones([2, 2])
>>> print("張量的維度:{}，張量的值:{}".
format(mat_zero.dim(), mat_zero))
張量的維度:2，張量的值:tensor([[0., 0.],
[0., 0.]])
>>> print("張量的維度:{}，張量的值:{}".
format(mat_one.dim(), mat_one))
張量的維度:2，張量的值:tensor([[1., 1.],
[1., 1.]])
通過torch.zeros(*size)和torch.ones(*size)函數創建了元素值全為 0 和全為 1 的 0D 張量、1D 張量和 2D 張量，創建 nD 張量與之類似，這裡不再贅述。*size 參數指定創建張量的形狀，不同維度張量的形狀可以參考下表。
比如：
-
創建 0D 張量只需要指定 size = []； -
創建 1D 張量只需要指定 size = [dim0]，其中 dim0 為第 0 個維度的元素個數； -
創建 2D 張量只需要指定 size = [dim0, dim1]，其中 dim0 為第 0 個維度的元素個數，dim1 為第 1 個維度的元素個數； -
依次類推，創建 nD 張量只需要指定 size = [dim0, dim1, …, dimn]，其中 dim0 為第 0 個維度的元素個數，dim1 為第 1 個維度的元素個數，…，dimn 為第 n 個維度的元素個數；
通過 torch.zeros_like(input) 和 torch.ones_like(input) 函數可以方便地創建與 input 張量形狀一致，且元素值全為 0 或者 1 的張量，需要注意此時的 input 必須是張量。
>>> import torch
>>> scalar_a = torch.tensor(1.)
>>> vec_a = torch.tensor([1., 2., 3.])
>>> mat_a = torch.tensor([[1., 2.], [3., 4.]])
>>> print("張量的形狀:{}".format(scalar_a.size()))
張量的形狀:torch.Size([])
>>> print("張量的形狀:{}".format(vec_a.size()))
張量的形狀:torch.Size([3])
>>> print("張量的形狀:{}".format(mat_a.size()))
張量的形狀:torch.Size([2, 2])
>>> # 創建和張量scalar_a相同形狀的全為0或1的張量
>>> scalar_zero = torch.zeros_like(scalar_a)
>>> scalar_one = torch.ones_like(scalar_a)
>>> print("張量的維度:{}，張量的值:{}".
format(scalar_zero.dim(), scalar_zero))
張量的維度:0，張量的值:0.0
>>> print("張量的維度:{}，張量的值:{}".
format(scalar_one.dim(), scalar_one))
張量的維度:0，張量的值:1.0
>>> # 創建和張量scalar_a相同形狀的全為0或1的張量
>>> vec_zero = torch.zeros_like(vec_a)
>>> vec_one = torch.ones_like(vec_a)
>>> print("張量的維度:{}，張量的值:{}".
format(vec_zero.dim(), vec_zero))
張量的維度:1，張量的值:tensor([0., 0., 0.])
>>> print("張量的維度:{}，張量的值:{}".
format(vec_one.dim(), vec_one))
張量的維度:1，張量的值:tensor([1., 1., 1.])
>>> # 創建和張量scalar_a相同形狀的全為0或1的張量
>>> mat_zero = torch.zeros_like(mat_a)
>>> mat_one = torch.ones_like(mat_a)
>>> print("張量的維度:{}，張量的值:{}".
format(mat_zero.dim(), mat_zero))
張量的維度:2，張量的值:tensor([[0., 0.],
[0., 0.]])
>>> print("張量的維度:{}，張量的值:{}".
format(mat_one.dim(), mat_one))
張量的維度:2，張量的值:tensor([[1., 1.],
[1., 1.]])
3. 創建自定義數值張量
除了將張量的元素值初始化全為 0 或全為 1 的張量依然，有時候也需要全部初始化為某個自定義數值的張量。通過 torch.full(size,fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False) 可以創建全為自定義數值 fill_value 的張量，形狀由 size 參數指定。
torch.full() 函數中除了 size 和 fill_value 參數外，其餘都是可選參數且和 torch.zeros() 和 torch.ones() 兩個函數的參數一致，同樣不再贅述。
-
size: 定義輸出張量形狀的整數序列，這個整數序列可以是列表和數組之類的集合也可以是整數的 torch.Size（執行 tensor.size() 獲取 tensor 形狀的結果為 torch.Size）； -
fill_value: 填充到張量中的元素值，必須為標量值；
>>> import torch
>>> # 創建0D且元素值為5的張量
>>> scalar_a = torch.full([], 5)
>>> # 創建1D且元素值為5的張量
>>> vec_a = torch.full([3], 5)
>>> # 創建2D且元素值為5的張量
>>> mat_a = torch.full([2, 2], 5)
>>> print("張量的維度:{}，張量的值:{}".
format(scalar_a.dim(), scalar_a))
張量的維度:0，張量的值:5.0
>>> print("張量的維度:{}，張量的值:{}".
format(vec_a.dim(), vec_a))
張量的維度:1，張量的值:tensor([5., 5., 5.])
>>> print("張量的維度:{}，張量的值:{}".
format(mat_a.dim(), mat_a))
張量的維度:2，張量的值:tensor([[5., 5.],
[5., 5.]])
「通過 torch.full_like(input,fill_value) 函數來創建全為自定義數值 fill_value 的張量，形狀由參數 input 的形狀指定，input 必須是張量。」
4. 創建已知分佈的張量
正態分佈（Normal Distribution）和均勻分佈（Uniform Distribution）是最常見的分佈之一，創建採樣自這 2 個分佈的張量非常有用，「比如在卷積神經網絡中，卷積核張量 初始化為正態分佈有利於網絡的訓練；在對抗生成網絡中，隱藏變量 一般採樣自均勻分佈。」
通過 torch.normal(mean,std,generator=None,out=None) 可以創建均值為 mean，標準差為 std 的正態分佈 ，先來簡單看一看這些參數：
-
mean(Tensor) – 傳入參數 mean 的張量中的每個元素都是對應輸出元素的正態分佈的均值； -
std(Tensor) – 傳入參數 std 的張量中的每個元素都是對應輸出元素的正態分佈的標準差； -
generator = None(torch.Generator, optional) – 用於採樣的偽隨機數，可以暫時不用關注； -
out = None(Tensor, optional) – 指定輸出的張量。比如執行 torch.normal(mean = torch.tensor(0.), std = torch.tensor(1.), out = tensor_a)，相當於執行tensor_a = torch.normal(mean = torch.tensor(0.), std = torch.tensor(1.))；
torch.normal(mean,std,generator=None,out=None) 函數傳入的 mean 和 std 參數的兩個張量的形狀不一定要匹配，但是這兩個張量中的元素總個數必須相等，「這裡需要注意此時兩個張量中的元素總個數必須相等不僅僅包括顯式的相等，還包含隱式的相等。」
-
顯式相等非常好理解，簡單來說就是傳入張量的元素總個數相等。比如傳入參數 mean 的張量形狀為 [1, 4]，那麼傳入參數 std 的張量形狀必須是 [1, 4]、[2, 2]、[4, 1] 中的任意一個，必須滿足 mean.numel() == std.numel()（tensor.numel() 函數返回 tensor 中的元素個數）； -
隱式相等其實就是 PyTorch 中的廣播機制，PyTorch 中的廣播機制和 TensorFlow 以及 Numpy 中的廣播機制類似。比如傳入參數 mean 的張量形狀為 [1, 2]，而傳入參數 std 的張量形狀為 [2, 2]，PyTorch 會根據廣播機制的規則將傳入 mean 參數的張量形狀廣播成 [2, 2]。「雖然傳入的兩個張量元素總個數不相等，但是通過 PyTorch 中的廣播機制可以將符合廣播機制的張量擴展成相同元素總個數的兩個張量；」
>>> import torch
>>> # 傳入mean和std的兩個張量:
>>> # 1. 形狀不匹配
>>> # 2. 兩個張量中的元素個數顯式相等
>>> normal_a = torch.normal(mean = torch.full([1, 4], 0.),std = torch.full([2, 2], 1.))
>>> print(normal_a.size())
torch.Size([1, 4])
>>> print(normal_a)
tensor([[-1.7489, -1.4797, 1.1246, 0.4521]])
>>> # 傳入mean和std的兩個張量:
>>> # 1. 形狀不匹配
>>> # 2. 兩個張量中的元素個數顯式不相等,但是符合廣播機制的規則
>>> normal_b = torch.normal(mean = torch.full([1, 2], 0.),std = torch.full([2, 2], 1.))
>>> print(normal_b.size())
torch.Size([2, 2])
>>> print(normal_b)
tensor([[-1.1370, -1.1644],
[-1.5242, -0.9315]])
>>> # 傳入mean和std的兩個張量:
>>> # 1. 形狀不匹配
>>> # 2. 兩個張量中的元素個數顯式不相等,且不符合廣播機制的規則
>>> # 程序會報錯error
>>> # normal_c = torch.normal(mean = torch.full([1, 3], 0.),
>>> # std = torch.full([2, 2], 1.))
PyTorch 的官方文檔中強調：”當輸入參數 mean 和 std 的張量形狀不匹配的時候，輸出張量的形狀由傳入 mean 參數的張量形狀所決定。”通過前面的介紹後這句話非常好理解，因為不管傳入 mean 和 std 參數的張量形狀如何，只要代碼正確，最終都會被轉換為相同的形狀。
不過有可能會有 UserWarning 的警告（我的 PyTorch 為 1.5），這個警告因為 torch.normal(mean = torch.full((1, 4), 0.),std = torch.full((2, 2), 1.)) 代碼段，「這是因為當傳入的兩個張量形狀不匹配，但是元素總個數相等的情況下，PyTorch 會使用 reshape 函數將傳入參數 std 的張量形狀改變成和傳入 mean 參數張量相同的形狀，這可能會引發一些問題，所以在 PyTorch 1.6 以後的版本這種方法將會捨棄，這裡只需要注意一下即可。」
通過 torch.randint(low=0,high,size,generator=None,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False) 函數能夠創建採樣自 [low, high) 區間（包左不包右）的均勻分佈的張量，函數中的很多參數都介紹過，這裡不再贅述，這裡只關注 low 和 high 兩個參數。
-
low(int, optional) – 從均勻分佈中採樣的最小整數，默認為 0； -
high(int) – 從均勻分佈中採樣的最大整數，不包括最大整數；
>>> import torch
>>> # 創建採樣自[1, 10)均勻分佈的0D張量
>>> scalar_a = torch.randint(1, 10, ())
>>> print(scalar_a.size())
torch.Size([])
>>> print(scalar_a)
tensor(4)
>>> # 創建採樣自[2, 5)均勻分佈的1D張量
>>> vec_b = torch.randint(2, 5, (3, ))
>>> print(vec_b.size())
torch.Size([3])
>>> print(vec_b)
tensor([2, 2, 2])
>>> # 創建採樣自[0, 10)均勻分佈的2D張量
>>> mat_c = torch.randint(10, (2, 2))
>>> print(mat_c.size())
torch.Size([2, 2])
>>> print(mat_c)
tensor([[3, 8],
[4, 2]])
通過 torch.randint(low, high, size) 函數創建採樣自 [low, high) 均勻分佈的 0D 張量、1D 張量和 2D 張量，創建 nD 張量與之類似，這裡不再贅述。*size 參數指定創建張量的形狀。
torch.normal() 函數相對比較複雜，而 torch.randint() 函數和前面介紹的函數類似，只不過需要指定採樣的區間範圍。針對比較常見的標準正態分佈和採樣自 [0, 1) 區間的均勻分佈，PyTorch 又提供了 torch.randn(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False)和torch.rand(*size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False) 兩個函數。
>>> import torch
>>> # 創建採樣自均值0.標準差1.正態分佈的2D張量
>>> # 等價torch.normal(mean = torch.full([2, 2], 0.)
>>> # std = torch.full([2, 2], 1.))
>>> normal_a = torch.randn([2, 2])
>>> print(normal_a)
tensor([[-0.4471, -0.2377],
[ 0.6442, -0.1024]])
>>> # 創建採樣自[0, 1)均勻分佈的2D張量
>>> # !不等價torch.randint(0, 1, [2, 2])
>>> uniform_b = torch.rand([2, 2])
>>> print(uniform_b)
tensor([[0.9690, 0.6938],
[0.1431, 0.4861]])
還有一點需要注意：「torch.randint() 函數只能採樣指定範圍均勻分佈的整數，而 torch.rand() 函數能夠採樣 [0, 1) 範圍內均勻分佈的浮點數，如果你想要採樣自指定範圍內的浮點數，可以使用 torch.rand() 函數進行改造，不過最簡單的方法就是使用 torch.nn.init.uniform_(tensor, a=0.0, b=1.0) 函數。」
比如創建一個採樣自 [2, 10) 範圍均勻分佈且形狀為 [2, 2] 的 2D 張量。
>>> import torch
>>> uniform_c = torch.FloatTensor(2, 2).uniform_(2, 10)
>>> print(uniform_c)
tensor([[8.9692, 6.4037],
[4.4121, 7.0056]])
5. 創建序列張量
在循環計算或者對張量進行索引時，經常需要創建一段連續的整型或浮點型的序列張量。PyTorch 提供了一些能夠創建序列張量的方法。
創建整型序列：
-
torch.arange(start = 0, end, step = 1, out = None, layout = torch.strided, device = None, requires_grad = False) 可以創建長度為 ( 為向上取整，返回大於或者等於表達式的最小整數) 的 1D 張量，張量的元素值為在 [start, end) 之間，步長為 step 的整型序列，不包含 end 本身； -
torch.range(start = 0, end, step = 1, out = None, layout = torch.strided, device = None, requires_grad = False) 可以創建長度為 ( 為向下取整，返回小於或者等於表達式的最大整數) 的 1D 張量，張量的元素值為在 [start, end] 之間，步長為 step 的整型序列，包含 end 本身；
使用 torch.range() 函數會出現 Warning 警告：未來的 Pytorch 版本會將 torch.range() 函數丟棄。因為 torch.range() 函數和 Python 的內建函數 range 行為不一致，Python 中的 range 函數生成的整數序列範圍為 [start, end) (包左不包右，Python中習慣使用包左不包右的規範)，而 torch.range() 函數生成的整數序列範圍為 [start, end] (包左包右)。
torch.arange() 函數和 torch.range() 函數功能相似。「如果想要創建整型序列，推薦使用 torch.arange() 函數。」
>>> import torch
>>> # 創建元素值為範圍[0, 10)步長為1的1D整數序列張量
>>> a = torch.arange(0, 10)
>>> print(a)
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> # 創建元素值為範圍[1, 10)步長為2的1D整數序列張量
>>> b = torch.arange(1, 10, 2)
>>> print(b)
tensor([1, 3, 5, 7, 9])
>>> # 使用torch.range()函數創建元素值為範圍[0, 10)步長為1的1D整數序列張量
>>> c = torch.range(0, 10)
>>> print(c)
tensor([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
/home/chenkc/code/create_tensor.py:298: UserWarning: torch.range is deprecated in favor of torch.arange and will be removed in 0.5. Note that arange generates values in [start; end), not [start; end].
c = torch.range(0, 10)
對於張量 b 來說，由於 ，因此最終張量 b 為長度為 5 的 1D 張量。
創建浮點型序列：
-
torch.linspace(start, end, steps, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False) 可以創建長度為 steps 的 1D 張量，張量的元素值為在 [start, end] 之間均勻間隔的 steps 個點。序列張量的值為 ； -
torch.logspace(start, end, steps, base = 10.0, out = None, layout = torch.strided, device = None, requires_grad = False) 可以創建長度為 steps 的 1D 張量，張量的元素值為在 之間均勻間隔的 steps 個點。序列張量的值為 ；
>>> import torch
>>> # 創建元素值為範圍[0, 10]之間均勻間隔的5個值的1D浮點型序列張量
>>> a = torch.linspace(0., 10., 5)
>>> print(a)
tensor([ 0.0000, 2.5000, 5.0000, 7.5000, 10.0000])
>>> # 創建元素值為範圍[10^0, 10^10]之間均勻間隔的5個值的1D浮點型序列張量
>>> b = torch.logspace(0., 10., 5)
>>> print(b)
tensor([1.0000e+00, 3.1623e+02, 1.0000e+05, 3.1623e+07, 1.0000e+10])
