torch.cat函数用法

torch.cat函数是PyTorch中用于拼接张量（tensors）的函数。它可以沿着指定的维度将多个张量连接在一起。

1. cat函数构成

下面是torch.cat函数的用法和一个示例说明：

torch.cat(tensors, dim=0, out=None) -> Tensor
1

参数说明：

• tensors：要拼接的张量序列，可以是一个张量列表或元组。
• dim：指定拼接的维度。例如，dim=0表示在第一个维度上拼接，dim=1表示在第二个维度上拼接，以此类推。
• out：可选参数，用于指定输出张量的位置。如果未提供，将创建一个新的张量来保存结果。

2.两个二维张量拼接

假设有两个二维张量a和b：

import torch

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

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

接下来我们将用这两个张量进行示例。

2.1 二维张量拼接（dim=0维度）

要在第一个维度（行）上拼接这两个张量，根据cat函数构成直接拼接即可

result = torch.cat((a, b), dim=0)
print(result)
1
2

完整代码示例：

import torch

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

b = torch.tensor([[5, 6],
                  [7, 8]])

result = torch.cat((a, b), dim=0)
# 在第一个维度上进行拼接
#在[[1, 2], [3, 4]]最外边的"["进行拼接

print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

tensor([[1, 2],
        [3, 4],
        [5, 6],
        [7, 8]])
1
2
3
4

在这个示例中，torch.cat将张量a和张量b沿着第一个维度（行）连接在一起，生成一个新的张量result。可以通过指定不同的dim参数来在其他维度上进行拼接。

2.2 二维张量拼接（dim=1维度）

import torch

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

b = torch.tensor([[5, 6],
                  [7, 8]])

result = torch.cat((a, b), dim=1)
# 在第二个维度上进行拼接
#在[[1, 2], [3, 4]]的第二个"["进行拼接

print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

tensor([[1, 2, 5, 6],
        [3, 4, 7, 8]])
1
2

在这个示例中，torch.cat将张量a和张量b沿着第二个维度（行）连接在一起，生成一个新的张量result。
注意： dim=-1是对最后一个维度进行拼接，因此二维张量dim=-1进行拼接时，结果与dim=-1相同

3.两个三维张量拼接

假设有两个二维张量c和d：

import torch

c = torch.tensor([[[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]],
                 [[11, 12, 13],
                  [14, 15, 16],
                  [17, 18, 19]]]
                 )

d = torch.tensor([[[21, 22, 23],
                  [24, 25, 26],
                  [27, 28, 29]],
                 [[31, 32, 33],
                  [34, 35, 36],
                  [37, 38, 39]]]
                 )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.1 二维张量拼接（dim=0维度）

同样的，要在第一个维度（行）上拼接这两个张量，根据cat函数构成直接拼接即可

result = torch.cat((c, d), dim=0)
print(result)
1
2

完整代码示例：

import torch

c = torch.tensor([[[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]],
                 [[11, 12, 13],
                  [14, 15, 16],
                  [17, 18, 19]]]
                 )

d = torch.tensor([[[21, 22, 23],
                  [24, 25, 26],
                  [27, 28, 29]],
                 [[31, 32, 33],
                  [34, 35, 36],
                  [37, 38, 39]]]
                 )

result = torch.cat((c, d), dim=0)

# 在第一个维度上进行拼接
#在最外边的"["进行拼接

print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出：

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

        [[11, 12, 13],
         [14, 15, 16],
         [17, 18, 19]],

        [[21, 22, 23],
         [24, 25, 26],
         [27, 28, 29]],

        [[31, 32, 33],
         [34, 35, 36],
         [37, 38, 39]]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示例中，torch.cat将张量a和张量b沿着第一个维度（行）连接在一起，生成一个新的张量result。可以通过指定不同的dim参数来在其他维度上进行拼接。

2.2 二维张量拼接（dim=1维度）

import torch

c = torch.tensor([[[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]],
                 [[11, 12, 13],
                  [14, 15, 16],
                  [17, 18, 19]]]
                 )

d = torch.tensor([[[21, 22, 23],
                  [24, 25, 26],
                  [27, 28, 29]],
                 [[31, 32, 33],
                  [34, 35, 36],
                  [37, 38, 39]]]
                 )

result = torch.cat((c, d), dim=1)

# 在第二个维度上进行拼接
#在第二个"["进行拼接

print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出：

tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9],
         [21, 22, 23],
         [24, 25, 26],
         [27, 28, 29]],

        [[11, 12, 13],
         [14, 15, 16],
         [17, 18, 19],
         [31, 32, 33],
         [34, 35, 36],
         [37, 38, 39]]])

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，torch.cat将张量c和张量d沿着第二个维度（行）连接在一起，生成一个新的张量result。

2.3 二维张量拼接（dim=2维度）

import torch

c = torch.tensor([[[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]],
                 [[11, 12, 13],
                  [14, 15, 16],
                  [17, 18, 19]]]
                 )

d = torch.tensor([[[21, 22, 23],
                  [24, 25, 26],
                  [27, 28, 29]],
                 [[31, 32, 33],
                  [34, 35, 36],
                  [37, 38, 39]]]
                 )

result = torch.cat((c, d), dim=2)

# 在第二个维度上进行拼接
#在第三个"["进行拼接，也就是最里面的那个

print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出：

tensor([[[ 1,  2,  3, 21, 22, 23],
         [ 4,  5,  6, 24, 25, 26],
         [ 7,  8,  9, 27, 28, 29]],

        [[11, 12, 13, 31, 32, 33],
         [14, 15, 16, 34, 35, 36],
         [17, 18, 19, 37, 38, 39]]])
1
2
3
4
5
6
7

在这个示例中，torch.cat将张量c和张量d沿着第二个维度（行）连接在一起，生成一个新的张量result。

注意： dim=-1是对最后一个维度进行拼接，因此三维张量dim=-1进行拼接时，结果与dim=-2相同