【机器学习】-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

在 PyTorch 里：

self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))

这里的 torch.empty 并不是“空的”的意思，而是 创建一个未初始化的张量。

• torch.empty(shape) 会直接分配一块内存，但 不对数值做初始化
• 里面的值通常是内存里的随机数（垃圾值）
• 一般会 马上再用 nn.init（比如 xavier_uniform_）去初始化

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 的值设成合理的初始权重。

🔹 举个例子

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：一个缩放系数（通常是根据激活函数来设定），这里取 $\sqrt{2}$，适合 ReLU / ELU 激活

---

🔹 Xavier 初始化的原理

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

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

Xavier 初始化的目标是：
让每一层输入和输出的方差尽量保持一致，避免数值逐层放大/缩小。

公式（均匀分布版）：

$$W_{ij}\sim U(-\sqrt{\frac{6}{\text{fan\_in}+\text{fan\_out}}}\cdot \text{gain},\sqrt{\frac{6}{\text{fan\_in}+\text{fan\_out}}}\cdot \text{gain})$$

其中：

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

🔹 为什么 gain=1.414？

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

🔹 举个例子

import torch
import torch.nn as nnW = 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() 里，交给优化器更新。
🔹 举个例子

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

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

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 会被 优化器更新。

🔹 在你代码里的用法

self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))

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

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 存储子模块：

self._modules: Dict[str, Module]

当你调用：

self.add_module("attention_0", GraphAttentionLayer(...))

就相当于：

self._modules["attention_0"] = GraphAttentionLayer(...)

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

print(self._modules["attention_0"])

🔹 区别

和普通字典不同，_modules 里的对象会被：

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

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

🔹 示例

import torch.nn as nnclass 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) 二维矩阵

A.shape = (m, n)
B.shape = (n, p)
C = torch.matmul(A, B)  # C.shape = (m, p)

• 与 torch.mm 一致

(2) 向量

a.shape = (n,)
b.shape = (n,)
c = torch.matmul(a, b)  # 内积，标量

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

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 中的应用

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,:]) → 注意力机制的线性组合