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

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]

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,所使用的相同的元素为7b = torch.full([2, 3], 7)

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

   c = torch.arange(0, 8, 2)  # tensor([0, 2, 4, 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影响是很大的。

torch.set_default_tensor_type(torch.DoubleTensor)

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

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

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,删除失败

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])

tensor.t()

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

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

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

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]

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])

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])