当前位置：首页 > news >正文

PyTorch 中，Tensor view、reshape、 permute、transpose 接口是什么，有什么区别和联系？

news 2026/4/26 12:11:06

PyTorch 中，Tensor view、reshape、 permute、transpose 接口是什么，有什么区别和联系？

PyTorch 中，Tensor view、reshape、 permute、transpose 接口是什么，有什么区别和联系？
- 一、官方文档说明
  - 1、Tensor.view(*shape) → Tensor
  - 2、torch.reshape(input, shape) → Tensor
  - 3、Tensor.permute(*dims) → Tensor
    - Tensor.T
  - 4、torch.transpose
    - torch.Tensor.transpose
    - torch.Tensor.transpose_
    - Tensor.H
    - Tensor.mT
- 二、以《 PyTorch 深度学习实战》书中示例为例
  - 1、 .view()
  - 2、 .reshape()
  - 🆚 对比 view 与 reshape
  - 3、 .transpose()
  - 4、 .permute()
  - 🆚 对比 transpose 与 permute
- 三、对比表

一、官方文档说明

1、Tensor.view(*shape) → Tensor

返回一个与 self 张量数据相同但 shape（形状）不同的新张量。

返回的张量与原张量共享相同的数据，且必须具有相同数量的元素，但大小（size）可能不同。若要对张量进行 view 操作，新的视图大小必须与其原始大小和步幅（stride）兼容，即：每个新的视图维度要么是原始维度的一个子空间，要么仅跨越满足以下类连续性（contiguity-like）条件的原始维度 \(d, d+1, \ldots, d+k\)，即对于 \(\forall i = d, \ldots, d+k-1\) ：

\[stride[i]=stride[i+1]×size[i+1] \]

否则，将无法在不复制（例如通过 contiguous()）的情况下将 self 张量视为 shape。当不确定是否可以执行 view() 时，建议使用 reshape()，它在形状兼容时返回视图，否则返回副本（相当于调用 contiguous()）。

参数:

shape (torch.Size 或 int...) – 所需的大小

2、torch.reshape(input, shape) → Tensor

返回一个张量，该张量与 input 具有相同的数据和元素数量，但形状不同。在可能的情况下，返回的张量将是 input 的视图。否则，它将是一个副本。连续的输入和具有兼容步幅的输入可以在不复制的情况下进行重塑，但您不应依赖于复制与视图的行为。

请参阅 torch.Tensor.view() 了解何时可以返回视图。

单个维度可以是 -1，在这种情况下，它会根据其余维度和 input 中的元素数量推断出来。

参数:

input (Tensor) – 要重塑的张量
shape (tuple of int) – 新的形状

3、Tensor.permute(*dims) → Tensor

返回一个视图，其张量维度已重新排列。

参数:

dims (torch.Size, int...__, tuple of int or list of int) – 所需的维度顺序。

Tensor.T

返回此张量维数反转后的视图。

如果 n 是 x 的维数，则 x.T 等价于 x.permute(n-1, n-2, ..., 0)。

警告：
在维度不为 2 的张量上使用 Tensor.T() 来反转形状的做法已被弃用，在未来版本中将抛出错误。对于矩阵批次的转置，请考虑使用 mT；要反转张量的维度，请使用 x.permute(*torch.arange(x.ndim - 1, -1, -1))。

4、torch.transpose

torch.transpose(input, dim0, dim1) → Tensor

返回一个 input 的转置张量。给定的维度 dim0 和 dim1 将被交换。

如果 input 是一个步幅张量（strided tensor），那么结果张量 out 将与 input 张量共享底层存储，因此改变其中一个的内容也会改变另一个的内容。

如果 input 是一个稀疏张量，那么结果张量 out 不会与 input 张量共享底层存储。

如果 input 是具有压缩布局（SparseCSR, SparseBSR, SparseCSC 或 SparseBSC）的稀疏张量，则参数 dim0 和 dim1 必须同时为批次维度，或者必须同时为稀疏维度。稀疏张量的批次维度是指位于稀疏维度之前的维度。

注意：
交换 SparseCSR 或 SparseCSC 布局张量的稀疏维度的转置操作，将导致布局在这两种选项之间切换。同样，对 SparseBSR 或 SparseBSC 布局张量的稀疏维度进行转置，也会产生具有相反布局的结果。

参数:

input (Tensor) – 输入张量。
dim0 (int) – 要转置的第一个维度
dim1 (int) – 要转置的第二个维度

torch.Tensor.transpose

Tensor.transpose(dim0, dim1) → Tensor

请参阅 torch.transpose()。

torch.Tensor.transpose_

Tensor.transpose_(dim0, dim1) → Tensor

transpose() 的就地版本。

Tensor.H

返回矩阵（二维张量）共轭转置后的视图。

对于复数矩阵，x.H 等价于 x.transpose(0, 1).conj()；对于实数矩阵，等价于 x.transpose(0, 1)。

Tensor.mT

返回此张量最后两个维度转置后的视图。

x.mT 等价于 x.transpose(-2, -1)。

二、以《 PyTorch 深度学习实战》书中示例为例

第四章 4.4.2 按时间段调整数据

将 [17520, 17] 形状（小时数、特征数）的二维数据转换为 [730, 24, 17] 形状（天数 × 每天小时数 × 特征数）的三维数据。

# 原始数据形状
>>> bikes.shape, bikes.stride()
(torch.Size([17520, 17]), (17, 1))

1、 .view()

# 将数据重塑为按天组织的三维张量
>>> daily_bikes = bikes.view(-1, 24, bikes.shape[1])  
>>> daily_bikes.shape, daily_bikes.stride()
(torch.Size([730, 24, 17]), (408, 17, 1))

-1 表示自动计算该维度的大小，即：17520 ÷ 24 = 730
24 ：每天 24 小时
bikes.shape[1] 表示第二个维度的大小，即特征数量，值为 17

变换过程：

使用 .view(-1, 24, bikes.shape[1]) 进行重塑
新形状：[730, 24, 17] （天数 × 每天小时数 × 特征数）

步幅变化：

原来：(17, 1) → 按行和列访问
现在：(408, 17, 1) →
- 访问下一天：跳过 408 个元素（24小时×17特征=408）
- 访问下一小时：跳过 17 个元素
- 访问下一特征：跳过 1 个元素

2、 .reshape()

对于上段代码中的具体情况，由于 bikes 张量是新创建的连续张量，所以 view() 和 reshape() 会产生相同的结果。
虽然在功能上等价，但在内存、性能等方面存在差异。
但在实践中，如果不确定张量的连续性，使用 reshape() 更安全。

🆚 对比 `view` 与 `reshape`

特性	`view`	`reshape`
内存要求	要求步幅兼容（通常需连续）	自动处理非连续
行为	直接处理	优先用 view，必要时复制数据
性能	稍快（无检查）	稍慢（多了检查逻辑）
安全性	可能报错	更安全

reshape = view + 自动连续性处理

对于不确定张量是否连续的情况，始终使用 reshape
reshape 是官方推荐的主流 API
view 在性能敏感的代码中（确认连续时）可以使用

3、 .transpose()

转置维度以改变数据布局。

>>> daily_bikes = daily_bikes.transpose(1, 2)  
>>> daily_bikes.shape, daily_bikes.stride()
(torch.Size([730, 17, 24]), (408, 1, 17))

转置操作：

transpose(1, 2) 交换第1维（小时数，24）和第2维（特征数，17）
原形状：[730, 24, 17] （天，小时，特征）
新形状：[730, 17, 24] （天，特征，小时）

步幅再次变化：

之前：(408, 17, 1) → (天间距, 小时间距, 特征间距)
之后：(408, 1, 17) → (天间距, 特征间距, 小时间距)
这样可以更方便地按特征访问时间序列数据

4、 .permute()

对于上段代码中的具体情况， permute() 和 transpose() 可以产生相同的结果，但需要写出完整的维度。

>>> daily_bikes = daily_bikes.permute(0, 2, 1)

🆚 对比 `transpose` 与 `permute`

特性	`transpose`	`permute`
功能	交换指定的两个维度	按任意顺序重排所有维度
参数	`dim0, dim1`（两个维度）	`*dims`（完整的维度排列）
维度数量	只能交换一对维度	可以一次性重排所有维度
灵活性	较低，仅限两个维度互换	极高，支持任意维度置换
返回结果	视图（共享数据，不复制）	视图（共享数据，不复制）
别名/简写	`x.T`、`x.mT`、`x.H` 等	无直接别名，但 `x.T` 相当于二维张量的 `permute(1,0)`
多次交换	多次调用可复合，但会产生中间视图	一步到位，代码更简洁、语义更清晰
适用场景	简单转置，如：矩阵转置、最后两维交换	复杂维度重排，如：`(N,C,H,W)` → `(N,H,W,C)`

两者的关系：
transpose(dim0, dim1) 实际上是 permute 的一个特例。

例如，对于三维张量 x：

x.transpose(0, 1) 等价于 x.permute(1, 0, 2)
x.transpose(1, 2) 等价于 x.permute(0, 2, 1)

因此，当只需要交换两个维度时，transpose 写起来更简单；如果需要同时改变多个维度的顺序，permute 是唯一选择。
从“显式优于隐式”的角度，使用 permute 能够更清晰地表达“所有维度最终变成什么顺序”，可读性往往更好。

性能说明：
二者均返回视图，不复制底层数据，仅改变张量的 stride 和 shape，速度极快，且均不要求张量连续。在实际使用中，性能几乎没有差异。

三、对比表

方法	功能	连续性要求	适用场景
`view`	改变形状	要求步幅兼容（通常需连续）	已知连续的小心使用
`reshape`	改变形状	自动处理	日常首选
`transpose`	交换两维度	不需要	交换两个维度
`permute`	重排所有维度	不需要	任意维度重排