PyTorch框架學習二——基本數據結構（張量）

• 一、什么是張量？
• 二、Tensor與Variable（PyTorch中）
• • 1.Variable
  • 2.Tensor
• 三、Tensor的創建
• • 1.直接創建Tensor
  • • （1）torch.tensor()
    • （2）torch.from_numpy()
  • 2.依據數值創建
  • • （1）torch.zeros()
    • （2）torch.zeros_like()
    • （3）torch.ones()
    • （4）torch.ones_like()
    • （5）torch.full()
    • （6）torch.full_like()
    • （7）torch.arange()
    • （8）torch.linspace()
    • （9）torch.logspace()
    • （10）torch.eye()
  • 3.依據概率分布創建張量
  • • （1）torch.normal()
    • （2）torch.randn()
    • （3）torch.randn_like()
    • （4）torch.rand()
    • （5）torch.rand_like()
    • （6）torch.randint()
    • （7）torch.randint_like()
    • （8）torch.randperm()
    • （9）torch.bernoulli()

一、什么是張量？

先來看一些數學上常見的名詞：

標量：0維張量
向量：1維張量
矩陣：2維張量

所以，張量（Tensor）是一個多維數組，是上述提及的標量、向量和矩陣的高維拓展。

二、Tensor與Variable（PyTorch中）

Variable是PyTorch 0.4.0之前的一種數據類型，PyTorch 0.4.0開始，Variable已經并入了Tensor，所以已經不再需要用到Variable，但是為了學習的一個循序漸進的過程，我們還是先來看一下Variable這個數據類型。

1.Variable

是torch.autograd中的數據類型，主要用于封裝Tensor，使得Tensor可以自動求導。

Variable這種數據類型包括了五種屬性，分別如下所示：

data：被包裝的Tensor

grad：data的梯度

grad_fn：創建Tensor的Function，這是自動求導的關鍵

requires_grad：指示是否需要計算梯度

is_leaf：指示是否是葉子結點（張量）

Variable可以看成是給Tensor加上了四個與梯度相關的屬性。

2.Tensor

PyTorch 0.4.0 版本開始，Variable并入Tensor。Tensor在Variable的基礎上又添加了三個與數據相關的屬性，一共有八個屬性，分別如下所示：

data：被包裝的Tensor

dtype：張量的數據類型，如torch.FloatTensor、torch.cuda.FloatTensor等

shape：張量的形狀/維度，如(64,3,224,224)

device：張量所在設備，GPU/CPU，是加速計算的關鍵

grad：data的梯度

grad_fn：創建Tensor的Function，這是自動求導的關鍵

requires_grad：指示是否需要計算梯度

is_leaf：指示是否是葉子結點（張量）

前四個屬性與數據相關，后四個屬性與梯度求導相關。

三、Tensor的創建

一般Tensor的創建有三種方式：直接創建、依數值創建和依概率分布創建，下面分別進行介紹：

1.直接創建Tensor

這種創建方式一般是將列表（list）、數組（ndarray）封裝數據的形式直接轉變為Tensor，常用的有torch.tensor()、torch.from_numpy()。

（1）torch.tensor()

功能：從data創建tensor

先給出官方的函數形式以及參數：

torch.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False)

下面看一下所有的參數：

data：要轉變為張量的數據，可以是列表、元組、numpy的ndarry、散點和其他數據類型。

dtype:（可選）張量的數據類型，默認為None，返回data自己的數據類型。

device:（可選）張量的計算設備，默認為None，使用現有的設備，可以是cuda/cpu。

requires_grad:（布爾類型，可選）如果autogard需要記錄張量的運算，即是否需要計算data的梯度，默認為False。

pin_memory:（布爾類型，可選）如果設置，張量將被分配到鎖頁內存中，只為CPU的張量工作，默認為False。

arr = np.ones((3, 3)) print("ndarray數組：", arr) print("ndarray的數據類型：", arr.dtype)# t = torch.tensor(arr, device='cpu') t = torch.tensor(arr) print(t)tens = torch.tensor([1, 2], dtype=torch.int64) print(tens.data, tens.dtype)

（2）torch.from_numpy()

功能：從numpy.ndarray創建tensor，相比tensor()，數據類型只能是numpy.ndarray。

torch.from_numpy(ndarray)

它只有一個參數，就是輸入的ndarry，但是它需要注意的是：torch.from_numpy()創建的tensor與原ndarry是共享內存的，當修改其中一個數據時，另一個也將會被改動。

arr = np.array([[1, 2, 3], [4, 5, 6]]) t = torch.from_numpy(arr) print("numpy array: ", arr) print("tensor : ", t)

print("\n修改arr") arr[0, 0] = 0 print("numpy array: ", arr) print("tensor : ", t)

print("\n修改tensor") t[0, 0] = -1 print("numpy array: ", arr) print("tensor : ", t)

2.依據數值創建

（1）torch.zeros()

功能：依據size創建全0張量

torch.zeros(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

看一下所有的參數：

size：定義輸出張量的形狀/維度，可以是元組或者列表，如(3,3)，(3,3,3)。

out:（張量，可選）輸出張量。

dtype:（可選）張量的數據類型，默認為None，使用全局默認類型。

layout:（可選）內存中的布局形式，有strided，sparse_coo等，默認為torch.strided。

device：同上。

requires_grad：同上。

>>> torch.zeros(2, 3) tensor([[ 0., 0., 0.],[ 0., 0., 0.]])>>> torch.zeros(5) tensor([ 0., 0., 0., 0., 0.])

（2）torch.zeros_like()

功能：依據input形狀創建全0張量

torch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

看一下所有的參數：

input:（張量）input的尺寸/維度決定輸出張量的維度。

dtype:（可選）默認為None，與input的類型一致。

layout:（可選）默認為None，與input的layout一致。

device:（可選）默認為None，與input的device一致。

requires_grad:（布爾，可選）同上。

memory_format:（可選）張量的存儲格式。

>>> input = torch.empty(2, 3) >>> torch.zeros_like(input) tensor([[ 0., 0., 0.],[ 0., 0., 0.]])

（3）torch.ones()

功能：依據size創建全1張量

參數與torch.zeros()類似

（4）torch.ones_like()

功能：依據input形狀創建全1張量

參數與torch.ones()類似

（5）torch.full()

功能：創建一個尺寸為size的張量，里面每個元素的值全為fill_value

torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

參數如下：

size：維度

fill_value：張量內要填充的值

其他參數都同上

>>> torch.full((2, 3), 3.141592) tensor([[ 3.1416, 3.1416, 3.1416],[ 3.1416, 3.1416, 3.1416]])

（6）torch.full_like()

功能：依據input的尺寸創建一個張量，值全為full_value。

torch.full_like(input, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)

（7）torch.arange()

功能：創建等差的一維張量。注意數值區間為 [ start, end )

torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

start：數列起始值，默認為0。

end：數列“結束值”。

step：數列公差，默認為1。

其他參數同上。

>>> torch.arange(5) tensor([ 0, 1, 2, 3, 4]) >>> torch.arange(1, 4) tensor([ 1, 2, 3])

（8）torch.linspace()

功能：創建均分的一維張量。注意數值區間為 [ start, end ]。

torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

start：數列起始值。

end：數列結束值。

steps：在start和end之間要采樣的個數，默認為100。

其他參數同上。

>>> torch.linspace(3, 10, steps=5) tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000]) >>> torch.linspace(-10, 10, steps=5) tensor([-10., -5., 0., 5., 10.])

（9）torch.logspace()

功能：創建對數均分的一維張量，長度為steps，對數的底為base。

torch.logspace(start, end, steps=100, base=10.0, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

start：數列的起始值。

end：數列的結束值。

steps：數列的長度，默認為100。

base：對數的底，默認為10。

其他參數同上。

>>> torch.logspace(start=-10, end=10, steps=5) tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10]) >>> torch.logspace(start=0.1, end=1.0, steps=5) tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])

（10）torch.eye()

功能：創建單位對角矩陣（2維張量），默認為方陣。

torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

n：矩陣行數。

m:（可選）矩陣列數，默認等于n。

其他參數同上。

>>> torch.eye(3) tensor([[ 1., 0., 0.],[ 0., 1., 0.],[ 0., 0., 1.]])

3.依據概率分布創建張量

（1）torch.normal()

功能：返回隨機數的張量，這些隨機數是從給定平均值和標準差的獨立正態分布中提取的。

torch.normal(mean, std, *, generator=None, out=None)

有四種模式：
1.mean是標量，std是標量：這是只有一個高斯分布，這時需要指定張量的尺寸，即在這個高斯分布里采樣多少次。

# mean：標量 std: 標量 t_normal = torch.normal(0., 1., size=(4,)) print(t_normal)

2和3. mean和std中有一個是張量，一個是標量：

# mean：張量 std: 標量 mean = torch.arange(1, 5, dtype=torch.float) std = 1 t_normal = torch.normal(mean, std) print("mean:{}\nstd:{}".format(mean, std)) print(t_normal)

這里就是從四個高斯分布中分別采樣了一次得到的張量。

4. mean和std都為張量：

# mean：張量 std: 張量 mean = torch.arange(1, 5, dtype=torch.float) std = torch.arange(1, 5, dtype=torch.float) t_normal = torch.normal(mean, std) print("mean:{}\nstd:{}".format(mean, std)) print(t_normal)

（2）torch.randn()

功能：生成標準正態分布，normal的特殊情況。

torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

>>> torch.randn(4) tensor([-2.1436, 0.9966, 2.3426, -0.6366]) >>> torch.randn(2, 3) tensor([[ 1.5954, 2.8929, -1.0923],[ 1.1719, -0.4709, -0.1996]])

（3）torch.randn_like()

torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

（4）torch.rand()

功能：生成[0, 1)之間均勻分布的隨機采樣張量。

torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

>>> torch.rand(4) tensor([ 0.5204, 0.2503, 0.3525, 0.5673]) >>> torch.rand(2, 3) tensor([[ 0.8237, 0.5781, 0.6879],[ 0.3816, 0.7249, 0.0998]])

（5）torch.rand_like()

torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

（6）torch.randint()

功能：生成[low, high)之間均勻分布的隨機采樣張量。

torch.randint(low=0, high, size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

low：（可選）均勻分布范圍的下限，默認為0。

high：均勻分布范圍的“上限”。

其他參數同上。

>>> torch.randint(3, 5, (3,)) tensor([4, 3, 4])>>> torch.randint(10, (2, 2)) tensor([[0, 2],[5, 5]])>>> torch.randint(3, 10, (2, 2)) tensor([[4, 5],[6, 7]])

（7）torch.randint_like()

torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)

（8）torch.randperm()

功能：生成從0到n-1的隨機排列。

torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False)

n：上界，也是tensor的長度。

其他參數同上。

>>> torch.randperm(4) tensor([2, 1, 0, 3])

（9）torch.bernoulli()

功能：以input為概率，生成伯努利分布（0-1分布，兩點分布）。

torch.bernoulli(input, *, generator=None, out=None)

input：（張量）伯努利分布的概率值，依據這個概率值抽取0/1。

其他參數同上。

>>> a = torch.empty(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1] >>> a tensor([[ 0.1737, 0.0950, 0.3609],[ 0.7148, 0.0289, 0.2676],[ 0.9456, 0.8937, 0.7202]]) >>> torch.bernoulli(a) tensor([[ 1., 0., 0.],[ 0., 0., 0.],[ 1., 1., 1.]])>>> a = torch.ones(3, 3) # probability of drawing "1" is 1 >>> torch.bernoulli(a) tensor([[ 1., 1., 1.],[ 1., 1., 1.],[ 1., 1., 1.]]) >>> a = torch.zeros(3, 3) # probability of drawing "1" is 0 >>> torch.bernoulli(a) tensor([[ 0., 0., 0.],[ 0., 0., 0.],[ 0., 0., 0.]])

總結

以上是生活随笔為你收集整理的PyTorch框架学习二——基本数据结构（张量）的全部內容，希望文章能夠幫你解決所遇到的問題。

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