pytorch 1 张量

张量

Tensor主要有以下八个主要属性，data，dtype，shape，device，grad，grad_fn，is_leaf，requires_grad。

torch.Tensor 的 主要属性

1. data:

   • 包含张量的原始数据，不包含梯度信息。
   • 如果你不关心梯度，只关心张量的数据本身，可以通过 tensor.data 访问。

2. dtype:

   • 张量的数据类型，如 torch.float32、torch.int64 等。
   • 可以通过 tensor.dtype 查看或指定张量的数据类型。

3. shape:

   • 张量的形状（也称为尺寸），表示每个维度的大小。
   • 可以通过 tensor.shape 或 tensor.size() 获取。

4. device:

   • 表示张量所在的设备，如 cpu 或 cuda:0（第一个GPU）。
   • 可以通过 tensor.device 获取张量所在的设备。

5. requires_grad:

   • 如果 True，表示张量需要计算梯度，在反向传播时会记录操作以便计算梯度。
   • 可以通过 tensor.requires_grad 设置或检查。

6. grad:

   • 存储与张量关联的梯度信息，在反向传播之后会填充该值。
   • 可以通过 tensor.grad 访问，通常用于更新模型参数。

7. grad_fn:

   • 记录创建张量的 Function（函数），是创建该张量的操作的历史。
   • 对于叶子节点张量（is_leaf=True），grad_fn 为 None，因为它们不是通过某个操作计算得到的。

8. is_leaf:

   • 如果张量是计算图中的叶子节点，则 is_leaf=True。
   • 通常，叶子节点是由用户创建的，且 requires_grad=True，没有使用运算符对它们进行进一步的计算。

torch.Tensor 的 其他常用属性和方法

1. ndim:

   • 返回张量的维度数（即张量的秩）。

2. T:

   • 返回张量的转置（对于2D张量来说，相当于矩阵转置）。

3. numel():

   • 返回张量中元素的总数。

4. stride():

   • 返回张量在每个维度上的步长。

5. storage():

   • 返回底层存储对象。

6. contiguous():

   • 返回一个内存连续的相同张量。如果张量在内存中不是连续的，这个方法会返回一个连续的副本。

7. to(device):

   • 将张量移动到指定设备（如 CPU 或 GPU）。

8. detach():

   • 创建一个与当前计算图分离的新张量，不会参与梯度计算。

9. clone():

   • 创建张量的深拷贝。

10. item():

    • 对于单元素张量，返回其 Python 标量值。

11. numpy():

    • 将张量转换为 NumPy 数组（仅在张量位于 CPU 上时可用）。

12. size():

    • 返回张量的形状（等同于 shape）。

13. view() 或 reshape():

    • 改变张量的形状，view() 要求张量的内存是连续的，而 reshape() 则不需要。

14. squeeze() 和 unsqueeze():

    • squeeze() 移除张量中所有大小为1的维度。
    • unsqueeze() 在指定位置插入一个大小为1的新维度。

15. cpu() 和 cuda():

    • cpu() 将张量移动到 CPU。
    • cuda() 将张量移动到 GPU。

16. backward():

    • 计算梯度，通常在损失张量上调用。

17. retain_grad():

    • 对非叶节点也保留梯度（默认情况下，只有叶节点的梯度被保留）。

18. register_hook():

    • 注册一个反向传播的钩子函数，在计算梯度时调用，可以用于调试或修改梯度。

以下是关于 PyTorch 中 叶子张量 和 中间计算结果 的整理总结。

叶子张量（Leaf Tensors）

定义

在 PyTorch 的自动求导机制中，叶子张量 是计算图中的最基础的节点（或源节点），它们通常由用户直接创建，并且不会通过任何操作进一步派生出新的张量。

• 叶子张量: 是计算图中不依赖其他张量的张量。通常是通过直接创建张量的操作（例如 torch.tensor()、torch.randn() 等）生成的。叶子张量通常代表模型的输入数据或参数。

叶子张量的约定

“All Tensors that have requires_grad which is False will be leaf Tensors by convention.”

这句话的意思是：

按照惯例，所有 requires_grad=False 的张量都被视为叶子张量。

深入理解

1. 叶子张量（Leaf Tensors）：

   • 在 PyTorch 的计算图中，叶子张量是那些不是由其他张量通过操作创建的张量。
   • 它们通常是直接创建的或者是模型的参数。

2. requires_grad：

   • 这个属性表示是否需要为该张量计算梯度。
   • 当 requires_grad=True 时，PyTorch 会跟踪对该张量的所有操作，以便后续进行自动微分。

3. 约定（Convention）：

   • 这是 PyTorch 的一个设计决定，不是技术上的必然结果，但它简化了计算图的管理和梯度计算。

示例代码

import torch

# 创建 requires_grad=False 的张量（叶子节点）
x = torch.randn(3)
print("x is leaf:", x.is_leaf)  # True
print("x requires grad:", x.requires_grad)  # False

# 创建 requires_grad=True 的张量（也是叶子节点）
y = torch.randn(3, requires_grad=True)
print("y is leaf:", y.is_leaf)  # True
print("y requires grad:", y.requires_grad)  # True

# 进行操作，创建非叶子节点
z = x + y
print("z is leaf:", z.is_leaf)  # False
print("z requires grad:", z.requires_grad)  # True

# 使用 detach() 创建新的叶子节点
w = z.detach()
print("w is leaf:", w.is_leaf)  # True
print("w requires grad:", w.requires_grad)  # False

总结

• 叶子张量: 通常是由用户直接创建的，不依赖其他张量。默认情况下，requires_grad=False 的张量会被视为叶子张量。
• 非叶子张量: 是通过其他张量的操作生成的，requires_grad=True 的张量，如果不是直接创建的张量，而是通过计算生成的，则不是叶子张量。

中间计算结果与 detach() 方法

定义

中间计算结果 是通过对叶子张量进行操作生成的张量。它们通常不是叶子张量，除非使用 detach() 方法将它们从计算图中分离出来。

中间计算结果不是叶子节点

当我们对叶子张量进行操作时，生成的中间计算结果会被记录在计算图中。这些结果通常是非叶子张量，因为它们依赖于前面的操作和张量。

使用 detach() 方法使中间结果成为叶子张量

如果你希望将一个中间计算结果从计算图中分离出来，使其成为叶子张量，可以使用 detach() 方法。detach() 方法返回一个新的张量，与原始张量共享数据，但不会记录在计算图中，因此不会参与梯度计算。

示例代码

import torch

# 创建叶子张量
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 对叶子张量进行操作，生成非叶子张量
y = x + 2

# 使用 detach() 使 y_detach 成为叶子张量
y_detach = y.detach()

print("y is leaf:", y.is_leaf)            # False
print("y_detach is leaf:", y_detach.is_leaf)  # True

# 检查 y_detach 是否记录计算历史
print("y requires grad:", y.requires_grad)  # True
print("y_detach requires grad:", y_detach.requires_grad)  # False

实际应用

使用 detach() 有多个应用场景：

• 冻结模型的一部分：在训练时冻结某些层的参数，防止这些参数的梯度被计算和更新。
• 防止梯度传播：在反向传播中，有时希望切断某些部分的梯度传播，可以使用 detach()。
• 生成中间结果用于其他目的：例如在某些自定义损失函数或正则化过程中，需要从计算图中提取中间结果。

总结

• 中间计算结果通常不是叶子节点：因为它们依赖于前面的操作和张量。
• detach() 方法：可以将中间结果从计算图中分离出来，使其成为叶子张量，并且不再计算梯度。

关于 requires_grad 的说明

• 如果一个张量的 requires_grad=False，意味着我们不需要对其计算梯度。在大多数情况下，这样的张量是叶子张量。
• 反之，如果一个张量的 requires_grad=True，并且是通过其他张量的操作生成的（比如 a = b + c，其中 b.requires_grad=True），那么 a 不是叶子张量，因为它是通过操作生成的，依赖于 b 和 c。

例子

import torch

# 直接创建的张量，requires_grad=False，因此是叶子张量
x = torch.tensor([1.0, 2.0, 3.0])
print("x is leaf:", x.is_leaf)  # True

# 直接创建的张量，requires_grad=True，因此是叶子张量
y = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
print("y is leaf:", y.is_leaf)  # True

# 通过操作创建的张量，requires_grad=True，因此不是叶子张量
z = y + 2
print("z is leaf:", z.is_leaf)  # False

# 使用 detach 创建的张量，requires_grad=False，是叶子张量
z_detach = z.detach()
print("z_detach is leaf:", z_detach.is_leaf)  # True

直接创建张量的操作

当然！下面是一个表格，列出了常见的用于直接创建张量的 PyTorch 函数和方法。每个方法都会创建一个新的张量，默认情况下，这些张量的 requires_grad=False，并且它们是计算图中的叶子节点。

解释与应用

• 直接创建张量: 这些方法创建的张量通常作为计算图中的叶子节点，因为它们是由用户直接定义的。除非显式指定 requires_grad=True，否则它们不会参与梯度计算。

• 典型用例:

  • torch.zeros() 和 torch.ones() 常用于初始化模型参数。
  • torch.randn() 和 torch.rand() 常用于生成随机初始化的张量，用于神经网络的权重初始化等。
  • torch.eye() 常用于生成单位矩阵，用于线性代数计算。
  • torch.from_numpy() 常用于将现有的 NumPy 数据转换为 PyTorch 张量。

梯度 requires_grad

关于张量是否计算梯度

这是一个很好的问题！PyTorch 中 requires_grad 的默认值取决于张量的创建方式和上下文。让我们详细探讨一下：

1. 基本规则：

   • 对于大多数通过 PyTorch 操作创建的新张量，默认 requires_grad=False。
   • 对于通过涉及至少一个 requires_grad=True 的张量的操作创建的新张量，默认 requires_grad=True。

2. 常见情况：

   a) 使用 PyTorch 函数直接创建的张量：

   x = torch.ones(5)  # 默认 requires_grad=False
   y = torch.randn(3)  # 默认 requires_grad=False
   

   b) 从 NumPy 数组创建的张量：

   import numpy as np
   a = np.array([1, 2, 3])
   x = torch.from_numpy(a)  # 默认 requires_grad=False
   

   c) 通过操作已有张量创建的新张量：

   x = torch.ones(5)
   y = x + 2  # 如果 x.requires_grad=False，则 y.requires_grad=False
   

   d) 模型参数：

   import torch.nn as nn
   model = nn.Linear(10, 5)
   # model.weight 和 model.bias 默认 requires_grad=True
   

3. 特殊情况：

   a) 使用 torch.tensor() 创建张量时：

   x = torch.tensor([1, 2, 3])  # 默认 requires_grad=False
   y = torch.tensor([1, 2, 3], requires_grad=True)  # 显式设置为 True
   

   b) 在 torch.no_grad() 上下文中：

   with torch.no_grad():
       x = torch.ones(5)  # 即使显式设置，也会是 False
       y = torch.ones(5, requires_grad=True)  # 仍然是 True，但梯度不会被跟踪
   

让我们通过一个例子来演示这些规则：

import torch
import torch.nn as nn

# 基本张量创建
x = torch.ones(5)
print("1. torch.ones():", x.requires_grad)

# 使用 torch.tensor()
y = torch.tensor([1, 2, 3])
print("2. torch.tensor():", y.requires_grad)

# 操作现有张量
z = x + y
print("3. 操作现有张量:", z.requires_grad)

# 至少一个输入 requires_grad=True
x.requires_grad_(True)
w = x + y
print("4. 至少一个输入 requires_grad=True:", w.requires_grad)

# 模型参数
model = nn.Linear(5, 3)
print("5. 模型参数 (weight):", model.weight.requires_grad)
print("   模型参数 (bias):", model.bias.requires_grad)

# torch.no_grad() 上下文
with torch.no_grad():
    a = torch.ones(5)
    b = torch.ones(5, requires_grad=True)
    print("6. torch.no_grad() 中创建:", a.requires_grad)
    print("   torch.no_grad() 中显式设置 True:", b.requires_grad)

# 检查 torch.no_grad() 对梯度跟踪的影响
c = x * 2
with torch.no_grad():
    d = x * 2
print("7. 正常操作:", c.requires_grad)
print("   torch.no_grad() 中的操作:", d.requires_grad)

这个示例展示了不同情况下 requires_grad 的默认行为。运行这段代码，你会看到：

1. 基本张量创建默认为 False。
2. 使用 torch.tensor() 创建的张量默认为 False。
3. 操作不需要梯度的张量得到的新张量默认为 False。
4. 如果操作中至少有一个输入需要梯度，结果张量默认为 True。
5. 模型参数默认为 True。
6. 在 torch.no_grad() 上下文中，新创建的张量仍遵循默认规则，但不会跟踪计算图。
7. torch.no_grad() 会暂时阻止梯度跟踪，即使操作涉及 requires_grad=True 的张量。

理解这些默认行为很重要，因为它们影响：

• 计算图的构建
• 内存使用
• 反向传播过程

在实际应用中：

• 对于模型参数，通常保持默认的 requires_grad=True。
• 对于输入数据，通常保持默认的 requires_grad=False。
• 在需要冻结某些参数或部分模型时，可以手动设置 requires_grad=False。
• 使用 torch.no_grad() 来临时禁用梯度计算，通常用于推理或评估阶段。

是否开启梯度计算

要查看一个 PyTorch 张量是否开启了梯度计算，有几种方法。我来为您详细介绍这些方法，并提供一些实用的例子。

import torch

# 创建几个不同的张量用于演示
x = torch.randn(3, requires_grad=True)
y = torch.zeros(3)
z = x * 2

print("1. 使用 .requires_grad 属性:")
print("x.requires_grad:", x.requires_grad)
print("y.requires_grad:", y.requires_grad)
print("z.requires_grad:", z.requires_grad)

print("\n2. 使用 .is_leaf 属性:")
print("x.is_leaf:", x.is_leaf)
print("y.is_leaf:", y.is_leaf)
print("z.is_leaf:", z.is_leaf)

print("\n3. 检查 .grad_fn 属性:")
print("x.grad_fn:", x.grad_fn)
print("y.grad_fn:", y.grad_fn)
print("z.grad_fn:", z.grad_fn)

print("\n4. 使用 torch.is_grad_enabled() 函数:")
print("全局梯度计算状态:", torch.is_grad_enabled())

print("\n5. 在 torch.no_grad() 上下文中:")
with torch.no_grad():
    w = x * 2
    print("w.requires_grad:", w.requires_grad)
    print("torch.is_grad_enabled():", torch.is_grad_enabled())

print("\n6. 使用 .detach() 方法:")
v = x.detach()
print("v.requires_grad:", v.requires_grad)

print("\n7. 检查 .grad 属性:")
print("x.grad:", x.grad)  # 在反向传播之前为 None
x.sum().backward()
print("反向传播后 x.grad:", x.grad)

让我解释一下这些方法：

1. 使用 .requires_grad 属性：

   • 这是最直接的方法。
   • 如果为 True，表示张量需要梯度计算。

2. 使用 .is_leaf 属性：

   • 叶子节点通常是需要梯度的张量。
   • 但注意，并非所有 requires_grad=True 的张量都是叶子节点。

3. 检查 .grad_fn 属性：

   • 如果张量有 grad_fn，说明它是由某个操作创建的，并且可能参与梯度计算。
   • 叶子节点（如直接创建的张量）的 grad_fn 为 None。

4. 使用 torch.is_grad_enabled() 函数：

   • 这会检查全局的梯度计算状态。
   • 在 torch.no_grad() 上下文中，这会返回 False。

5. 在 torch.no_grad() 上下文中：

   • 这个上下文管理器临时禁用梯度计算。
   • 在此上下文中创建的张量默认 requires_grad=False。

6. 使用 .detach() 方法：

   • 这会创建一个与原张量共享数据但不需要梯度的新张量。

7. 检查 .grad 属性：

   • 只有需要梯度的叶子节点在反向传播后才会有 .grad 属性。
   • 在反向传播之前，即使 requires_grad=True，.grad 也是 None。

重要说明：

• requires_grad=True 不意味着张量当前正在跟踪梯度，只是表示它有能力跟踪梯度。
• 在 torch.no_grad() 上下文中，即使 requires_grad=True 的张量也不会跟踪梯度。
• 非叶子节点（由操作创建的张量）通常不存储梯度，除非使用 retain_grad()。

在实际应用中：

• 对于模型参数，通常会看到 requires_grad=True。
• 对于输入数据，通常 requires_grad=False。
• 在模型评估或推理阶段，经常使用 torch.no_grad() 来提高效率。

reshape/view

PyTorch 中的 reshape 和 view 方法。这两个方法都用于改变张量的形状，但它们在某些情况下有细微的区别。我们来详细解释一下：

1. x.view()

view 方法返回一个新的张量，其数据与原张量共享内存，但具有不同的形状。

特点：

• 更快，因为它不会复制数据。
• 要求张量是连续的（contiguous）。
• 如果张量不是连续的，会抛出错误。

2. x.reshape()

reshape 方法也返回一个新形状的张量，但它更灵活。

特点：

• 可以处理非连续的张量。
• 如果可能，它会返回一个视图（view）。
• 如果不可能返回视图，它会返回一个副本。

让我们通过一些例子来说明：

import torch

# 创建一个简单的张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
print("原始张量 x:")
print(x)
print("x 的形状:", x.shape)

# 使用 view
y = x.view(3, 2)
print("\n使用 view 后的张量 y:")
print(y)
print("y 的形状:", y.shape)

# 使用 reshape
z = x.reshape(3, 2)
print("\n使用 reshape 后的张量 z:")
print(z)
print("z 的形状:", z.shape)

# 创建一个非连续的张量
a = torch.tensor([[1, 2, 3],
                  [4, 5, 6]]).t()  # 转置使其非连续
print("\n非连续张量 a:")
print(a)
print("a 是否连续:", a.is_contiguous())

# 尝试使用 view（这会引发错误）
try:
    b = a.view(3, 2)
except RuntimeError as e:
    print("\n使用 view 时的错误:")
    print(e)

# 使用 reshape（这会成功）
c = a.reshape(3, 2)
print("\n使用 reshape 后的张量 c:")
print(c)
print("c 的形状:", c.shape)

这个例子展示了 view 和 reshape 的主要区别：

1. 对于连续的张量，view 和 reshape 的行为是相同的。
2. 对于非连续的张量，view 会失败，而 reshape 会成功（通过创建一个新的张量副本）。

在实践中：

• 如果你确定张量是连续的，使用 view 可能会稍微快一些。
• 如果你不确定张量是否连续，或者你希望代码更加健壮，使用 reshape 是更安全的选择。

总的来说，reshape 更加通用和安全，而 view 在特定情况下可能会有轻微的性能优势。在大多数情况下，使用 reshape 是个不错的选择，因为它能够处理更多的情况，并且性能差异通常是微不足道的。

张量连续的概念

很好的问题！让我们深入探讨一下张量的连续性概念。

张量的连续性（contiguity）是指张量在内存中的存储方式。这个概念对于理解某些 PyTorch 操作的行为和性能很重要。

1. 连续的张量（Contiguous Tensor）：

   • 在内存中以一个连续的块存储。
   • 元素的存储顺序与它们的访问顺序一致。
   • 可以直接用 view() 改变形状而不需要复制数据。

2. 非连续的张量（Non-contiguous Tensor）：

   • 在内存中的存储可能是分散的或者顺序与访问顺序不一致。
   • 通常是某些操作（如转置、切片等）的结果。
   • 使用 view() 会引发错误，需要先调用 contiguous() 或使用 reshape()。

让我们通过一些例子来说明这个概念：

import torch

# 创建一个连续的张量
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
print("原始张量 x:")
print(x)
print("x 是否连续:", x.is_contiguous())

# 创建一个非连续的张量（通过转置）
y = x.t()
print("\n转置后的张量 y:")
print(y)
print("y 是否连续:", y.is_contiguous())

# 尝试对非连续张量使用 view
try:
    z = y.view(6)
except RuntimeError as e:
    print("\n对非连续张量使用 view 的错误:")
    print(e)

# 使用 contiguous() 使张量变为连续
y_cont = y.contiguous()
print("\n使用 contiguous() 后的张量 y_cont:")
print(y_cont)
print("y_cont 是否连续:", y_cont.is_contiguous())

# 现在可以使用 view 了
z = y_cont.view(6)
print("\n对连续张量使用 view 的结果 z:")
print(z)

# 使用 reshape 可以直接处理非连续张量
w = y.reshape(6)
print("\n对非连续张量使用 reshape 的结果 w:")
print(w)

解释：

1. 原始张量 x 是连续的。

2. 转置操作 x.t() 创建了一个非连续的张量 y。这是因为转置改变了元素的访问顺序，但没有改变它们在内存中的实际存储顺序。

3. 当我们尝试对非连续张量 y 使用 view() 时，PyTorch 抛出了一个错误。这是因为 view() 需要张量是连续的。

4. 我们可以使用 contiguous() 方法创建一个新的连续张量 y_cont。这个操作会在内存中重新排列元素。

5. 对连续的 y_cont 使用 view() 是可以的。

6. reshape() 方法可以直接处理非连续的张量，它会在内部自动调用 contiguous() 如果需要的话。

实际应用中的影响：

1. 性能：连续的张量通常可以更快地进行某些操作，因为数据在内存中是连续的。

2. 内存使用：contiguous() 操作可能会创建一个新的张量副本，这会增加内存使用。

3. 某些操作的要求：一些 PyTorch 操作（如 view()）要求张量是连续的。

4. CUDA 操作：在 GPU 上，使用连续的张量通常会有更好的性能。

参考

1. https://pytorch.org/docs/stable/tensors.html
2. https://tingsongyu.github.io/PyTorch-Tutorial-2nd/chapter-2/2.3-datastruct-tensor.html
3. https://pytorch.org/tutorials/beginner/introyt/autogradyt_tutorial.html
4. https://pytorch.org/docs/stable/notes/autograd.html