Pytorch——張量 Tensors

希望每天漲粉發表於2021-10-20
PyTorch

張量 Tensors

1、torch.is_tensor

torch.is_tensor(obj)

用法：判斷是否為張量，如果是 pytorch 張量，則返回 True。

引數：obj (Object) – 判斷物件

例子：

torch.is_tensor(torch.rand(2,3))
True

 

2、 torch.is_storage

torch.is_storage(obj)

用法：判斷是否為pytorch Storage，如何是，則返回True

引數：input (Object) – 判斷物件

例子：

torch.is_storage(torch.rand(2,3))
False

 

3、torch.numel

torch.numel(input)->int

用法：返回input 張量中的元素個數

引數：input (Tensor) – 輸入張量

例子：

torch.numel(torch.rand(2,3))
6

 

4、torch.eye

torch.eye(n, m=None, out=None)

用法：返回一個2維張量，對角線數字為1，其它位置為0

引數：

  • n (int) – 行數
  • m (int, 可選) – 列數.如果為None,則預設為n
  • out (Tensor,可選) - 輸出張量

例子：

torch.eye(3, m=2)
tensor([[1., 0.],
        [0., 1.],
        [0., 0.]])
torch.eye(3)
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])

 

5、torch.from_numpy

torch.from_numpy(ndarray) → Tensor

用法：將 numpy.ndarray 轉換為 Tensor。 返回的張量 tensor 和 numpy 的 ndarray 共享同一記憶體空間。修改一個會導致另外一個也被修改。返回的張量不能調整大小。

引數：ndarray

例子：

x = np.random.rand(2,3)
x
array([[0.84130586, 0.64710973, 0.82838384],
       [0.50825928, 0.3054745 , 0.22876226]])
y = torch.from_numpy(x)
y
tensor([[0.8413, 0.6471, 0.8284],
        [0.5083, 0.3055, 0.2288]], dtype=torch.float64)

 

6、torch.linspace

torch.linspace(start, end, steps=100, out=None) → Tensor

用法：返回start和end之間長度為steps的一維張量 引數:

引數：

  • start (float) – 點集的起始值
  • end (float) – 點集的最終值
  • steps (int) – 在start 和 end間的取樣數,即返回多少個數
  • out (Tensor, 可選的) – 結果張量

例子：

x = torch.linspace(1,10,steps=5)
x
tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

 

7、torch.logspace

torch.logspace(start, end, steps=100, out=None) → Tensor

用法：返回一個 1 維張量，包含在區間10^start和10^end上以對數刻度均勻間隔的steps個點。 輸出1維張量的長度為steps。

引數：

  • start (float) – 該點集的起始點
  • end (float) – 該點集的最終值
  • steps (int) – 在start 和 end間生成的樣本數
  • out (Tensor, 可選) – 結果張量

例子：

x = torch.logspace(1,10,steps=5)
x
tensor([1.0000e+01, 1.7783e+03, 3.1623e+05, 5.6234e+07, 1.0000e+10])

 

8、torch.ones

torch.ones(*sizes, out=None) → Tensor

用法：返回一個全為1的張量，形狀由可變引數sizes定義。

引數：

  • sizes (int...) – 整數序列，定義了輸出形狀,如：(5,5)，(2)
  • out (Tensor, 可選) – 結果張量

例子：

x = torch.ones(5,5)
x
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
x = torch.ones(5)
x
tensor([1., 1., 1., 1., 1.])

 

9、torch.randn

torch.randn(*sizes, out=None) → Tensor

用法：返回一個張量，包含了從正態分佈(均值為0，方差為 1，即高斯白噪聲)中抽取一組隨機數。 Tensor的形狀由變數sizes定義。

引數：

  • sizes (int...) – 整數序列，定義了輸出形狀

  • `out (Tensor, 可選) - 結果張量

例子：

x = torch.randn(2)
x
tensor([ 0.1526, -0.0788])
x = torch.randn(2,2)
x
tensor([[-0.4000,  0.6303],
        [ 0.5029,  0.3646]])

 

10、torch.randperm

torch.randperm(n, out=None) → LongTensor

用法：輸入引數n，返回一個從0 到n -1的隨機整數排列。

引數：

  • n(int) – 上限(獨佔),即最大值

例子：

x = torch.randperm(10)
x
tensor([9, 2, 5, 3, 1, 0, 8, 4, 7, 6])

 

11、torch.arange

torch.arange(start, end, step=1, out=None) → Tensor

 用法：返回一個1維張量，長度為floor((end−start)/step),floor代表向下取整。包含從start到end，以step為步長的一組序列值(預設步長為1)。

引數：

  • start (float) – 該點集的起始點
  • end (float) – 該點集的終止點
  • step (float) – 相鄰點的間隔大小
  • out (Tensor, 可選的) – 結果張量

 

例子：

x = torch.arange(1,10,step=2)
x
tensor([1, 3, 5, 7, 9])
x = torch.arange(1, 2.5, 0.5)
x
tensor([1.0000, 1.5000, 2.0000])

 

12、torch.range

torch.range(start, end, step=1, out=None) → Tensor

用法：返回一個1維張量，長度為floor((end−start)/step)+1，其中floor代表向下取整數。從start開始，end為結尾，以step為步長的一組值。 step 是兩個值之間的間隔，即 $X_i+1=X_i+step$

引數：

  • start (float) – 該點集的起始點
  • end (float) – 該點集的最終值
  • step (int) – 相鄰點之間的間隔大小
  • out (Tensor, 可選的) – 結果張量

例子：

x = torch.range(1,10,step=2)
x
tensor([1., 3., 5., 7., 9.])
x = torch.range(1, 2.5, 0.5)
x
tensor([1.0000, 1.5000, 2.0000, 2.5000])

 

13、torch.zeros

torch.zeros(*sizes, out=None) → Tensor

用法：返回一個全0的張量，形狀由可變引數sizes定義。

引數：

  • sizes (int...) – 整數序列，定義了輸出形狀
  • out (Tensor, 可選) – 結果張量

例子：

x = torch.zeros(3)
x
tensor([0., 0., 0.])
x = torch.zeros(3,2)
x
tensor([[0., 0.],
        [0., 0.],
        [0., 0.]])

索引,切片,連線,變異操作

1、torch.cat

torch.cat(seq, dim=0, out=None) → Tensor

用法：在給定維度上對輸入的張量序列seq 進行連線操作。

引數：

  • seq（Tensors的序列） - 可以是相同型別的Tensor的任何python序列。
  • dim（int，可選） - 張量連線的尺寸
  • out（Tensor，可選） - 輸出引數

例子：

x = torch.arange(0,4).view(-1,2)
print(x[0])
print(x[1])
tensor([0, 1])
tensor([2, 3])
torch.cat((x,x,x),dim=0)
tensor([[0, 1],
        [2, 3],
        [0, 1],
        [2, 3],
        [0, 1],
        [2, 3]])
torch.cat((x,x,x),dim=1)
tensor([[0, 1, 0, 1, 0, 1],
        [2, 3, 2, 3, 2, 3]])

C=torch.cat((A,B),0)就表示按維數0（行）拼接A和B，也就是豎著拼接，A上B下。

C=torch.cat((A,B),1)就表示按維數1（列）拼接A和B，也就是橫著拼接，A左B右。

 

2、torch.nonzero

torch.nonzero(input, out=None) → LongTensor

用法：返回一個包含輸入input中非零元素索引的張量。輸出張量中的每行包含輸入中非零元素的索引。

　　　如果輸入input有n維，則輸出的索引張量output的形狀為 z x n, 這裡 z 是輸入張量input中所有非零元素的個數。

引數：

  • input (Tensor) – 源張量
  • out (LongTensor, 可選的) – 包含索引值的結果張量

例子：

torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
tensor([[0],
        [1],
        [2],
        [4]])
torch.nonzero(torch.Tensor([[0.6, 0.0, 1.0, 0.0],
                             [0.0, 0.4, 0.0, 0.0],
                             [0.0, 0.0, 1.2, 0.0],
                             [0.0, 0.0, 0.0,-0.4]]))
tensor([[0, 0],
        [0, 2],
        [1, 1],
        [2, 2],
        [3, 3]])

3、torch.split

torch.split(tensor, split_size, dim=0)

用法：將輸入張量分割成相等形狀的chunks（如果可分）。 如果沿指定維的張量形狀大小不能被split_size 整分， 則最後一個分塊會小於其它分塊。

引數：

  • tensor (Tensor) – 待分割張量
  • split_size (int) – 單個分塊的形狀大小
  • dim (int) – 沿著此維進行分割

例子：

x = torch.Tensor([[0.6, 0.0, 1.0, 0.0],
                 [0.0, 0.4, 0.0, 0.0],
                 [0.0, 0.0, 1.2, 0.0],
                 [0.0, 0.0, 0.0,-0.4]])
torch.split(x, 2, dim=0)
(tensor([[0.6000, 0.0000, 1.0000, 0.0000],
         [0.0000, 0.4000, 0.0000, 0.0000]]),
 tensor([[ 0.0000,  0.0000,  1.2000,  0.0000],
         [ 0.0000,  0.0000,  0.0000, -0.4000]]))
torch.split(x, 2, dim=1)
(tensor([[0.6000, 0.0000],
         [0.0000, 0.4000],
         [0.0000, 0.0000],
         [0.0000, 0.0000]]),
 tensor([[ 1.0000,  0.0000],
         [ 0.0000,  0.0000],
         [ 1.2000,  0.0000],
         [ 0.0000, -0.4000]]))

 

4、torch.squeeze

torch.squeeze(input, dim=None, out=None)

用法：將輸入張量形狀中的1 去除並返回。 如果輸入是形如($A \times 1\times B \times 1 \times C \times 1 \times D$) ，那麼輸出形狀就為：($A \times B \times C \times D$) 

　　   當給定dim時，那麼擠壓操作只在給定維度上。例如，輸入形狀為: $(A \times 1 \times B) $, squeeze(input, 0) 將會保持張量不變，只有用 squeeze(input, 1)，形狀會變成 $(A \times B )$。

引數：

  • input (Tensor) – 輸入張量
  • dim (int, 可選的) – 如果給定，則input只會在給定維度擠壓
  • out (Tensor, 可選的) – 輸出張量

例子：

x = torch.zeros(2,1,2,1,2)
x.size()
torch.Size([2, 1, 2, 1, 2])
y = torch.squeeze(x)
y.size()
torch.Size([2, 2, 2])
torch.Size([2, 1, 2, 1, 2])
torch.Size([2, 1, 2, 1, 2])
y = torch.squeeze(x, 1)
y.size()
torch.Size([2, 2, 1, 2])

 

5、torch.stack

torch.stack(sequence, dim=0)

用法：沿著一個新維度對輸入張量序列進行連線。 序列中所有的張量都應該為相同形狀。

引數：

  • sqequence (Sequence) – 待連線的張量序列
  • dim (int) – 插入的維度。必須介於 0 與 待連線的張量序列數之間。

 

6、torch.t

torch.t(input, out=None) → Tensor

用法：輸入一個矩陣（2維張量），並轉置0, 1維。 可以被視為函式transpose(input, 0, 1)的簡寫函式。

引數：

  • input (Tensor) – 輸入張量

  • out (Tensor, 可選的) – 結果張量

例子：

x = torch.randn(2, 3)
torch.t(x)
tensor([[ 0.2929,  0.1270],
        [-0.0673, -0.3026],
        [-0.4359,  0.4589]])

 

7、torch.transpose

torch.transpose(input, dim0, dim1, out=None) → Tensor

用法：返回輸入矩陣input的轉置。交換維度dim0和dim1。 輸出張量與輸入張量共享記憶體，所以改變其中一個會導致另外一個也被修改。

引數：

  • input (Tensor) – 輸入張量
  • dim0 (int) – 轉置的第一維
  • dim1 (int) – 轉置的第二維

例子：

x = torch.randn(2, 3)
x
tensor([[-0.0635, -0.4873,  0.1029],
        [ 0.3269,  1.8284,  0.1268]])
torch.transpose(x, 0, 1)
tensor([[-0.0635,  0.3269],
        [-0.4873,  1.8284],
        [ 0.1029,  0.1268]])

 

8、torch.unbind

torch.unbind(tensor, dim=0)[source]

用法：移除指定維後，返回一個元組，包含了沿著指定維切片後的各個切片

引數：

  • tensor (Tensor) – 輸入張量
  • dim (int) – 刪除的維度

 

9、torch.unsqueeze

torch.unsqueeze(input, dim, out=None)

用法：返回一個新的張量，對輸入的制定位置插入維度 1

引數：

  • tensor (Tensor) – 輸入張量
  • dim (int) – 插入維度的索引
  • out (Tensor, 可選的) – 結果張量

例子：

x = torch.Tensor([1, 2, 3, 4])
torch.unsqueeze(x, 0)
tensor([[1., 2., 3., 4.]])
torch.unsqueeze(x, 1)
tensor([[1.],
        [2.],
        [3.],
        [4.]])

 

隨機抽樣 Random sampling

1、torch.manual_seed

torch.manual_seed(seed)

用法：設定生成隨機數的種子，並返回一個 _torch.C.Generator 物件.

引數：seed (int or long) – 種子.

例子：

torch.manual_seed(1)
<torch._C.Generator at 0x19749eb5890>

 

2、torch.initial_seed

torch.initial_seed()

用法：返回生成隨機數的原始種子值（python long）。

例子：

torch.manual_seed(12)
torch.initial_seed()
12

 

3、torch.bernoulli

torch.bernoulli(input, out=None) → Tensor

用法：

 

　　從伯努利分佈中抽取二元隨機數(0 或者 1)。

　　輸入張量須包含用於抽取上述二元隨機值的概率。 因此，輸入中的所有值都必須在［0,1］區間，即 $( 0<=input_i<=1 )$

　　輸出張量的第 $i$ 個元素值， 將會以輸入張量的第 $i$ 個概率值等於1。

　　返回值將會是與輸入相同大小的張量，每個值為 0 或者 1 引數:

引數：

  • input (Tensor) – 輸入為伯努利分佈的概率值
  • out (Tensor, 可選的) – 輸出張量(可選)

例子：

a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
a
tensor([[0.4657, 0.2328, 0.4527],
        [0.5871, 0.4086, 0.1272],
        [0.6373, 0.2421, 0.7312]])
torch.bernoulli(a)
tensor([[0., 1., 0.],
        [1., 0., 0.],
        [1., 0., 0.]])
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.]])

 

4、torch.multinomial

torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

用法：

 

　　返回一個張量，每行包含從input相應行中定義的多項分佈中抽取的num_samples個樣本。

 

　　當抽取樣本時，依次從左到右排列(第一個樣本對應第一列)。

 

　　如果輸入input是一個向量，輸出out也是一個相同長度 num_samples 的向量。如果輸入 input 是有 m 行的矩陣，輸出 out 是形如 $m \times n$ 的矩陣。

 

　　如果引數 replacement 為 True, 則樣本抽取可以重複。否則，一個樣本在每行不能被重複抽取。

 

　　引數 num_samples 必須小於 input 長度(即，input 的列數，如果是 input 是一個矩陣)。

 

引數：

 

  • input (Tensor) – 包含概率值的張量
  • num_samples (int) – 抽取的樣本數
  • replacement (bool, 可選的) – 布林值，決定是否能重複抽取
  • out (Tensor, 可選的) – 結果張量

 

例子：

weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
torch.multinomial(weights, 4)
tensor([1, 2, 0, 3])
torch.multinomial(weights, 4, replacement=True)
tensor([2, 1, 1, 1])

 

5、torch.normal()

torch.normal(means, std, out=None)

用法：返回一個張量，包含從給定引數means,std的離散正態分佈中抽取隨機數。 均值means是一個張量，包含每個輸出元素相關的正態分佈的均值。 std是一個張量，包含每個輸出元素相關的正態分佈的標準差。 均值和標準差的形狀不須匹配，但每個張量的元素個數須相同。

引數：

  • means (Tensor) – 均值
  • std (Tensor) – 標準差
  • out (Tensor) – 可選的輸出張量

例子：

torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))

 1.5104

 1.6955

 2.4895

 4.9185

 4.9895

 6.9155

 7.3683

 8.1836

 8.7164

 9.8916

 

相關文章