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

# 介绍

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

### 作用

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

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

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

# 语法

```
Tensor.is_contiguous() → bool
```

# 例子

```python
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() 前的前置检测
```python
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，不报错
```

### 高性能计算前的优化

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

```python
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()` 的结果，快速定位问题：
```python
# 调试时输出张量状态
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()`，既避免报错又提升效率。

原文出处：http://malaoshi.top/show_1GW2dNEzcQx9.html