pytorch 中维度（Dimension）概念的理解

pytorch 中维度（Dimension）概念的理解

Dimension为0（即维度为0时）

维度为0时，即tensor(张量)为标量。例如：神经网络中损失函数的值即为标量。
接下来我们创建一个dimension为0 的tensor

#导入torch
import torch
#创建一个维度为0的tensor
a = torch.tensor(1.)
print(a)#输出a
print(a.size())#表示tensor的类型，size和shape在pytorh中都表示tensor的类型
print(a.shape)
print(len(a.shape))

其输出为：

tensor(1.)
torch.Size([])
torch.Size([])
0

Dimension为1 的tensor。

接下来我们接着创建一个维度为1的tensor，与维度为0的张量创建时相比，仅仅只多了一个[ ]。

#导入torch
import torch
#创建一个维度为1的tensor
a = torch.tensor([1.1])
print(a)#输出a
print(a.shape)#输出形状
print(len(a.shape))

其输出结果为：

tensor([1.1000])#python中默认为浮点数类型
torch.Size([1])#中括号里边的1，即代表1维
1

维度为1的tensor常用于偏置（bias）或者神经网络中线性层的输入

Dimension为2的tensor

首先，我们创建一个2行3列的Tensor。

#导入torch
import torch
#创建一个维度为2的tensor
b = torch.randn(2,3)#randn是正态分布，即创建一个2行3列的矩阵，矩阵内元素符合均值为0方差为1的分布
print(b)#输出b
print(b.size())#输出tensor的类型
print(len(b.shape))

其输出结果为：

tensor([[-0.6245, -0.9659,  0.8636],
        [-0.9493,  0.6241, -1.5067]])
torch.Size([2, 3])#tensor类型为2行3列的矩阵
2

那么我们如何来理解这个二维的tensor呢？实际上，这个二维的tensor就是一个二维矩阵，2维即可理解为矩阵的行和列，行即维度为0，列即维度为1。我们再来看一下：

print(b.shape[0])
print(b.shape[1])

输出为：

2
3

显示，我们可以更加直观的看出，2为的tensor，其索引为0和1，0代表其行数，1代表其列数。在大致了解了二维的tensor后，我们再来理解一下他的物理意义：
一个带有batch的线性层输入，即加入一个图片的宽和高为[25,25],打平后为[625],
则[2,625]即表示2张图片一块输入，每个图片的大小是625

接着如果我们按照dim=0对其求和，会得到什么呢？如下代码所示：

print(b)
print(torch.sum(b,dim=0))

输出为：

tensor([[ 0.5664,  0.8722,  1.0401],
        [ 0.1872, -1.4659, -0.1133]])

tensor([ 0.7536, -0.5937,  0.9268])

从上边结果中我们可以很直观的看出，对于在dim=0上的求和，即行不变，tensor内的位置元素按列对应相加，输出的为维度为1的，长度为3的tensor,这难道不就是我们刚才创建的二维tensor的列数吗？
我们再来看来看一下，对dim=1时的求和，或者我们会更加明白。

print(b)
print(torch.sum(b,dim=1))

输出为：

tensor([[ 0.5885, -0.9505, -0.3206],
        [-1.0481,  0.4318, -0.8288]])
tensor([-0.6827, -1.4452])

同样，由上述结果所示，dim=1,即列不变，按行求和，其输出结果为一个维度为1，长度为2的tensor。也即我们刚才创建的二维tensor的行数。
总结：当我们按照某一个维度进行运算时，即该维度不变，对另一维度进行运算，且输出为另一个维度的大小。
下面我们以一个动图来进一步深刻理解一下：如下面的动图所示, 当dim=0的时候, 按每一行的元素进行相加, 最后的结果就是和按列求和。（下面的动图中，也是一个二维tensor，但是各元素值为1、2、3、4、5、6）。大家可以看一下加深一下印象。

Dimension为3的tensor

下面我们创建一个三维的tensor,其中的rand()表示的是以0-1之间的均值分布来进行初始化。

#导入torch
import torch
#创建一个维度为3的tensor
c = torch.rand(1,2,3)
print(c)

输出结果：

tensor([
		 [[0.7255, 0.9112, 0.8162],
         [0.7307, 0.3815, 0.5921]]
       ])

上述的三维tensor ，其实就是一个二维矩阵外边，又套了一层中括号。即这个三维的tensor可以理解为有一个2行3列的矩阵，
我们再来看一下他的形状

print(c.shape)
print(c[0])

输出为：

torch.Size([1, 2, 3])
tensor( [[0.7255, 0.9112, 0.8162],
         [0.7307, 0.3815, 0.5921]])

从上边的输出结果可以看出，size的形状为，[1,2,3]；而c[0]表示的是第三维上的那个二维矩阵，且索引只为0，因为只有一个二维矩阵，若第三维上有两个二维矩阵，则索引为0,1。
我们再来输出一下其它的：

print(c[0,0])

输出为

tensor([0.7255, 0.9112, 0.8162])

上边的输出结果表示什么？其实就是，c[0,0]；第一个0表示的是第三维，也就是那个二维矩阵，而第二个0就是二维矩阵的第一行。
总结：三维的tensor中，例如[2,3,4],第三维即这个列表中的第一个元素（在这维度上的索引为0,1），记为：dim = 0;第二维即这个这个列表中的第二个元素，记为dim = 1（其实就是表示二维数组行的维度，该维度上的索引为0,1,2），最后一个维度及这个列表中第三个元素，记为dim =2，（即二维数组中表示列的维度，该维度上的索引为0，1，2，3）。

我们再来看一下，对于3维的Tensor在各个维度上求和是怎么样的。
重新创建一个3维的tensor

#导入torch
import torch
#创建一个维度为3的tensor
c = torch.rand(3,2,3)

print(c)
print(c.shape)

输出结果为：

tensor([[[0.0932, 0.7748, 0.1215],
         [0.6337, 0.3522, 0.1062]],

        [[0.5779, 0.6993, 0.0230],
         [0.9226, 0.5299, 0.1861]],

        [[0.0227, 0.3016, 0.9368],
         [0.7684, 0.7787, 0.6171]]])
torch.Size([3, 2, 3])

由上述结果可知，该3维的Tensor其实就是，三个2行3列的二维数组。

对dim=0求和：

print(torch.sum(c,dim=0))

输出结果为：

tensor([[0.6937, 1.7757, 1.0814],
        [2.3247, 1.6609, 0.9093]])

在dim=0上求和，即把每个二维数据按照对应位置，相加即可，且其输出的形状为[2,3]，下面我们看个动图再进一步理解一下：

对dim=1求和：

print(torch.sum(c,dim=2))

输出结果为：

tensor([[0.7269, 1.1271, 0.2277],
        [1.5005, 1.2292, 0.2091],
        [0.7911, 1.0803, 1.5539]])

在dim=1上求和，即对每个二维矩阵，行不变，按列相加，然后组合在一块，且其输出的形状为[3,3]
我们再来看一组动图：

对dim=2求和：

print(torch.sum(c,dim=2))

输出结果为：

tensor([[0.9896, 1.0921],
        [1.3002, 1.6386],
        [1.2611, 2.1641]])

在dim=2上求和，即对每个二维矩阵，列不变，按行相加，然后组合在一块，且其输出的形状为[3,2]
我们再来看一组动图：

注：在各个维度输出的形状，与整个tensor形状有关，各位自己再揣摩一下。

Dimension为4的tensor

维度为4的tensor，最常见的情况就是在卷积神经网络 中，[batch,channel,height,width]。接下来，我们创建一个四维的tensor。

#导入torch
import torch
#创建一个维度为4的tensor
c = torch.rand(2,3,25,25)
"""
上边创建的四维tensor ，各参数的物理意义可理解为;2表示进行处理的图片batch，这里为两张；
3表示的是该图片为彩色图片，channel数量为RGB3通道，25*25表示图片的长和宽。
"""
print(c)
print(c.shape)
print(c.numel())#numel函数，及number element。即逐元素相乘。
print(c.dim())#求tensor的维度为多少

输出结果为：

tensor([[[[0.0885, 0.7384, 0.6371,  ..., 0.3208, 0.0581, 0.7142],
          [0.8130, 0.0404, 0.7012,  ..., 0.6019, 0.1015, 0.9588],
          [0.4855, 0.6130, 0.1593,  ..., 0.1474, 0.3851, 0.5320],
          ...,
          [0.1728, 0.4715, 0.3917,  ..., 0.9605, 0.8233, 0.8145],
          [0.6379, 0.7163, 0.2047,  ..., 0.2210, 0.8876, 0.7437],
          [0.2638, 0.3275, 0.7637,  ..., 0.5851, 0.0522, 0.8435]],

         [[0.4587, 0.2620, 0.5742,  ..., 0.1823, 0.1100, 0.7643],
          [0.8904, 0.8908, 0.1480,  ..., 0.3918, 0.3410, 0.7371],
          [0.6350, 0.4235, 0.4947,  ..., 0.1291, 0.7077, 0.4199],
          ...,
          [0.9750, 0.9149, 0.0253,  ..., 0.7849, 0.9863, 0.4276],
          [0.4117, 0.9636, 0.2074,  ..., 0.5924, 0.8397, 0.5174],
          [0.6355, 0.9376, 0.6325,  ..., 0.5065, 0.9398, 0.4591]],

         [[0.7319, 0.3808, 0.3656,  ..., 0.6158, 0.8127, 0.5377],
          [0.7817, 0.5277, 0.9428,  ..., 0.0032, 0.7543, 0.2630],
          [0.3526, 0.2539, 0.6907,  ..., 0.7403, 0.6150, 0.8632],
          ...,
          [0.9896, 0.2491, 0.9341,  ..., 0.5563, 0.1472, 0.7592],
          [0.5110, 0.8409, 0.2105,  ..., 0.9475, 0.0620, 0.6796],
          [0.6519, 0.9809, 0.7917,  ..., 0.7317, 0.0315, 0.7892]]],


        [[[0.2208, 0.9637, 0.9443,  ..., 0.4771, 0.5033, 0.2917],
          [0.1701, 0.8320, 0.3640,  ..., 0.5074, 0.6219, 0.1707],
          [0.4048, 0.1494, 0.9358,  ..., 0.8532, 0.2298, 0.0691],
          ...,
          [0.2787, 0.3809, 0.9087,  ..., 0.4491, 0.4912, 0.4132],
          [0.1516, 0.4484, 0.4718,  ..., 0.9796, 0.8061, 0.4744],
          [0.6960, 0.5026, 0.5266,  ..., 0.7811, 0.4093, 0.5238]],

         [[0.3725, 0.7506, 0.8075,  ..., 0.9897, 0.6699, 0.3276],
          [0.3139, 0.5054, 0.3133,  ..., 0.3512, 0.1084, 0.8433],
          [0.8386, 0.3877, 0.1941,  ..., 0.0903, 0.6257, 0.2474],
          ...,
          [0.0579, 0.4931, 0.8824,  ..., 0.1812, 0.8336, 0.0030],
          [0.2589, 0.3976, 0.6554,  ..., 0.1437, 0.4533, 0.0758],
          [0.2885, 0.1804, 0.6388,  ..., 0.4709, 0.2782, 0.8804]],

         [[0.4836, 0.3040, 0.6066,  ..., 0.6594, 0.3668, 0.4089],
          [0.4970, 0.8915, 0.5742,  ..., 0.5544, 0.2297, 0.8319],
          [0.8399, 0.8372, 0.8259,  ..., 0.8524, 0.0242, 0.1726],
          ...,
          [0.1040, 0.3566, 0.1785,  ..., 0.4557, 0.4020, 0.7327],
          [0.0273, 0.0586, 0.4000,  ..., 0.8475, 0.2587, 0.6252],
          [0.1678, 0.0942, 0.1210,  ..., 0.1048, 0.4521, 0.5950]]]])
torch.Size([2, 3, 25, 25])
3750#这里即为2*3*25*25
4

由此，本篇文章对pytorch中维度的描述，做了一个简单的介绍，希望能够为大家的学习提供一点点帮助。由于本人也是刚开始进行学习，如果有什么写的不对的，敬请批评指正。

在这里要感谢文艺数学君，王 茂南 发表于 2020年4月11日07:51:51的一篇博文