PyTorch 实战指南：如何高效地将张量列表合并为单个张量

2026-02-02 07:49:09 0条评论 2次阅读 0人点赞

在使用 PyTorch 进行深度学习开发或数据处理时，我们经常会遇到一种非常普遍的情况：手头有一个包含多个张量的列表，但我们的模型或后续的运算逻辑要求输入必须是一个单独的、整合后的张量。

这时候，将“张量列表”转换为“单个张量”就成了一项必须掌握的基本功。这听起来可能很简单，但如果不理解其中的细节，很容易在形状、内存或设备兼容性上踩坑。

在这篇文章中，我们将以实战的角度，深入探讨在 PyTorch 中完成这一任务的各种方法。我们会分析 INLINECODE14daeb8c、INLINECODE09e76108 以及其他转换技巧的区别，通过丰富的代码示例演示它们的工作原理，并分享一些在处理不同形状张量时的最佳实践和避坑指南。无论你是正在准备数据的初学者，还是寻求优化的资深开发者，这篇文章都将为你提供实用的见解。

核心概念：为什么需要合并张量？
方法一：使用 torch.stack() 增加新维度
方法二：使用 torch.cat() 连接现有维度
方法三：使用 torch.tensor() 直接构造
方法四：处理不规则张量（填充与 Mask）
性能优化与内存管理
常见陷阱与解决方案

核心概念：为什么需要合并张量？

在深入代码之前，让我们先统一一下认识。在 PyTorch 中，Tensor（张量）是核心数据结构，类似于多维数组。但在实际操作中，我们往往是分批次获取数据的。

想象一下，你正在处理一个自然语言处理（NLP）任务。你可能有一个包含 10 个句子的列表，每个句子都被转换成了一个形状为 INLINECODEfab9ef23 的张量。为了将它们一次性输入到 LSTM 或 Transformer 模型中，你需要将这 10 个张量合并成一个大张量，其形状通常是 INLINECODE499d0ae0。

这就是我们要解决的问题：将 List[Tensor] 转换为 Tensor。

方法一：使用 `torch.stack()` 增加新维度

torch.stack() 是我们将列表转换为张量时最常用也最直观的函数之一。它的核心思想是“堆叠”——即在现有的数据基础上，增加一个新的维度。

#### 工作原理

假设你有一叠 A4 纸，每张纸上都写着一个数字（比如 1, 2, 3）。如果你把这些纸叠在一起，你就不仅有了数字，还有了“第几张纸”的概念。torch.stack 就是做这件事的：它不会把数据挤平，而是会保留原始张量的形状，并在外面套上一层“索引”。

#### 代码示例

让我们通过一个具体的例子来看看它是如何工作的。

import torch

# 创建三个简单的 1D 张量
tensor_a = torch.tensor([1, 2, 3])
tensor_b = torch.tensor([4, 5, 6])
tensor_c = torch.tensor([7, 8, 9])

# 将它们放入一个列表中
tensor_list = [tensor_a, tensor_b, tensor_c]

print("原始张量列表中的每个张量形状:", tensor_a.shape) # 输出: torch.Size([3])

# 使用 torch.stack 沿着新维度 (dim=0) 进行堆叠
# 这会创建一个新的维度作为第 0 维
stacked_tensor = torch.stack(tensor_list, dim=0)

print("使用 torch.stack (dim=0) 后的结果:")
print(stacked_tensor)
print("新张量的形状:", stacked_tensor.shape) # 输出: torch.Size([3, 3])

输出结果：

原始张量列表中的每个张量形状: torch.Size([3])
使用 torch.stack (dim=0) 后的结果:
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
新张量的形状: torch.Size([3, 3])

在这个例子中，我们原本有 3 个形状为 INLINECODE8eee5395 的向量。堆叠后，我们得到了一个 INLINECODEb46ac338 的矩阵。新增加的第 0 维代表了列表中的索引。

#### 改变堆叠维度

我们也可以改变 INLINECODE28ee3efd 参数。如果我们设 INLINECODE59902587，结果就会不同：

# 沿着维度 1 堆叠
stacked_dim1 = torch.stack(tensor_list, dim=1)

print("使用 torch.stack (dim=1) 后的结果:")
print(stacked_dim1)
print("新张量的形状:", stacked_dim1.shape) # 输出: torch.Size([3, 3])

输出结果：

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

注意到了吗？数据被转置排列了。这表明 stack 非常适合构建批次数据。

重要提示： 使用 torch.stack() 有一个硬性前提：列表中的所有张量必须具有完全相同的形状。如果形状不一，程序会直接报错。

方法二：使用 `torch.cat()` 连接现有维度

如果你不想增加新维度，只是想把数据“首尾相连”地拼接起来，那么 torch.cat()（Concatenate）就是你的不二之选。

#### 工作原理

torch.cat() 会在指定的现有维度上将张量串联起来。这就像把两列火车车厢接在同一轨道上，长度增加了，但车厢的宽度不变。

#### 代码示例

假设我们要合并两个批次的数据：

import torch

# 创建两个 2x3 的矩阵
batch_1 = torch.tensor([[1, 2, 3], 
                        [4, 5, 6]])
                        
batch_2 = torch.tensor([[7, 8, 9], 
                        [10, 11, 12]])

# 列表包含两个张量
tensor_list = [batch_1, batch_2]

# 在第 0 维（行）上进行拼接
# 相当于把 batch_2 的行追加到 batch_1 下面
result_dim0 = torch.cat(tensor_list, dim=0)

print("在 dim=0 上拼接的结果:")
print(result_dim0)
print("形状:", result_dim0.shape) # 输出: torch.Size([4, 3])

输出结果：

在 dim=0 上拼接的结果:
tensor([[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9],
        [10, 11, 12]])
形状: torch.Size([4, 3])

如果我们换成 dim=1（列方向）：

# 在第 1 维（列）上进行拼接
result_dim1 = torch.cat(tensor_list, dim=1)

print("在 dim=1 上拼接的结果:")
print(result_dim1)
print("形状:", result_dim1.shape) # 输出: torch.Size([2, 6])

输出结果：

在 dim=1 上拼接的结果:
tensor([[ 1,  2,  3,  7,  8,  9],
        [ 4,  5,  6, 10, 11, 12]])
形状: torch.Size([2, 6])

使用场景： torch.cat 常用于将多个预测结果合并，或者在 RNN 中处理时间序列数据时将不同时间步的特征拼接在一起。
前提条件： 除了拼接的那个维度，其他维度的形状必须完全一致。

方法三：使用 `torch.tensor()` 直接构造

这是一种“简单粗暴”的方法。你可以直接把一个列表（甚至是包含张量的列表）传给 torch.tensor() 构造函数，它会尝试根据数据创建一个新的张量。

#### 适用场景

这种方法最适用于标量列表（List of numbers）或者非常简单的结构。当处理复杂张量列表时，它可能会产生意想不到的副作用（比如保留原列表作为对象，而不是进行堆叠）。

import torch

# 场景 1：简单的数字列表
scalar_list = [10, 20, 30, 40]
tensor_from_scalars = torch.tensor(scalar_list)

print("将标量列表转换为张量:")
print(tensor_from_scalars) # tensor([10, 20, 30, 40])

# 场景 2：处理简单的一维张量列表
# 注意：这种做法会将它们视为数据源进行组装
list_of_vectors = [torch.tensor([1, 2]), torch.tensor([3, 4])]
# 这里的行为类似 stack，生成一个 2x2 的张量
tensor_from_vectors = torch.tensor(list_of_vectors)

print("
将向量列表转换为张量:")
print(tensor_from_vectors)

输出结果：

将标量列表转换为张量:
tensor([10, 20, 30, 40])

将向量列表转换为张量:
tensor([[1, 2],
        [3, 4]])

方法四：处理不规则张量（填充与 Mask）

这是实际项目中最为棘手的问题。如果我们有一个列表，里面的张量长度不一（比如不同长度的句子），直接使用 INLINECODEbb463148 或 INLINECODEccfda3ca 都会报错。

#### 解决方案：Padding

我们需要先“填充”它们，让短张量变长，直到与最长的那个一样长。通常我们用 0 来填充。

import torch
import torch.nn.functional as F

# 模拟两个长度不一的句子张量
sentence_1 = torch.tensor([1, 2, 3])       # 长度 3
sentence_2 = torch.tensor([4, 5, 6, 7, 8]) # 长度 5

raw_list = [sentence_1, sentence_2]

# 步骤 1：找到最大长度
max_len = max([len(t) for t in raw_list])

# 步骤 2：手动进行填充（Pad）
padded_list = []
for t in raw_list:
    # 计算需要填充多少个 0
    padding_size = max_len - len(t)
    # 使用 F.pad，注意 padding 参数是 (左填充, 右填充, 上填充, 下填充...)
    # 对于 1D 张量，是 (左, 右)
    if padding_size > 0:
        padded_t = F.pad(t, (0, padding_size), ‘constant‘, 0)
    else:
        padded_t = t
    padded_list.append(padded_t)

print("填充后的张量列表:")
for t in padded_list:
    print(t)

# 步骤 3：现在可以安全地使用 stack 了
final_tensor = torch.stack(padded_list)

print("
最终合并后的张量:")
print(final_tensor)
print("形状:", final_tensor.shape) # [2, 5]

输出结果：

填充后的张量列表:
tensor([1, 2, 3, 0, 0])
tensor([4, 5, 6, 7, 8])

最终合并后的张量:
tensor([[1, 2, 3, 0, 0],
        [4, 5, 6, 7, 8]])
形状: torch.Size([2, 5])

这种技术在 NLP 中无处不在。虽然 PyTorch 有 torch.nn.utils.rnn.pad_sequence 函数专门做这个，但理解底层的填充原理对于调试代码至关重要。

性能优化与内存管理

在处理大规模数据时（比如 ImageNet 或大型文本语料库），列表转换不仅仅是代码正确性的问题，更是内存和速度的问题。

预分配内存：如果你是在一个循环中不断使用 INLINECODEa3407d8d 来拼接结果，这会导致严重的内存碎片和性能下降（因为每次 INLINECODEba672371 都会重新分配内存并复制所有数据）。最佳实践是预分配一个足够大的张量，然后填充进去，或者先收集到一个 Python 列表中，最后只调用一次 torch.stack。

    # 不推荐的做法（循环中 cat）
    # result = torch.empty((0, 10))
    # for i in range(100):
    #     data = get_data()
    #     result = torch.cat([result, data], dim=0) # 慢！

    # 推荐的做法（收集后 stack）
    buffer_list = []
    for i in range(100):
        data = get_data() # 假设返回 [1, 10]
        buffer_list.append(data)
    result = torch.stack(buffer_list, dim=0) # 快！

设备一致性：在进行合并操作前，确保列表中的所有张量都在同一个设备上。你不能直接把一个 CPU 张量和一个 GPU 张量进行 stack。通常我们会这样处理：

    device = torch.device("cuda:0")
    # 确保所有张量都移动到目标设备
    tensor_list = [t.to(device) for t in tensor_list]
    stacked = torch.stack(tensor_list)

常见陷阱与解决方案

作为开发者，我们经常会遇到一些令人头疼的错误。让我们看看如何解决它们。

#### 1. RuntimeError: stack expects each tensor to be equal size

错误原因：你试图 stack 形状不同的张量。
解决方案：检查列表中每个张量的 INLINECODE5c577098。如果确实需要合并不同形状的数据，请回顾上面的“填充”部分，或者考虑使用 INLINECODEdc449fbc 配合 unsqueeze 来手动调整维度。

#### 2. RuntimeError: Expected all tensors to be on the same device

错误原因：列表中混入了 CPU 张量和 GPU 张量。
解决方案：在转换前统一设备。

    # 检查并修复设备不匹配
    target_device = tensor_list[0]..device
    for t in tensor_list:
        if t.device != target_device:
            t = t.to(target_device)

#### 3. 数据类型不匹配

虽然 torch.stack 通常会处理类型提升（比如 Int 和 Float 会变成 Float），但显式指定类型总是更安全的，尤其是在模型推理时。

    # 统一转换为 float32
    tensor_list = [t.float() for t in tensor_list]
    stacked = torch.stack(tensor_list)

结语

将列表转换为张量是 PyTorch 编程中的基石，看似简单，实则蕴含着对数据维度的深刻理解。我们探讨了使用 INLINECODE8e83331b 增加维度，使用 INLINECODE4ee0a47b 连接数据，以及如何通过填充来处理不规则数据。

当你下次遇到 List[Tensor] 时，请根据你的数据形状需求做出选择：

形状相同，需要批次维度？ -> torch.stack。
形状相同，只需要更长？ -> torch.cat。
形状不同？ -> 先 Padding，再 stack。

掌握这些方法，能让你在构建 DataLoader 和预处理 Pipeline 时更加得心应手，避免不必要的 Debug 时间。希望这些技巧能帮助你在深度学习的道路上走得更远！

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客

PyTorch 实战指南：如何高效地将张量列表合并为单个张量

目录

核心概念：为什么需要合并张量？

方法一：使用 `torch.stack()` 增加新维度

方法二：使用 `torch.cat()` 连接现有维度

方法三：使用 `torch.tensor()` 直接构造

方法四：处理不规则张量（填充与 Mask）

性能优化与内存管理

常见陷阱与解决方案

结语

相关文章美国1G带宽/1T流量高速vps $17.99/年

PyTorch 实战指南：如何高效地将张量列表合并为单个张量

目录

核心概念：为什么需要合并张量？

方法一：使用 torch.stack() 增加新维度

方法二：使用 torch.cat() 连接现有维度

方法三：使用 torch.tensor() 直接构造

方法四：处理不规则张量（填充与 Mask）

性能优化与内存管理

常见陷阱与解决方案

结语

相关文章美国1G带宽/1T流量高速vps $17.99/年

方法一：使用 `torch.stack()` 增加新维度

方法二：使用 `torch.cat()` 连接现有维度

方法三：使用 `torch.tensor()` 直接构造