pytorch中torch.stack()用法虽简单，但不好理解

函数功能

沿一个新维度对输入一系列张量进行连接，序列中所有张量应为相同形状，stack 函数返回的结果会新增一个维度。也即是把多个2维的张量凑成一个3维的张量；多个3维的凑成一个4维的张量...以此类推，也就是在增加新的维度上面进行堆叠。

参数列表

tensors ：为一系列输入张量，类型为turple和List

dim ：新增维度的（下标）位置，当dim = -1时默认最后一个维度；范围必须介于 0 到输入张量的维数之间，默认是dim=0,在第0维进行连接

返回值：输出新增维度后的张量

情况一：输入数据为1维数据

dim = 0 : 在第0维进行连接，相当于在行上进行组合(输入张量为一维，输出张量为两维)

import torch

a = torch.tensor([1, 2, 3])

b = torch.tensor([11, 22, 33])

#在第0维进行连接，相当于在行上进行组合，取a的一行，b的一行，构成一个新的tensor(输入张量为一维，输出张量为两维)

c = torch.stack([a, b],dim=0)          

print(a)

print(b)

print(c.size())

print(c)

输出：
tensor([1, 2, 3])
tensor([11, 22, 33])
torch.Size([2, 3])
tensor([[ 1,  2,  3],
        [11, 22, 33]])

dim = 1 ：在第1维进行连接，相当于在对应行上面对列元素进行组合(输入张量为一维，输出张量为两维)

import torch

a = torch.tensor([1, 2, 3])

b = torch.tensor([11, 22, 33])

print(a)

print(b)

#在第1维进行连接，相当于在对应行上面对列元素进行组合，取a的一列，b的一列，构成新的tensor的一行(输入张量为一维，输出张量为两维)

c = torch.stack([a, b],dim=1)

print(c.size())

print(c)

输出：
tensor([1, 2, 3])
tensor([11, 22, 33])
torch.Size([3, 2])
tensor([[ 1, 11],
        [ 2, 22],
        [ 3, 33]])

情况二：输入数据为2维数据

dim=0：表示在第0维进行连接，相当于在通道维度上进行组合(输入张量为两维，输出张量为三维)，注意：此处输入张量维度为二维，因此dim最大只能为2。

import torch

a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

b = torch.tensor([[11, 22, 33], [44, 55, 66], [77, 88, 99]])

print(a)

print(b)
#在第0维进行连接，相当于在通道维度上进行组合
#即取a的所有数据，作为新tensor的一个分量
#取b的所有数据，作为新tensor的另一个分量
#(输入张量为两维，输出张量为三维)

c = torch.stack([a, b],dim=0)

print(c.size())

print(c)

输出：
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
tensor([[11, 22, 33],
        [44, 55, 66],
        [77, 88, 99]])
torch.Size([2, 3, 3])
tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[11, 22, 33],
         [44, 55, 66],
         [77, 88, 99]]])

dim=1：表示在第1维进行连接，相当于对相应通道中每个行进行组合，注意：此处输入张量维度为二维，因此dim最大只能为2。

import torch

a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

b = torch.tensor([[11, 22, 33], [44, 55, 66], [77, 88, 99]])

print(a)

print(b)

#在第1维(行)进行连接，相当于对相应通道中每个行进行组合
#取a的一行，b的一行，作为新tensor的第1行和第2行
#原来a：3*3，b:3*3,新tensor：3*2*3

c = torch.stack([a, b], 1)

print(c.size())

print(c)

输出：
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
tensor([[11, 22, 33],
        [44, 55, 66],
        [77, 88, 99]])
torch.Size([3, 2, 3])
tensor([[[ 1,  2,  3],
         [11, 22, 33]],

        [[ 4,  5,  6],
         [44, 55, 66]],

        [[ 7,  8,  9],
         [77, 88, 99]]])

dim=2：表示在第2维进行连接，相当于对相应行中每个列元素进行组合，注意：此处输入张量维度为二维，因此dim最大只能为2。

import torch

a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

b = torch.tensor([[11, 22, 33], [44, 55, 66], [77, 88, 99]])

print(a)

print(b)

#在第2维进行连接，相当于对相应行中每个列元素进行组合
#针对每行，取a、b的第一列数据，构成tensor的第一行
#针对每行，取a、b的第二列数据，构成tensor的第二行
#，针对每行取a、b的第三列数据，构成tensor的第三行
#原来a：3*3，b:3*3,新tensor：3*3*2
c = torch.stack([a, b], 2)

print(c.size())

print(c)

输出：
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
tensor([[11, 22, 33],
        [44, 55, 66],
        [77, 88, 99]])
torch.Size([3, 3, 2])
tensor([[[ 1, 11],
         [ 2, 22],
         [ 3, 33]],

        [[ 4, 44],
         [ 5, 55],
         [ 6, 66]],

        [[ 7, 77],
         [ 8, 88],
         [ 9, 99]]])

情况三：输入数据为3维数据

dim=0：表示在第0维进行连接，相当于在通道维进行拼接。注意：此处输入张量维度为三维，因此dim最大只能为3。

import torch

a = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[10, 20, 30], [40, 50, 60], [70, 80, 90]]])

b = torch.tensor([[[11, 22, 33], [44, 55, 66], [77, 88, 99]], [[110, 220, 330], [440, 550, 660], [770, 880, 990]]])

print(a)

print(b)

#表示在第0维进行连接，取整个a作为新tensor的一个分量，取整个b作为新tensor的一个分量
c = torch.stack([a, b], 0)

print(c)

输出：
tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]])
torch.Size([2, 3, 3])
tensor([[[ 11,  22,  33],
         [ 44,  55,  66],
         [ 77,  88,  99]],

        [[110, 220, 330],
         [440, 550, 660],
         [770, 880, 990]]])
torch.Size([2, 3, 3])
torch.Size([2, 2, 3, 3])
tensor([[[[  1,   2,   3],
          [  4,   5,   6],
          [  7,   8,   9]],

         [[ 10,  20,  30],
          [ 40,  50,  60],
          [ 70,  80,  90]]],


        [[[ 11,  22,  33],
          [ 44,  55,  66],
          [ 77,  88,  99]],

         [[110, 220, 330],
          [440, 550, 660],
          [770, 880, 990]]]])

dim=1：表示在第1维进行连接，取各自的第1维度数据，进行拼接。注意：此处输入张量维度为三维，因此dim最大只能为3。

import torch

a = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[10, 20, 30], [40, 50, 60], [70, 80, 90]]])

b = torch.tensor([[[11, 22, 33], [44, 55, 66], [77, 88, 99]], [[110, 220, 330], [440, 550, 660], [770, 880, 990]]])

print(a)
print(a.size())

print(b)
print(b.size())

#表示在第1维进行连接，取a的第一维数据[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#取b的第一维数据[[11, 22, 33], [44, 55, 66], [77, 88, 99]]作为新tensor的一个分量

#取a的第一维数据[[10, 20, 30], [40, 50, 60], [70, 80, 90]]
#取b的第一维数据[[110, 220, 330], [440, 550, 660], [770, 880, 990]]作为新tensor的另一个分量
c = torch.stack([a, b], 1)

print(c.size())

print(c)

输出：
tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]])
torch.Size([2, 3, 3])
tensor([[[ 11,  22,  33],
         [ 44,  55,  66],
         [ 77,  88,  99]],

        [[110, 220, 330],
         [440, 550, 660],
         [770, 880, 990]]])
torch.Size([2, 3, 3])
torch.Size([2, 2, 3, 3])
tensor([[[[  1,   2,   3],
          [  4,   5,   6],
          [  7,   8,   9]],

         [[ 11,  22,  33],
          [ 44,  55,  66],
          [ 77,  88,  99]]],


        [[[ 10,  20,  30],
          [ 40,  50,  60],
          [ 70,  80,  90]],

         [[110, 220, 330],
          [440, 550, 660],
          [770, 880, 990]]]])

dim=2：表示在第2维进行连接，取各自的第2维度数据，进行拼接。注意：此处输入张量维度为三维，因此dim最大只能为3。

import torch

a = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[10, 20, 30], [40, 50, 60], [70, 80, 90]]])

b = torch.tensor([[[11, 22, 33], [44, 55, 66], [77, 88, 99]], [[110, 220, 330], [440, 550, 660], [770, 880, 990]]])

print(a)
print(a.size())

print(b)
print(b.size())

#表示在第1维进行连接，取a的第2维数据[1, 2, 3]
#取b的第2维数据[11, 22, 33]作为新tensor的一个分量

#取a的第2维数据[4, 5, 6]
#取b的第2维数据[44, 55, 66]作为新tensor的一个分量

#取a的第2维数据[4, 5, 6]
#取b的第2维数据[44, 55, 66]作为新tensor的一个分量

#取a的第2维数据[7, 8, 9]
#取b的第2维数据[77, 88, 99]作为新tensor的一个分量

#取a的第2维数据[10, 20, 30]
#取b的第2维数据[110, 220, 330]作为新tensor的一个分量

#取a的第2维数据[40, 50, 60]
#取b的第2维数据[440, 550, 660]作为新tensor的一个分量

#取a的第2维数据[70, 80, 90]
#取b的第2维数据[770, 880, 990]作为新tensor的一个分量
c = torch.stack([a, b], 2)
print(c.size())

print(c)

输出：
tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]])
torch.Size([2, 3, 3])
tensor([[[ 11,  22,  33],
         [ 44,  55,  66],
         [ 77,  88,  99]],

        [[110, 220, 330],
         [440, 550, 660],
         [770, 880, 990]]])
torch.Size([2, 3, 3])
torch.Size([2, 3, 2, 3])
tensor([[[[  1,   2,   3],
          [ 11,  22,  33]],

         [[  4,   5,   6],
          [ 44,  55,  66]],

         [[  7,   8,   9],
          [ 77,  88,  99]]],


        [[[ 10,  20,  30],
          [110, 220, 330]],

         [[ 40,  50,  60],
          [440, 550, 660]],

         [[ 70,  80,  90],
          [770, 880, 990]]]])

dim=3：表示在第3维进行连接，取各自的第3维度数据，进行拼接。注意：此处输入张量维度为三维，因此dim最大只能为3。

import torch

a = torch.tensor([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[10, 20, 30], [40, 50, 60], [70, 80, 90]]])

b = torch.tensor([[[11, 22, 33], [44, 55, 66], [77, 88, 99]], [[110, 220, 330], [440, 550, 660], [770, 880, 990]]])

print(a)
print(a.size())

print(b)
print(b.size())

#针对第二维数据，在每个第二维度相同的情况下，取各自的列数据，构成新tensor的一行
c = torch.stack([a, b], 3)
print(c.size())

print(c)

输出：
tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9]],

        [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]])
torch.Size([2, 3, 3])
tensor([[[ 11,  22,  33],
         [ 44,  55,  66],
         [ 77,  88,  99]],

        [[110, 220, 330],
         [440, 550, 660],
         [770, 880, 990]]])
torch.Size([2, 3, 3])
torch.Size([2, 3, 3, 2])
tensor([[[[  1,  11],
          [  2,  22],
          [  3,  33]],

         [[  4,  44],
          [  5,  55],
          [  6,  66]],

         [[  7,  77],
          [  8,  88],
          [  9,  99]]],


        [[[ 10, 110],
          [ 20, 220],
          [ 30, 330]],

         [[ 40, 440],
          [ 50, 550],
          [ 60, 660]],

         [[ 70, 770],
          [ 80, 880],
          [ 90, 990]]]])

总结：m个序列数据，在某个维度k进行拼接，该维度大小为n，则拼接后形成了*n*m*大小，具体拼接过程是取m个序列数据，k-1维(设k-1维大小为x，从x=1开始取)相同情况下的第1个数据，构成新tensor的一个行；第二个数据...，第三个数据...构成tensor的新行；然后从x=2开始执行同样的操作