torch.cat()

torch.cat(tensors, dim=0, *, out=None) → Tensor

官方解释：利用给定的维度连接给定的张量序列(cat代表concatenate)，所有张量必须具有相同的形状（连接维度除外）或为空。
相当于按指定维度将张量序列进行拼接

参数解释：

tensors：要连接的张量序列(元组tuple或者列表list)
dim：张量连接的维度
out：输出张量(一般用不到，如果有输出，则可以直接进行赋值操作)

注意：
①tensors输入的必须是张量序列，不能是单个张量；
②输入的张量序列除了dim维度，其他维度必须形状相同。

举例：

import torch
a=torch.arange(6).reshape(2,3)
b=torch.arange(12)
c=torch.cat((a,b.reshape(4,3)),dim=0)
# 沿第0维度进行拼接，也就是按行拼接(竖着拼)
d=torch.cat((a,b.reshape(2,6)),dim=1)
# 沿第1维度进行拼接，也就是按列拼接(横着拼)
print(c)
print(c.shape)
print(d)
print(d.shape)

输出：

tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])
torch.Size([6, 3])
tensor([[ 0,  1,  2,  0,  1,  2,  3,  4,  5],
        [ 3,  4,  5,  6,  7,  8,  9, 10, 11]])
torch.Size([2, 9])

利用torch.cat()沿dim拼接，在形状上看相当于对dim进行相加，其余维度大小不变，利用这个思想，可以很容易理解高维数组的拼接

高维举例：

import torch
a=torch.ones(4*256*56*56).reshape(4,256,56,56)
b=torch.arange(4*128*56*56).reshape(4,128,56,56)
c=torch.zeros(4*64*56*56).reshape(4,64,56,56)
d=torch.cat((a,b,c),dim=1)
print(d.shape)

输出：

torch.Size([4, 448, 56, 56])

上述例子在卷积神经网络中常用于特征图的堆叠。

torch.stack()

torch.stack(tensors, dim=0, *, out=None) → Tensor

官方解释：沿着新的维度连接一系列张量，所有的张量都需要具有相同的大小。
相当于先将多个n维张量进行扩维操作，然后再拼接为一个n+1维的张量

参数解释：

tensors：要连接的张量序列(元组tuple或者列表list)
dim：要插入的维度，大小必须介于0和需要拼接的张量维数之间(dim最大不超过张量的维数)
out：输出张量(与cat()类似，一般用不到)

注意：
①与cat(类似，必须输入张量序列，不能是单个张量；
②输入的所有张量序列形状(尺寸)必须一致(这里与cat有区别)。

举例：

import torch
a=torch.arange(12).reshape(3,4)
b=torch.ones(12).reshape(3,4)
c=torch.stack((a,b),dim=0)
d=torch.stack((a,b),dim=1)
e=torch.stack((a,b),dim=2)
# dim最大可到输入张量的维数，即a、b的维数
print(c)
print(c.shape)
print(d)
print(d.shape)
print(e)
print(e.shape)

输出：

tensor([[[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]],

        [[ 1.,  1.,  1.,  1.],
         [ 1.,  1.,  1.,  1.],
         [ 1.,  1.,  1.,  1.]]])
torch.Size([2, 3, 4])
tensor([[[ 0.,  1.,  2.,  3.],
         [ 1.,  1.,  1.,  1.]],

        [[ 4.,  5.,  6.,  7.],
         [ 1.,  1.,  1.,  1.]],

        [[ 8.,  9., 10., 11.],
         [ 1.,  1.,  1.,  1.]]])
torch.Size([3, 2, 4])
tensor([[[ 0.,  1.],
         [ 1.,  1.],
         [ 2.,  1.],
         [ 3.,  1.]],

        [[ 4.,  1.],
         [ 5.,  1.],
         [ 6.,  1.],
         [ 7.,  1.]],

        [[ 8.,  1.],
         [ 9.,  1.],
         [10.,  1.],
         [11.,  1.]]])
torch.Size([3, 4, 2])