【机器学习】-torch相关知识01

学习代码时遇到的问题,GPT给的答案,如有错误请指出。

问题1 torch.empty nn.init.xavier

问题2 nn.Parameter 是什么?

问题3 self.add_module

问题4 torch.matmul torch.mm

文章目录

    • [问题1 torch.empty nn.init.xavier](#问题1 torch.empty nn.init.xavier)
    • [问题2 `nn.Parameter` 是什么?](#问题2 nn.Parameter 是什么?)
    • [问题3 self.add_module](#问题3 self.add_module)
    • [问题4 `torch.matmul` `torch.mm`](#问题4 torch.matmul torch.mm)

问题1 torch.empty nn.init.xavier

在 PyTorch 里:

python 复制代码
self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))

这里的 torch.empty 并不是"空的"的意思,而是 创建一个未初始化的张量

  • torch.empty(shape) 会直接分配一块内存,但 不对数值做初始化
  • 里面的值通常是内存里的随机数(垃圾值)
  • 一般会 马上再用 nn.init(比如 xavier_uniform_)去初始化
python 复制代码
self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))
nn.init.xavier_uniform_(self.W.data, gain=1.414)

解释:

  1. torch.empty(...):先申请一个形状为 (in_features, out_features) 的张量,里面值是随机的垃圾值。
  2. nn.init.xavier_uniform_:再用 Xavier 初始化self.W 的值设成合理的初始权重。

🔹 举个例子

python 复制代码
x = torch.empty(2, 3)
print(x)

可能输出:

复制代码
tensor([[ 4.5908e-41,  0.0000e+00, -1.8754e+38],
        [ 1.4013e-45,  0.0000e+00,  2.8026e-45]])

⚠️ 这些值是 内存里原本的残留值 ,完全没意义。

所以我们几乎总是 立刻再初始化

📌 总结一句:
torch.empty = 只开辟空间,不赋值(可能是内存垃圾值)。

这里用它的原因是:要立刻用 xavier_uniform_ 来做权重初始化。

  • nn.init.xavier_uniform_:Xavier 初始化方法(又叫 Glorot 初始化)
  • self.W.data :表示直接访问 Parameter 的底层 Tensor 数据(绕过 autograd 的计算图)
  • gain=1.414 :一个缩放系数(通常是根据激活函数来设定),这里取 2 \sqrt{2} 2 ,适合 ReLU / ELU 激活

🔹 Xavier 初始化的原理

在神经网络训练中,如果权重初始化得不好,可能会出现:

  • 前向传播时数值逐层变得很大或很小
  • 反向传播时梯度消失或爆炸

Xavier 初始化的目标是:

让每一层输入和输出的方差尽量保持一致,避免数值逐层放大/缩小。

公式(均匀分布版):

W i j ∼ U ( − 6 fan_in + fan_out ⋅ gain ,    6 fan_in + fan_out ⋅ gain ) W_{ij} \sim U\Bigg(-\sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}} \cdot \text{gain}, \; \sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}} \cdot \text{gain}\Bigg) Wij∼U(−fan_in+fan_out6 ⋅gain,fan_in+fan_out6 ⋅gain)

其中:

  • fan_in = 输入维度
  • fan_out = 输出维度
  • gain = 缩放系数(跟激活函数有关)

🔹 为什么 gain=1.414

  • PyTorch 里可以用 nn.init.calculate_gain('relu') 得到对应的 gain
  • 对于 ReLU / ELU 激活,推荐的 gain = 2 ≈ 1.414 \sqrt{2} ≈ 1.414 2 ≈1.414
  • 因为 GAT 里面用了 ELU 激活,所以这里选 1.414

🔹 举个例子

python 复制代码
import torch
import torch.nn as nn

W = torch.empty(3, 2)
nn.init.xavier_uniform_(W, gain=1.414)
print(W)

可能输出:

复制代码
tensor([[-0.6465,  0.5042],
        [ 0.7393, -0.1285],
        [-0.2268,  0.6471]])

这些值就是在合适的范围内随机初始化的权重。

📌 总结:
nn.init.xavier_uniform_(self.W.data, gain=1.414)

= 用 Xavier 均匀分布初始化 W,保证前后层方差平衡,避免梯度消失/爆炸,适合 ELU 激活。

问题2 nn.Parameter 是什么?

nn.Parameter 是一种 特殊的张量(Tensor) ,和普通 torch.Tensor 的区别在于:

👉 如果你把一个 Tensor 包装成 nn.Parameter,并把它赋值给 nn.Module 的属性,那么它就会 自动被认为是模型的可训练参数 ,会在训练时出现在 model.parameters() 里,交给优化器更新。

🔹 举个例子

python 复制代码
import torch
import torch.nn as nn

# 普通 Tensor
w1 = torch.randn(3, 3)

# Parameter
w2 = nn.Parameter(torch.randn(3, 3))

print(isinstance(w1, nn.Parameter))  # False
print(isinstance(w2, nn.Parameter))  # True

如果我们放到一个模型里:

python 复制代码
class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.w1 = torch.randn(3, 3)                 # 普通张量
        self.w2 = nn.Parameter(torch.randn(3, 3))   # 可训练参数

model = MyModel()
print(list(model.parameters()))

输出只会包含 w2,而不会包含 w1

也就是说,只有 Parameter 会被 优化器更新

🔹 在你代码里的用法

python 复制代码
self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))

这里 self.W线性变换的权重矩阵 ,必须在训练中更新,所以定义成 nn.Parameter

同样:

python 复制代码
self.a = nn.Parameter(torch.empty(size=(2*out_features, 1)))

是注意力机制里的权重,也需要更新,所以用 Parameter

🔹 总结

  • torch.Tensor:普通张量,不会自动训练
  • nn.Parameter:可训练张量,自动注册进模型参数
  • 在定义自定义层(如 GAT 层)时,所有需要 梯度更新的权重 都要用 Parameter

问题3 self.add_module

差不多可以这么理解 ✅,但它不是普通的 Python 字典,而是 PyTorch 的模块管理机制

我帮你详细解释一下 self.add_module

定义

nn.Module.add_module(name, module)

  • name: 字符串,子模块的名字
  • module: 一个 nn.Module 对象

作用就是 把子模块注册到当前 Module 里

🔹 内部原理

实际上,nn.Module 内部有一个 OrderedDict 存储子模块:

python 复制代码
self._modules: Dict[str, Module]

当你调用:

python 复制代码
self.add_module("attention_0", GraphAttentionLayer(...))

就相当于:

python 复制代码
self._modules["attention_0"] = GraphAttentionLayer(...)

所以你可以像字典一样访问:

python 复制代码
print(self._modules["attention_0"])

🔹 区别

和普通字典不同,_modules 里的对象会被:

  • model.parameters() 自动收集
  • model.to(device) 时自动搬到 GPU
  • model.train() / model.eval() 时自动切换模式

也就是说,只要是 add_module 注册进去的,就能参与训练

🔹 示例

python 复制代码
import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.add_module("layer1", nn.Linear(10, 20))
        self.add_module("layer2", nn.ReLU())
        
model = MyModel()
print(model._modules)  # 就是一个 OrderedDict

输出类似:

复制代码
OrderedDict([('layer1', Linear(in_features=10, out_features=20, bias=True)),
             ('layer2', ReLU())])

所以你理解得没错:self.add_module 背后确实是往一个 OrderedDict 里加条目,但它和普通字典不同,会多了很多 PyTorch 的训练支持功能。

问题4 torch.matmul torch.mm

torch.matmul 是 PyTorch 中一个 更通用的矩阵/向量乘法函数 ,功能比 torch.mm 更强,支持多种情况。

1️⃣ 基本区别

函数 支持的输入 输出 备注
torch.mm(A, B) A、B 都是二维矩阵 矩阵乘法 (m,n) × (n,p) → (m,p) 仅二维矩阵
torch.matmul(A, B) 支持向量、矩阵和高维张量 自动选择矩阵乘法或批量乘法 通用

2️⃣ 输入和输出规则

(1) 二维矩阵

python 复制代码
A.shape = (m, n)
B.shape = (n, p)
C = torch.matmul(A, B)  # C.shape = (m, p)
  • torch.mm 一致

(2) 向量

python 复制代码
a.shape = (n,)
b.shape = (n,)
c = torch.matmul(a, b)  # 内积,标量

(3) 高维张量(批量矩阵乘法)

python 复制代码
A.shape = (batch, m, n)
B.shape = (batch, n, p)
C = torch.matmul(A, B)  # C.shape = (batch, m, p)
  • torch.matmul 会对 batch 维度自动广播
  • 非常适合 批量图神经网络计算

3️⃣ 在 GAT 中的应用

python 复制代码
Wh1 = torch.matmul(Wh, self.a[:self.out_features, :])
  • Wh:节点特征 (N, out_features)
  • self.a[:out_features, :]:权重 (out_features, 1)
  • 输出 Wh1:形状 (N, 1)
  • 功能:对每个节点的特征向量进行线性组合,得到注意力机制的部分输入

相比 torch.mm,这里用 matmul 可以更通用,如果以后是批量矩阵或者高维张量也能工作

4️⃣ 总结

  • torch.mm:只能二维矩阵

  • torch.matmul:通用版本,支持:

    • 向量内积
    • 矩阵乘法
    • 批量矩阵乘法
  • GAT 中:

    • Wh = torch.mm(h, W) → 将输入特征线性映射
    • Wh1 = torch.matmul(Wh, a[:out_features,:]) → 注意力机制的线性组合