图嵌入与图神经网络：从 node2vec 到 GCN 的完整图谱

传统 ML 输入是「固定维度向量」（表格行、图像像素）
图数据的难点：节点数量不固定、结构信息（邻居关系）在向量外

图嵌入 = 把节点/边/图映射到低维向量空间
        保留「结构相似 → 向量相近」的性质

节点嵌入  ：每个节点 → 向量（用于节点分类/相似度）
边嵌入    ：每条边 → 向量（节点向量拼接/点积）
整图嵌入  ：每张图 → 向量（用于图分类/相似图检索）

思想：在图上做随机游走，得到节点序列（像句子中的词）
      → 用 Word2Vec 训练，让「同一游走里近邻」的节点向量相近

游走：从 v 出发随机选邻居走 L 步，得到序列 [v, v1, v2, ...]
      → 序列集合 = 语料库 → Skip-gram 训练嵌入

偏置参数：
  p（返回参数）：控制回到上一个节点的概率（小 p → 局部性）
  q（进出参数）：控制走向更远邻居的概率（小 q → 广度/结构）
同质性（小 q）：邻居结构相似的节点向量相近（同社区）
结构性（大 q）：枢纽/桥节点向量相近（同角色）

from node2vec import Node2Vec

edges = [('U1','M1'), ('U1','M2'), ('U2','M2'), ('U2','M3')]  # 边列表
model = Node2Vec(edges, dimensions=64,
                 walk_length=20, num_walks=50,
                 p=1.0, q=0.5,    # q<1 → 偏重结构
                 workers=4).fit()
vec = model.wv['U1']   # 节点 U1 的 64 维向量

1. 转导式（transductive）：新节点加入要重新训练
2. 只利用结构、不利用节点属性
3. 大规模图的游走内存开销大

设邻接矩阵 A（N×N），希望找到 U（N×d）使 A ≈ U·Uᵀ
→ 用 SVD / 谱方法求解，得到节点嵌入 U

局限：N 大时 A 是 N² 稀疏矩阵，SVD 昂贵 → 只适合中等规模

图拉普拉斯 L = D - A（D 为度矩阵）
谱嵌入：取 L 的「最小非零特征值」对应的特征向量
       → 保留「局部相似性」（相连的节点向量相近）

意义：这是 GCN 的数学基础——GCN 的卷积本质是谱域的局部近似

第 k 层：
  ① 消息（Message）   ：每个邻居向节点发送自己的表示
     m_{u→v} = Message(h_u^(k-1))
  ② 聚合（Aggregate） ：节点聚合所有邻居消息
     a_v = AGG({m_{u→v} | u ∈ N(v)})
  ③ 更新（Update）    ：结合自身表示生成新表示
     h_v^(k) = Update(h_v^(k-1), a_v)

k 层后，h_v 聚合了 k 跳邻居的信息（感受野 = k 跳）

均值聚合（Mean） ：a_v = mean({h_u})        → 平滑、稳定（GCN 用）
求和聚合（Sum）   ：a_v = sum({h_u})         → 保度数敏感（GIN 用）
注意力聚合（Attn）：a_v = Σ α_uv · h_u       → 邻居重要性加权（GAT 用）

层数太深 → 所有节点表示趋同（过平滑）→ 分类能力退化
经验：2-3 层 GNN 最常用（感受野 2-3 跳）
深图学习需残差、跳跃连接、GPR 等专门设计

GCN 的聚合公式（均值 + 自连接 + 对称归一化）：
  h_v^(k) = ReLU( W · Σ_{u∈N(v)∪{v}} (1/√(d_u·d_v)) · h_u^(k-1) )

要点：
  1. 归一化用度 d_u·d_v 的平方根 → 抑制高连接节点的消息放大
  2. 加自连接（v 也聚合自己）→ 保留自身信息
  3. 本质上是对图拉普拉斯的 1 阶局部近似

# 示意：GCN 单层聚合（伪代码）
def gcn_layer(h, adj, W, D):
    A_hat = adj + I                          # 加自连接
    D_hat = degree_diag(A_hat)
    A_norm = D_hat**(-0.5) @ A_hat @ D_hat**(-0.5)   # 对称归一化
    return relu(A_norm @ h @ W)

GAT 给每个邻居学一个重要性权重 α_uv：
  α_uv = softmax( LeakyReLU( a·[W·h_u ; W·h_v] ) )
聚合 = Σ α_uv · W · h_u

优势：无需预设度归一化，自适应地放大重要邻居、忽略噪声邻居
多头注意力：并行多组 α → 拼接/平均，更稳定

目标：预测节点标签（黑产账户/非黑产、欺诈订单/正常订单）
做法：节点嵌入 → 接 MLP/softmax 分类器
监督：一部分节点有标签，其余预测（半监督）

# 示意
node_emb = gnn_forward(graph)        # (N, d)
logits = linear(node_emb)            # (N, num_classes)
loss = cross_entropy(logits[masked], y[masked])   # 只在有标签节点上算

目标：预测「两个节点之间是否会出现/应该存在关系」
做法：正样本（已有边）+ 负采样（随机不存在的边）
     打分函数 score(u,v) = φ(h_u, h_v)   （点积/拼接+MLP）
损失：二分类（有无边）或排序损失
应用：推荐（用户-物品边）、知识图谱补全

目标：整张图一个标签（分子是否有药性、网络是否异常）
做法：节点嵌入 → 读出（Readout：全局池化 mean/sum）→ 分类器

转导式（transductive）：整图训练，随机遮住部分标签测试
  → 测试节点在训练时「看到」了图的连接
归纳式（inductive）   ：训练图/测试图分开（GraphSAGE、GNN 通用）
  → 更接近真实「新节点上线」场景

# 链路预测指标示例
from sklearn.metrics import roc_auc_score
auc = roc_auc_score(y_true, pos_prob)      # y_true: 是否存在边

1. 标签泄漏：测试节点「通过邻居传播」偷看标签 → 用 inductive 划分验证
2. 类别不平衡：欺诈场景正样本极少 → F1/AUC 而非准确率
3. 过平滑：层数别太深
4. 嵌入维度：64-256 常见，过大易过拟合

import torch
from torch_geometric.data import Data

edge_index = torch.tensor([[0, 1, 1, 2, 2, 3],      # 源节点
                           [1, 0, 2, 1, 3, 2]],     # 目标节点
                          dtype=torch.long)
x = torch.randn(4, 16)      # 4 个节点的 16 维特征
y = torch.tensor([0, 1, 0, 1])   # 节点标签
data = Data(x=x, edge_index=edge_index, y=y)

import torch.nn.functional as F
from torch_geometric.nn import GCNConv

class GCN(torch.nn.Module):
    def __init__(self, in_dim, hid_dim, out_dim):
        super().__init__()
        self.conv1 = GCNConv(in_dim, hid_dim)
        self.conv2 = GCNConv(hid_dim, out_dim)

    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x, edge_index))
        x = F.dropout(x, training=self.training)
        return self.conv2(x, edge_index)   # 节点分类 logits

model = GCN(in_dim=16, hid_dim=32, out_dim=2)
opt = torch.optim.Adam(model.parameters(), lr=0.01)
loss_fn = torch.nn.CrossEntropyLoss()

for epoch in range(200):
    model.train()
    logits = model(data.x, data.edge_index)
    loss = loss_fn(logits[data.train_mask], data.y[data.train_mask])
    opt.zero_grad(); loss.backward(); opt.step()
    if epoch % 20 == 0:
        print(epoch, loss.item())

# 负采样：随机取「不存在的边」作为负样本
neg_edge_index = random_non_existing_edges(data)   # (2, num_neg)
# 打分：node_emb[u] · node_emb[v]
score = (emb[src] * emb[dst]).sum(dim=1)
loss = bce(score, labels)     # labels: 正边=1, 负边=0

Neo4j（存与查）→ 导出边列表/子图 → Python（GNN 训练）→ 嵌入
→ 写回 Neo4j 节点属性 → 在线查询用嵌入相似度/向量检索

# Python 侧：读取子图 → node2vec → 写回
from neo4j import GraphDatabase
driver = GraphDatabase.driver("bolt://localhost:7687")
with driver.session() as s:
    edges = list(s.run("MATCH (u)-[r]->(m) RETURN id(u), id(m)"))
    # ... 训练嵌入 ...
    s.run("UNWIND $rows AS row SET n.emb = row.emb", rows=vec_rows)

1. 向量相似度 TopK：把嵌入存向量索引，新查询秒级返回相似节点
2. 图特征：把 GNN 学的嵌入当「图特征」喂给风控/推荐模型
3. 结构检索：找到「结构与某节点最像」的节点（反欺诈同构）