Pytorch API

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

   将给定的 input 这个 tensor 中，大小为 1 的 dim 全部压缩。

   如下例子：

   import torch
   t = torch.tensor([[1], [2], [3]])
   print(t) # tensor([[1], [2], [3]]) shape=(3,1)
   
   t = torch.squeeze(t)
   print(t) # tensor([1, 2, 3]) shape=(3,)

2. torch.unsqueeze(input, dim)

   将给定的 input 这个 tensor 中，指定的 dim 扩充一维

   如下例子：

   import torch
   t = torch.tensor([1, 2, 3])
   print(torch.unsqueeze(t, 0)) # tensor([[1, 2, 3]]) shape=(1,3)
   
   print(torch.unsqueeze(t, 1)) # tensor([[1], [2], [3]]) shape=(3,1)

3. torch.index_select(input, dim, index, *, out=None)

   在给定的 input 这个 tensor 中，选择维度 dim ，然后在这个维度中选择索引 index 的部分返回。

   如下例子：

   import torch
   
   t = torch.arange(1, 13).view(3, 4)
   	
   print(t)
   """
   tensor([[ 1,  2,  3,  4],
           [ 5,  6,  7,  8],
           [ 9, 10, 11, 12]])
   shape=(3, 4)
   """
   
   indices = torch.tensor([0, 2])
   
   print(torch.index_select(t, 0, indices))
   """
   tensor([[ 1,  2,  3,  4],
           [ 9, 10, 11, 12]])
   选择 dim=0 ，有 (0, 1, 2) 三个，选择第 0 行和第 2 行
   """
   
   print(torch.index_select(t, 1, indices))
   """
   tensor([[ 1,  3],
           [ 5,  7],
           [ 9, 11]])
   选择 dim=1 ，有 (0, 1, 2, 3) 四个，选择第 0 列和第 4 列
   """

4. torch.norm(input, p='fro', dim=None, keepdim=False, out=None, dtype=None)

   将给定的 input 这个 tensor 按照给定的 dim 计算范数，具体计算的是什么范数由 p 决定

   p=1 表示第一范数，即 tensor 中每个元素绝对值之和

   p=2 表示第二范数，即 tensor 中每个元素平方和的和，再开根号

   其他表示无穷范数，即 tensor 中绝对值最大的元素

   import torch
   """
   	inputs.shape = (3, 3, 4)
   """
   inputs = torch.tensor([[[ 1.,  2.,  3.,  4.],
                          [ 2.,  4.,  6.,  8.],
                          [ 3.,  6.,  9., 12.]],
                          [[ 1.,  2.,  3.,  4.],
                          [ 2.,  4.,  6.,  8.],
                          [ 3.,  6.,  9., 12.]],
                          [[ 1.,  2.,  3.,  4.],
                          [ 2.,  4.,  6.,  8.],
                          [ 3.,  6.,  9., 12.]]])
    
   """
   inputs1.shape = (1, 3, 4)
   对于 dim=0 进行 L2 范数的计算，就是考虑将 (i, j, k) 其中所有的 i 的元素平方和加起来再开根号
   这里 sqrt((0, 0, 0)^2 + (1, 0, 0)^2 + (2, 0, 0)^2) = sqrt(3) = 1.7321
   tensor([[[ 1.7321,  3.4641,  5.1962,  6.9282],
            [ 3.4641,  6.9282, 10.3923, 13.8564],
            [ 5.1962, 10.3923, 15.5885, 20.7846]]])
   """
   inputs1 = torch.norm(inputs, p=2, dim=0, keepdim=True)
   print(inputs1)
   
   """
   inputs2.shape = (3, 1, 4)
   对于 dim=1 进行 L2 范数的计算，就是考虑将 (i, j, k) 其中所有的 j 的元素平方和加起来再开根号
   这里 sqrt((0, 0, 0)^2 + (0, 1, 0)^2 + (0, 2, 0)^2) = sqrt(1+4+9) = 3.7417
   tensor([[[ 3.7417,  7.4833, 11.2250, 14.9666]],
           [[ 3.7417,  7.4833, 11.2250, 14.9666]],
           [[ 3.7417,  7.4833, 11.2250, 14.9666]]])
   """
   inputs2 = torch.norm(inputs, p=2, dim=1, keepdim=True)
   print(inputs2)
   
   """
   inputs3.shape = (3, 3, 1)
   对于 dim=2 进行 L2 范数的计算，就是考虑将 (i, j, k) 其中所有的 k 的元素平方和加起来再开根号
   这里 sqrt((0, 0, 0)^2+(0, 0, 1)^2+(0, 0, 2)^2+(0, 0, 3)^2) = sqrt(1+4+9+16) = 5.4772
   tensor([[[ 5.4772],
            [10.9545],
            [16.4317]],
   
           [[ 5.4772],
            [10.9545],
            [16.4317]],
   
           [[ 5.4772],
            [10.9545],
            [16.4317]]])
   """
   inputs3 = torch.norm(inputs, p=2, dim=2, keepdim=True)
   print(inputs3)

5. torch.chunk(input, chunks, dim=0) → List of Tensors

   将 input 这个 tensor 分成 chunks 个 tensors ，按照 dim 来划分。

   import torch
   
   t = torch.arange(1, 28).view(3, 3, 3)
   
   """
   tensor([[[ 1,  2,  3],
            [ 4,  5,  6],
            [ 7,  8,  9]],
   
           [[10, 11, 12],
            [13, 14, 15],
            [16, 17, 18]],
   
           [[19, 20, 21],
            [22, 23, 24],
            [25, 26, 27]]])
   shape = (3, 3, 3)
   """
   print(t)
   
   """
   按照 dim=0 划分，那么划分结果为
   (tensor([[[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]]]), 
    tensor([[[10, 11, 12],
            [13, 14, 15],
            [16, 17, 18]]]), 
    tensor([[[19, 20, 21],
            [22, 23, 24],
            [25, 26, 27]]]))
   """
   print(torch.chunk(t, chunks=3, dim=0))
   
   """
   按照 dim=1 划分，那么划分结果为
   (tensor([[[ 1,  2,  3]],
            [[10, 11, 12]],
            [[19, 20, 21]]]), 
   
    tensor([[[ 4,  5,  6]],
            [[13, 14, 15]],
            [[22, 23, 24]]]), 
            
    tensor([[[ 7,  8,  9]],
            [[16, 17, 18]],
            [[25, 26, 27]]]))
   """
   print(torch.chunk(t, chunks=3, dim=1))
   
   """
   按照 dim=2 划分，那么划分结果为
   (tensor([[[ 1],
            [ 4],
            [ 7]],
   
           [[10],
            [13],
            [16]],
   
           [[19],
            [22],
            [25]]]), 
   tensor([[[ 2],
            [ 5],
            [ 8]],
   
           [[11],
            [14],
            [17]],
   
           [[20],
            [23],
            [26]]]), 
   tensor([[[ 3],
            [ 6],
            [ 9]],
   
           [[12],
            [15],
            [18]],
   
           [[21],
            [24],
            [27]]]))
   """
   print(torch.chunk(t, chunks=3, dim=2))