torch.cat函数用法

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

本文主要包括以下内容:

  • 1. cat函数构成
  • 2.两个二维张量拼接
    • 2.1 二维张量拼接(dim=0维度)
    • 2.2 二维张量拼接(dim=1维度)
  • 3.两个三维张量拼接
    • 3.1 二维张量拼接(dim=0维度)
    • 2.2 二维张量拼接(dim=1维度)
    • 2.3 二维张量拼接(dim=2维度)

1. cat函数构成

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

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

参数说明:

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

2.两个二维张量拼接

假设有两个二维张量ab

import torch

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

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

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

2.1 二维张量拼接(dim=0维度)

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

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

完整代码示例:

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)

输出:

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

在这个示例中,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)

输出:

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

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

3.两个三维张量拼接

假设有两个二维张量cd

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]]]
                 )

3.1 二维张量拼接(dim=0维度)

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

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

完整代码示例:

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)

输出:

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]]])

在这个示例中,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)

输出:

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]]])

在这个示例中,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)

输出:

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]]])

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

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

你可能感兴趣的:(pytorch,pytorch)