pytorch api文档：张量的.is_contiguous()方法-判断张量内存是否连续

作者：马育民 • • 阅读：10031

介绍

张量的 .is_contiguous() 方法，是 判断张量内存是否连续 的“检测器”，是决定是否需要调用 .contiguous() 的关键依据，也是理解张量内存布局的核心工具。

作用

返回一个布尔值（True/False），表示当前张量的内存布局是否为“连续（contiguous）”：

  • True：张量内存连续，元素的内存存储顺序与按维度遍历（如行优先）的顺序完全一致；
  • False：张量内存非连续，内存顺序与维度遍历顺序不一致。

这个方法是 只读检测，不会修改张量本身，也不会产生任何内存开销，是判断张量状态的轻量操作。

语法

Tensor.is_contiguous() → bool

例子

import torch

# 1. 初始张量：默认连续
x = torch.tensor([[1, 2, 3], 
                  [4, 5, 6]])
print("=== 初始张量 ===")
print("是否连续：", x.is_contiguous())  # True
print("内存步长（stride）：", x.stride())  # (3, 1) → 行步长3，列步长1（连续特征）

# 2. 转置操作：变为非连续
x_trans = x.transpose(0, 1)
print("\n=== 转置后张量 ===")
print("是否连续：", x_trans.is_contiguous())  # False
print("内存步长（stride）：", x_trans.stride())  # (1, 3) → 行步长1，列步长3（非连续特征）
# x_trans.view(-1)  # 直接view会报错！

# 3. 先检测，再决定是否调用contiguous()（最佳实践）
if not x_trans.is_contiguous():
    x_trans_contig = x_trans.contiguous()
    print("\n=== contiguous() 后 ===")
    print("是否连续：", x_trans_contig.is_contiguous())  # True
    print("view展平结果：", x_trans_contig.view(-1))  # [1,4,2,5,3,6]

# 4. 其他触发非连续的操作 + 检测
# 场景1：切片操作
x_slice = x[:, ::2]  # 隔列取数
print("\n=== 切片后张量 ===")
print("是否连续：", x_slice.is_contiguous())  # False

# 场景2：permute（多维度交换）
x_3d = torch.randn(2, 3, 4)
x_permute = x_3d.permute(0, 2, 1)  # 交换维度1和2
print("\n=== permute后3维张量 ===")
print("是否连续：", x_permute.is_contiguous())  # False

# 场景3：clone() 后的张量（始终连续）
x_clone = x_trans.clone()
print("\n=== clone() 后张量 ===")
print("是否连续：", x_clone.is_contiguous())  # True

原理：从“步长（stride）”理解连续

.is_contiguous() 的判断本质是检查张量的步长（stride） 是否符合“连续规则”：

  • 步长（stride）：表示遍历张量时，每跳过一个维度需要移动的内存字节数（x.stride() 返回元组，对应每个维度的步长）；
  • 连续张量的步长规则：对于 N 维张量，第 i 维的步长 = 第 i+1 维的步长 × 第 i+1 维的大小（如 [2,3] 的连续张量，步长 (3,1)，满足 3 = 1×3）；
  • 非连续张量：步长不满足上述规则（如转置后的 [3,2] 张量，步长 (1,3)，1 ≠ 3×2）。

简单来说：.is_contiguous() 就是验证张量的步长是否符合“行优先连续”的数学规则。

实用场景：什么时候用 .is_contiguous()？

这个方法主要用于条件判断，避免无意义的 .contiguous() 调用（连续张量调用 .contiguous() 虽无错，但会多一次“判断+返回自身”的开销），最佳实践如下：

调用 .view() 前的前置检测

def safe_view(tensor, new_shape):
    """安全的view操作：先检测连续性，再view"""
    if not tensor.is_contiguous():
        tensor = tensor.contiguous()
    return tensor.view(new_shape)

# 测试
x_trans = x.transpose(0,1)
x_safe = safe_view(x_trans, -1)  # 先contiguous再view，不报错

高性能计算前的优化

非连续张量的内存访问效率低，在大规模计算（如大模型推理）前检测并整理：

def optimize_tensor(tensor):
    """优化张量内存布局"""
    if not tensor.is_contiguous():
        tensor = tensor.contiguous()
        print("张量已整理为连续，提升计算效率")
    return tensor

# 大张量计算前优化
big_tensor = torch.randn(1024, 1024).transpose(0,1)
big_tensor = optimize_tensor(big_tensor)  # 整理为连续后再计算

调试/日志输出

排查内存相关报错时，打印 .is_contiguous() 的结果，快速定位问题：

# 调试时输出张量状态
def debug_tensor(tensor, name):
    print(f"张量 {name}：形状={tensor.shape}，连续={tensor.is_contiguous()}")

debug_tensor(x_trans, "转置后的张量")  # 快速发现非连续问题

注意事项

  1. .is_contiguous() 无副作用：仅返回布尔值，不修改张量、不分配内存，可放心调用；
  2. .clone() 后的张量始终连续：无论原张量是否连续，.clone() 都会创建连续的内存副本；
  3. .detach() 不改变连续性：仅分离梯度，内存布局保持不变；
  4. CUDA张量同样适用：该方法对CPU/GPU张量都有效，判断逻辑一致。

总结

  1. .is_contiguous() 是检测张量内存是否连续的轻量方法，返回 True/False，无任何副作用；
  2. 核心判断依据是张量的“步长（stride）”是否符合连续规则，转置、切片、permute等操作会导致非连续；
  3. 最佳实践：调用 .view() 前先用 .is_contiguous() 检测，仅在非连续时调用 .contiguous()，既避免报错又提升效率。

原文出处：/show_1GW2dNEzcQx9.html

吉ICP备15003043号