pytorch：concat和stack的区别
整体来讲，concat是对dim进行拼接，stack是对dim维进行堆叠。
concat：不会增加新的维度，在指定维度上拼接。
stack：增加一个新的维度将两个单位，然后再上一维度分别进行堆叠。
下面的代码仅为直观维度上的变化，第二部分有图像辅助理解。
代码测试
测试1：以两个[3，4]矩阵a，b作为输入进行concat、stack测试
输入：
#data a and b
a = torch.tensor([[1,2,3,4],
[5,6,7,8]],dtype=torch.int16)
b = torch.tensor([[9,10,11,12],
[13,14,15,16]],dtype=torch.int16)
print("a:\n{}".format(a))
print("b:\n{}".format(b))
#dim=0
ab_concat_0 = torch.cat([a, b], dim=0)
ab_stack_0 = torch.stack([a, b], dim=0)
print("ab_concat_0:\n{}\nshape:{}".format(ab_concat_0,ab_concat_0.shape))
print("ab_stack_0:\n{}\nshape:{}".format(ab_stack_0,ab_stack_0.shape))
#dim=1
ab_concat_1 = torch.cat([a, b], dim=1)
ab_stack_1 = torch.stack([a, b], dim=1)
print("ab_concat_1:\n{}\nshape:{}".format(ab_concat_1,ab_concat_1.shape))
print("ab_stack_1:\n{}\nshape:{}".format(ab_stack_1,ab_stack_1.shape))
#dim=2
# ab_concat_2 = torch.cat([a, b], dim=2) error
ab_stack_2 = torch.stack([a, b], dim=2)
# print("ab_concat_2:\n{}".format(ab_concat_2))
print("ab_stack_2:\n{}\nshape:{}".format(ab_stack_2,ab_stack_2.shape))
输出：
#data
a:
tensor([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]], dtype=torch.int16)
b:
tensor([[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24]], dtype=torch.int16)
#dim=0
ab_concat_0:
tensor([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24]], dtype=torch.int16)
shape:torch.Size([6, 4])
ab_stack_0:
tensor([[[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]],
[[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24]]], dtype=torch.int16)
shape:torch.Size([2, 3, 4])
#dim=1
ab_concat_1:
tensor([[ 1, 2, 3, 4, 13, 14, 15, 16],
[ 5, 6, 7, 8, 17, 18, 19, 20],
[ 9, 10, 11, 12, 21, 22, 23, 24]], dtype=torch.int16)
shape:torch.Size([3, 8])
ab_stack_1:
tensor([[[ 1, 2, 3, 4],
[13, 14, 15, 16]],
[[ 5, 6, 7, 8],
[17, 18, 19, 20]],
[[ 9, 10, 11, 12],
[21, 22, 23, 24]]], dtype=torch.int16)
shape:torch.Size([3, 2, 4])
#dim=2
ab_stack_2:
tensor([[[ 1, 13],
[ 2, 14],
[ 3, 15],
[ 4, 16]],
[[ 5, 17],
[ 6, 18],
[ 7, 19],
[ 8, 20]],
[[ 9, 21],
[10, 22],
[11, 23],
[12, 24]]], dtype=torch.int16)
shape:torch.Size([3, 4, 2])
测试2：升一个维度，用两个维度为[3，4，5]的矩阵进行测试
#data
a:
shape:torch.Size([3, 4, 5])
b:
shape:torch.Size([3, 4, 5])
#dim=0
ab_concat_0:
shape:torch.Size([6, 4, 5])
ab_stack_0:
shape:torch.Size([2, 3, 4, 5])
#dim=1
ab_concat_1:
shape:torch.Size([3, 8, 5])
ab_stack_1:
shape:torch.Size([3, 2, 4, 5])
#dim=2
ab_concat_2:
shape:torch.Size([3, 4, 10])
ab_stack_2:
shape:torch.Size([3, 4, 2, 5])
在图像上
concat
可以理解为沿着dim维延申拼接。
dim=0:
在dim=0，该维度上的单位为红色框的A=（4，3）矩阵，此时concat表示在dim=0上，以A为单位进行延申拼接。
dim=1：
在dim=1，该维度上的单位为类似红色框的B=（1，3）矩阵，此时concat表示在dim=1上，以B为单位进行延申拼接。
dim=2:
在dim=1，该维度上的单位为类似红色框的C=（3，1）矩阵，此时concat表示在dim=2上，以C为单位进行延申拼接。
stack
两个矩阵分别将dim维度下的所有数据为单位，在新的维度上进行堆叠。
dim=0：
在dim=1，此维度下以A=（3，4，3）为单位，如红色框所示，以新的维度分别在上一维（（3，4，3）的上一维度为0，也就是直接将单位在新维度堆叠形成新维度）进行堆叠，得到（3，2，4，3）。
dim=1：
在dim=1，此维度下以B=（4，3）为单位，如红色框所示，以新的维度分别在上一维（（4，3）的上一维度为3）进行堆叠，得到（3，2，4，3）。
dim=2：
在dim=2，此维度下以C=（3）为单位，如红色框所示，以新的维度分别在上一维（（3）的上一维度为4）进行堆叠，得到C’=（4，2，3），然后，以C’为单位，分别在上一维（（4，2，3）的上一维度为3）进行堆叠得到（3，4，2，3）。
dim=3：
在dim=3，此维度下以D=[3] 的下一维度为单位，即最小元素，如红色框所示，以新的维度分别在上一维（上一维度为3）进行堆叠，得到D’=（3，2），然后，以D’为单位，分别在上一维（（3，2）的上一位度为4）进行堆叠得到（4，2，3），然后同理得到（3，4，3，2）。
上述仅为个人理解，如有问题欢迎交流指正。