pytorch中张量的4中维度和形状变化

张量的维度和形变

张量作为一组数的结构化表示，也同样拥有维度的概念。简便理解：向量就是一维的数组，而矩阵是二维的数组，以此类推，在张量中我们还可以定义更高维度的数组。张量的高维数组和numpy中高维array概念类似。
记住：文章中提到的，t1为一维张量，t2为二维张量，t3为零维张量，t4为三维张量。

1、创建一维、二维、零维、高维张量

1.1 用简单序列创建一维张量

#用一维列表序列创建一维张量
t1 = torch.tensor([1, 2])
结果为：tensor([1, 2])
#使用ndim属性查看张量的维度
t1.ndim
结果为：1
#使用shape查看张量的形状
t1.shape
结果为：torch.Size([2])
#和Size函数相同
t1.size()
结果为：torch.Size([2])

注意：pytorch和numpy不同，pytorch中的.size()方法返回结果和.shape属性返回结果一致。

1.2 用序列的序列创建二维张量
含义：以此类推，还可以通过形状相同的序列组成一个新的序列，进而将其转化为二维张量

#用二维list创建二维张量
t2 = torch.tensor([[1, 2], [3, 4]])
结果为：tensor([1, 2],
			   [3, 4])
#使用ndim属性查看张量的维度
t2.ndim
结果为：2
#使用shape查看张量的形状
t2.shape
结果为：torch.Size([2, 2])
#和Size函数相同
t2.size()
结果为：torch.Size([2, 2])

1.3 “零维”张量----拥有张量属性的单独的一个数，其是标量。
在pytorch中，还有一类特殊的张量，被称为零维张量。该类型张量只包含一个元素，但又不是一个单独的数。

#零维张量
t3 = torch.tensor(1)
结果为：tensor(1)
#使用ndim属性查看张量的维度
t3.ndim
结果为：0
#使用shape查看张量的形状
t3.shape
结果为：torch.Size([])
#和Size函数相同
t3.size()
结果为：torch.Size([])

理解零维张量：
我们可以将零维张量视为拥有张量属性的单独的一个数。（例如，张量可以存在GPU上，但python原生的数值型对象不行，但零维张量可以，尽管是零维。）python中单独一个数是scalars（标量），而零维的张量则是tensor。
1.3 高维张量
一般来说，三维及三维以上的张量，就称其为高维张量。

#由两个形状相同的二维数组创建一个三维张量 
a1 = np.array([[1, 2, 2],[3, 4, 4]])
a2 = np.array([[5, 6, 6],[7, 8, 8]])
t4 = torch.tensor([a1, a2])
print(t4)
结果为：tensor([[[1, 2, 2],
          		 [3, 4, 4]],
                 
                [[5, 6, 6],
                 [7, 8, 8]]], dtype=torch.int32)

#使用ndim属性查看张量的维度
t4.ndim
#结果为：3
#使用shape查看张量的形状
t4.shape
#结果为：torch.Size([2, 2, 3])#3个元素代表3维，两个两行三列的矩阵张量
#还可表示成：3维张量有2个二维张量组成，每个二维张量有2个一维张量组成，每个一维张量有3个元素
#和Size函数相同
t4.size()
#结果为：torch.Size([2, 2, 3])
t4.numel() #表示张量中元素的个数
#结果为：12

结论：N维张量的创建方法，可以先创建M个N-1维的数组，然后将其拼成一个N维的张量。

2、张量的形变，.flatten()方法，.reshape()方法

张量作为数字的结构化集合，其结构也是可以根据实际需求灵活调整的。
2.1 .flatten()方法，拉平。将任意维度张量转化为一维张量。

#用二维list创建二维张量
t2 = torch.tensor([[1, 2], [3, 4]])
t2.flatten()
#结果为：tensor([1, 2, 3, 4]) #按行排列，拉平
t4 = torch.tensor([a1, a2])
print(t4)
#结果为：tensor([[[1, 2, 2],
#          		  [3, 4, 4]],
                 
#                 [[5, 6, 6],
#                  [7, 8, 8]]], dtype=torch.int32)
t4.flatten()
#结果为：tensor([1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8],dtype=torch.int32)

注：如果将零维张量使用flatten，则会将其转化为一维张量
#零维张量
t3 = torch.tensor(1)
#结果为：tensor(1)
#使用ndim属性查看张量的维度
t3.flatten()
#结果为：tensor([1])
t3.flatten().ndim  #拉平后变成了一维张量
#结果为：1              

2.2 .reshape()方法：任意变形

t1 = torch.tensor([1, 2])
print(t1) 
#结果为：tensor([1, 2])
print(t1.reshape(2, 1)) #转化为两行一列的向量，此处发生了变化
#结果为：tensor([[1],
#                [2]])
print(t1) #tensor([1, 2])，结果未发生变化
#重点：eshape变形之后t1原来的形状未发生变化
#注意：.reshape()变形，维度变化过程中：reshape转化后的维度由该方法输入的参数“个数”决定。t1.reshape(2, 1)表示：由2个一维张量组成，每个一维张量有一个元素组成
t1.reshape(2, 1).ndim  #变形后变成了2维张量
#结果为：2  
t1.reshape(2, 1).shape
#结果为：torch.Size([2, 1])

2、转化后生成一维张量
t1.reshape(2)
#结果为：tensor([1, 2])
t1.reshape(2).ndim
#结果为：1
t1.reshape(2).shape
#结果为：torch.Size([2])

3、转化后生成二维张量
t1.reshape(1, 2)#生成包含一个两个元素的二维张量，过于抽象
生成一个二维张量，由一个一维张量组成，每个一维张量有两个元素
#结果为：tensor([[1, 2]])
t1.reshape(1, 2).ndim
#结果为：2
t1.reshape(1, 2).shape
#结果为：torch.Size([1, 2])

4、转化后生成三维张量
t1.reshape(1, 1, 2)
#结果为：tensor([[[1, 2]]])
t1.reshape(1, 1, 2).ndim
#结果为：3
t1.reshape(1, 1, 2).shape
#结果为：torch.Size([1, 1, 2])

5、通过.reshape()方法拉平
print(t4.reshape(12))  #通过reshape拉平，
#结果为：tensor([1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8], dtype=torch.int32)