pytorch基础学习（1）

1. 关于安装：建议官网(PyTorch)查指令安装：conda 指令后加-c pytorch表示安装pytorch 官网的源，如果要使用清华的源，则不加该参数
2. pytorch的类型：

   cpu:torch.IntTensor
   gpu：torch.cuda.IntTensor

3. 使用size()和shape()可以得到tensor维度
   1. dim=3的张量很适合用于RNN和NLP：如20句话，每句话10个单词，每个单词用100个分量的向量表示，得到的Tensor就是shape=[20,10,100]。

      a = torch.rand(1, 2, 3) # dim=3,shape=[1,2,3],随机取0~1之间的数
      b = a[0]  # 在第一个维度上取,得到的就是shape=[2,3]的dim=2的Tensor

   2. dim=4的张量适合用于CNN表示图像，CNN:[batch,channel,height,width]
4. tensor.numel()计算tensor中的元素个数
5. 创建tensor的方法：
   1. 从numpy创建：

      a = np.array([2, 3.3])
      a = torch.from_numpy(a)  # torch.DoubleTensor

   2. 从list创建：

      a = torch.FloatTensor([2, 3.3])  # 尽量少用这种方式,容易和给shape的情况看混淆
      b = torch.tensor([2, 3.3])  # 现有list时尽量用这种方式
      # 注意小写的tensor只接受现有的数据；而大写的Tensor相当于就是FloatTensor，既可以接收现有的数据，也可以接受shape来创建指定形状的Tensor。

   3. 使用相同元素构建：

       # shape=2,3,所使用的相同的元素为7
       b = torch.full([2, 3], 7)

   4. 等差序列：其实有些情况下可以把torch当做numpy使用

      c = torch.arange(0, 8, 2)  # tensor([0, 2, 4, 6])
6. 初始化：
   1. 正态分布初始化：

      a = torch.randn(2, 3)  # 2行3列,正态分布~N(0,1) 得到的是torch.FloatTensor类型的数据

   2. 仅指定维度的初始化：按照shape来创建，而先不为其提供具体值。

      # 生成2行3列的数据
      a = torch.empty(2, 3)
      b = torch.FloatTensor(2, 3)
      c = torch.IntTensor(2, 3)

   3. 采样自0~1均匀分布：

      a = torch.rand(3, 3)

   4. 随机初始化：

      1. 形如*_like接受一个Tensor,将这个Tensor的shape读取出来之后在送入*所表示的函数

         # 下面的rand_like(a)即将a的shape=3,3读出来传给torch.rand()函数
         b = torch.rand_like(a)

      2. 在区间[1,10)上随机采样,生成shape=2,2的LongTensor

         c = torch.randint(1, 10, [2, 2])

   5. 使用何恺明的初始化方法：

      w1 = torch.randn(200, 784, requires_grad=True)
      torch.nn.init.kaiming_normal_(w1)

   6. 网络中参数的初始化方法对网络的perform影响是很大的。
7. 修改tensor的默认类型：使用torch.tensor传入浮点数元素，或者使用torch.Tensor仅指定维度时，生成的默认是FloatTensor，也可以修改默认设置使其默认是其它类型的。

   torch.set_default_tensor_type(torch.DoubleTensor)

8. mask 索引：可以获取满足一些条件的值的位置索引，然后用这个索引去取出这些位置的元素。

   # 取出a这个Tensor中大于0.5的元素
   a = torch.randn(3, 4)
   print(a)
   x = a.ge(0.5)
   print(x)
   print(a[x])

9. 改变shape：reshape函数
10. 增加维度：正的索引是在那个维度原本的位置前面插入这个新增加的维度，负的索引是在那个位置之后插入。

    print(a.unsqueeze(0).shape)  # 在0号维度位置插入一个维度
    print(a.unsqueeze(-1).shape)  # 在最后插入一个维度
    print(a.unsqueeze(3).shape)  # 在3号维度位置插入一个维度

11. 删减维度：删减维度实际上是一个压榨的过程，直观地看是把那些多余的[]给去掉，也就是只是去删除那些size=1的维度。

    a = torch.Tensor(1, 4, 1, 9)
    print(a.shape)
    print(a.squeeze().shape) # 能删除的都删除掉
    print(a.squeeze(0).shape) # 尝试删除0号维度,ok
    print(a.squeeze(2).shape) # 尝试删除2号维度,ok
    print(a.squeeze(3).shape) # 尝试删除3号维度,3号维度是9不是1,删除失败

12. 维度扩展(expand)：expand就是在某个size=1的维度上改变size，改成更大的一个大小，实际就是在每个size=1的维度上的标量的广播操作。

    b = torch.rand(32)
    f = torch.rand(4, 32, 14, 14)
    # 想要把b加到f上面去
    # 先进行维度增加
    b = b.unsqueeze(1).unsqueeze(2).unsqueeze(0)
    print(b.shape)
    
    # 再进行维度扩展
    b = b.expand(4, -1, 14, 14)  # -1表示这个维度保持不变,这里写32也可以
    print(b.shape)
    # 运行结果：torch.Size([1, 32, 1, 1])
    # torch.Size([4, 32, 14, 14])

13. 维度重复(repeat)：repeat就是将每个位置的维度都重复至指定的次数，以形成新的Tensor。repeat会重新申请内存空间。
14. 转置：只适用于dim=2的Tensor：

    tensor.t()

15. 维度交换:注意这种交换使得存储不再连续，再执行一些reshape的操作肯定是执行不了的，所以要调用一下contiguous()使其变成连续的维度。

    d = torch.Tensor(6, 3, 1, 2)
    print(d.transpose(1, 3).contiguous().shape)  # 1号维度和3号维度交换

16. 使用permute可以直接指定维度新的所处位置 

    h.permute(0, 2, 3, 1)

17. Broadcasting:
    1. 从最后面的维度开始匹配。
    2. 在前面插入若干维度。
    3. 将维度的size从1通过expand变到和某个Tensor相同的维度。
    4. 总之，Broadcasting也就是自动实现了若干unsqueeze和expand操作，以使两个Tensor的shape一致，从而完成某些操作（往往是加法）。
18. 维度合并(cat)：要保证其它维度的size是相同的。

    a = torch.rand(4, 32, 8)
    b = torch.rand(5, 32, 8)    
    print(torch.cat([a, b], dim=0).shape) #  torch.Size([9, 32, 8]

19. 合并新增(stack)：stack需要保证两个Tensor的shape是一致的，这就像是有两类东西，它们的其它属性都是一样的（比如男的一张表，女的一张表）。使用stack时候要指定一个维度位置，在那个位置前会插入一个新的维度，因为是两类东西合并过来所以这个新的维度size是2，通过指定这个维度是0或者1来选择性别是男还是女。

    c = torch.rand(4, 3, 32, 32)
    d = torch.rand(4, 3, 32, 32)
    print(torch.stack([c, d], dim=2).shape) # torch.Size([4, 3, 2, 32, 32])
    print(torch.stack([c, d], dim=0).shape) # torch.Size([2, 4, 3, 32, 32])

20. 对tensor进行拆分：
    1. 按照size的长度拆分：

       a = torch.rand(2, 4, 3, 32, 32)
       a1, a2 = a.split(1, dim=0)  # 对0号维度拆分,拆分后每个Tensor取长度1
       print(a1.shape, a2.shape) #  torch.Size([1, 4, 3, 32, 32]) torch.Size([1, 4, 3, 32, 32])
       b = torch.rand(4, 3, 32, 32)
       b1, b2 = b.split([2, 1], dim=1)  # 对1号维度拆分,拆分后第一个维度取2,第二个维度1
       print(b1.shape, b2.shape) # torch.Size([4, 2, 32, 32]) torch.Size([4, 1, 32, 32])

    2. 按照份数等量拆分：给定在指定的维度上要拆分得的份数，就会按照指定的份数尽量等量地进行拆分。

       c = torch.rand(7, 4)
       c1, c2, c3, c4 = c.chunk(4, dim=0)
       print(c1.shape, c2.shape, c3.shape, c4.shape) 
       
       # 结果：torch.Size([2, 4]) torch.Size([2, 4]) torch.Size([2, 4]) torch.Size([1, 4])