图卷积网络（GCN）

一句话概述

图卷积网络（Graph Convolutional Network, GCN）是最经典和广泛使用的图神经网络之一。它将卷积操作从规则的图像网格推广到不规则的图结构上，核心思想是：每个节点的新特征是其自身特征和邻居特征的加权平均（带归一化），然后通过可学习的权重矩阵进行线性变换。GCN的每一层可以简洁地表示为 H^{(l+1)} = σ(D̃^{-1/2} Ã D̃^{-1/2} H^{(l)} W^{(l)})，其中Ã=A+I是添加自环的邻接矩阵，D̃是Ã的度矩阵，W是可学习权重，σ是激活函数。这个公式的推导源于图上的谱卷积（Spectral Convolution），但通过一阶近似简化为了高效的空间域实现。GCN以其简洁优雅的数学形式和良好的实验效果，成为图深度学习领域的基石模型。

💡 核心要点：①GCN将卷积操作推广到图结构，通过邻居特征聚合实现图上信息传播 ②核心公式H'=σ(D̃^{-1/2}ÃD̃^{-1/2}HW)，对称归一化防止度大的节点主导 ③添加自环确保节点自身信息不丢失 ④GCN层实现了消息传递中的"平均聚合+线性变换+非线性激活"

教学与演示

一、GCN的数学推导：从谱卷积到空间域

是什么（定义）：GCN（Graph Convolutional Network）是Thomas Kipf和Max Welling于2017年提出的图神经网络。其核心公式为 H^{(l+1)} = σ(D̃^{-1/2} Ã D̃^{-1/2} H^{(l)} W^{(l)})，其中Ã=A+I（带自环的邻接矩阵），D̃_{ii}=Σ_j Ã_{ij}（度矩阵），H^{(l)}是第l层的节点特征矩阵，W^{(l)}是可学习的权重矩阵，σ是激活函数（如ReLU）。这个公式实现了图上的卷积操作——每个节点的新特征是其邻居特征（包括自身）的加权平均。

大白话 GCN就像是"朋友圈影响力传播"。每个人（节点）的新观点（新特征）= 自己旧观点 + 朋友们的旧观点的加权平均，再经过一个"思考转换"（权重矩阵W）。这个加权平均不是简单的1/n（朋友数量），而是用了一种特殊的归一化，确保"有很多朋友的人"不会因为朋友多而影响力过大。就像在一个讨论组里，每个人发言的影响力应该被合理分配，而不是被"社交达人"垄断。

为什么（原理）：GCN的公式来源于图上的谱卷积理论。谱卷积的核心是在傅里叶域（图拉普拉斯矩阵的特征空间）进行卷积，但计算特征分解在计算上不可行。GCN通过一阶切比雪夫多项式近似，将谱卷积简化为空间域的邻居聚合。具体的推导步骤：①图卷积定义为g_θ★x = Ug_θU^Tx（U是特征向量矩阵）；②用切比雪夫多项式近似g_θ；③取一阶近似，得到简化公式；④通过重归一化技巧（renormalization trick）解决数值不稳定性。

import numpy as np

# GCN层的完整实现：从数学公式到代码
# 展示GCN如何从邻接矩阵和特征矩阵计算节点新表示

class GCNLayer:
    def __init__(self, d_in, d_out):
        np.random.seed(42)
        # 可学习的权重矩阵：将输入特征映射到输出特征
        self.W = np.random.randn(d_in, d_out) * 0.1
        # 偏置项
        self.b = np.zeros(d_out)

    def normalize_adjacency(self, A):
        """计算对称归一化的邻接矩阵：D^{-1/2} A D^{-1/2}"""
        # 步骤1：添加自环（A_tilde = A + I）
        # 确保节点自身的信息不会丢失
        A_tilde = A + np.eye(A.shape[0])

        # 步骤2：计算度矩阵D_tilde
        # D_tilde[i][i] = 节点i的度（包括自环）
        D_tilde = np.diag(np.sum(A_tilde, axis=1))

        # 步骤3：计算D^{-1/2}
        # 对对角线元素取-1/2次幂
        D_inv_sqrt = np.diag(1.0 / np.sqrt(np.diag(D_tilde)))

        # 步骤4：对称归一化：D^{-1/2} A_tilde D^{-1/2}
        A_norm = D_inv_sqrt @ A_tilde @ D_inv_sqrt

        return A_norm

    def forward(self, X, A):
        """
        GCN层的前向传播：H' = σ(A_norm @ H @ W)
        X: 节点特征矩阵 (n, d_in)
        A: 邻接矩阵 (n, n)
        """
        # 步骤1：归一化邻接矩阵
        A_norm = self.normalize_adjacency(A)

        # 步骤2：邻居聚合（消息传递）：A_norm @ X
        # 每个节点的新表示 = 自身和邻居特征的加权平均
        aggregated = A_norm @ X  # (n, d_in)

        # 步骤3：线性变换（可学习的权重矩阵）
        transformed = aggregated @ self.W + self.b  # (n, d_out)

        # 步骤4：非线性激活
        output = np.maximum(0, transformed)  # ReLU激活

        return output, A_norm


# 创建示例图
A = np.array([
    [0, 1, 0, 1, 0],
    [1, 0, 1, 0, 1],
    [0, 1, 0, 0, 0],
    [1, 0, 0, 0, 1],
    [0, 1, 0, 1, 0],
])

X = np.array([
    [0.5, 0.2, 0.1, 0.8],
    [0.1, 0.9, 0.3, 0.2],
    [0.3, 0.1, 0.7, 0.1],
    [0.8, 0.1, 0.2, 0.5],
    [0.2, 0.6, 0.1, 0.3],
])

gcn = GCNLayer(d_in=4, d_out=3)
output, A_norm = gcn.forward(X, A)

print("=== GCN层：图卷积操作 ===\n")

print("原始邻接矩阵 A（无自环）：")
print(A)

print(f"\n添加自环后 A_tilde = A + I：")
A_tilde = A + np.eye(5)
print(A_tilde)

print(f"\n归一化后 A_norm = D^{-1/2} A_tilde D^{-1/2}：")
print(np.round(A_norm, 4))

print("\n归一化矩阵的含义：")
print("- 对角元素：节点自身权重≈0.3-0.5")
print("- 非对角元素：邻居权重（与度有关）")
print("- 节点0的邻居1和3的权重不同，因为它们的度不同")

print(f"\n输入特征 X（5×4）→ 输出特征 H（5×3）：")
for i in range(5):
    print(f"  节点{i}: {X[i]} → {np.round(output[i], 4)}")

print("\nGCN公式总结：H' = ReLU(D^{-1/2} (A+I) D^{-1/2} · H · W)")

大白话 GCN公式可以拆成三步理解。第一步：Ã = A + I——给图加上自环，就像每个人都"关注自己"（我自己的意见也很重要）。第二步：D̃^{-1/2} Ã D̃^{-1/2}——对称归一化，等价于"每个人的意见按照他的社交圈大小来加权"——朋友圈大的人，他对每个朋友的影响力被稀释；朋友圈小的人，他的意见更集中。第三步：×W——就像每个人听完朋友意见后，用自己的"思考方式"（W）来消化这些信息，形成新观点。

什么用（应用）：GCN是最经典的图神经网络，广泛应用于节点分类（如Cora/CiteSeer/PubMed论文分类）、图分类、链接预测等任务。在Cora数据集上，2层GCN就能达到约81%的节点分类准确率。GCN也是许多后续GNN变体的基础——GAT（加注意力）、GraphSAGE（加采样）、GIN（加MLP）都可以看作GCN的扩展。

哪些坑（缺点）：GCN的主要局限包括：①转导学习（transductive）——训练时需要看到整个图结构，无法直接泛化到未见过的节点或图；②全批次训练——每次更新需要计算整个图的邻接矩阵，无法处理大规模图；③层数限制——通常只用2层，超过3层性能急剧下降（过平滑）；④对称归一化虽然有效，但丢失了有向图的方向信息。

二、GCN的归一化策略：为什么需要D^{-1/2}

是什么（定义）：GCN使用对称归一化D̃^{-1/2}ÃD̃^{-1/2}，而不是简单的平均（除以邻居数）或求和。对称归一化对每条边(i,j)赋予权重1/√(d_i·d_j)，其中d_i和d_j分别是节点i和j的度（包括自环）。这种归一化确保了：①特征值范围在[0,1]之间，数值稳定；②高度节点（社交达人）的影响力被适当稀释；③保持了邻接矩阵的对称性。

大白话 对称归一化就像是"公平投票"。在社交网络中，大V（有很多粉丝）的发言影响力不应该和普通人一样大——如果只是简单求和，大V的发言会被无数次放大。对称归一化就像给每条边分配一个"衰减系数"——大V对每个粉丝的影响力是1/√(大V的粉丝数×粉丝的朋友数)，这样大V的总影响力被稀释，普通人的声音也能被听到。

为什么（原理）：对称归一化有严格的数学依据。从谱图理论来看，归一化图拉普拉斯矩阵L_norm = I - D^{-1/2}AD^{-1/2}的特征值在[0,2]之间，与图的大小无关，这保证了卷积操作的数值稳定性。从信息传播角度，对称归一化等价于"随机游走的平稳分布"——信息在图上长期传播后，每个节点的信息量与其度成正比，归一化抵消了这种偏差。

import numpy as np

# 深入理解GCN归一化策略
# 对比不同归一化方式的差异

class NormalizationComparison:
    def __init__(self):
        pass

    def no_normalization(self, A):
        """无归一化：直接使用A（不含自环）"""
        return A

    def mean_normalization(self, A):
        """平均归一化：除以每个节点的度"""
        D_inv = np.diag(1.0 / np.sum(A, axis=1))
        D_inv[np.isinf(D_inv)] = 0  # 处理度为0的节点
        return D_inv @ A

    def symmetric_normalization(self, A):
        """对称归一化（GCN标准）：D^{-1/2} (A+I) D^{-1/2}"""
        A_tilde = A + np.eye(A.shape[0])
        D_tilde = np.diag(np.sum(A_tilde, axis=1))
        D_inv_sqrt = np.diag(1.0 / np.sqrt(np.diag(D_tilde)))
        return D_inv_sqrt @ A_tilde @ D_inv_sqrt

    def demonstrate(self, A):
        print("=== GCN归一化策略对比 ===\n")

        print("原始邻接矩阵 A：")
        print(A)

        print(f"\n1. 无归一化：")
        A_none = self.no_normalization(A)
        print(A_none)
        print(f"   缺点：特征值可能很大，训练不稳定")

        print(f"\n2. 平均归一化 (D^{-1}A)：")
        A_mean = self.mean_normalization(A)
        print(np.round(A_mean, 4))
        print(f"   每行和为1（概率矩阵），但不保留对称性")

        print(f"\n3. 对称归一化 (D^{-1/2}(A+I)D^{-1/2})：")
        A_sym = self.symmetric_normalization(A)
        print(np.round(A_sym, 4))
        print(f"   保留对称性，数值稳定，GCN标准选择")

        # 数值稳定性验证
        print(f"\n\n=== 数值稳定性验证 ===")

        # 模拟一个度很大的节点（社交网络大V）
        A_big = np.array([
            [0, 1, 1, 1, 1, 1, 1, 1, 1, 1],  # 节点0连接9个节点
            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ])

        print("高度节点示例：节点0连接9个节点，其他节点只连接节点0")
        A_norm = self.symmetric_normalization(A_big)
        print(f"节点0与节点1之间的边权重: {A_norm[0, 1]:.4f}")
        print(f"  1/√(10×2) = 1/√20 = {1/np.sqrt(20):.4f}")
        print("→ 高度节点的边权重被显著稀释，防止信息传播被大V垄断")


NormalizationComparison().demonstrate(A=np.array([
    [0, 1, 0, 1, 0],
    [1, 0, 1, 0, 1],
    [0, 1, 0, 0, 0],
    [1, 0, 0, 0, 1],
    [0, 1, 0, 1, 0],
]))

大白话 对称归一化的权重公式是 1/√(d_i × d_j)。想象节点i有100个朋友，节点j有10个朋友——i对j的影响力是1/√(100×10)≈0.032，而如果i和j都只有2个朋友，影响力是1/√(2×2)=0.5。这就是"朋友多的人，他对每个人的影响力被稀释"的数学表达。这种设计让GCN在社交网络、论文引用网络等度分布极不均匀的图上也能稳定工作。

什么用（应用）：对称归一化是GCN成功的关键技术之一。在Cora等论文引用网络中，论文的被引次数差异很大（有的被引100次，有的只有1次），对称归一化确保了引用多的论文不会"淹没"引用少的论文信息。这一归一化策略也被后续的GAT、GIN等模型继承，成为图神经网络的标配操作。

哪些坑（缺点）：对称归一化假设图是无向的（A对称），对于有向图需要不同的处理。此外，归一化虽然数值稳定，但丢失了节点的绝对度信息——两个具有相同归一化特征但不同度的节点在GCN中可能无法区分。GIN论文指出，GCN的归一化聚合（平均）表达能力不如求和聚合，因为在某些图中无法区分不同的局部结构。

三、GCN的训练与半监督节点分类

是什么（定义）：GCN在节点分类任务中的典型训练流程是：使用2层GCN（输入→隐藏→输出），在少量标注节点上计算交叉熵损失，通过反向传播更新权重矩阵W^{(0)}和W^{(1)}。GCN是转导（transductive）模型——训练时需要整个图的邻接矩阵和所有节点的特征（包括未标注节点），但只使用标注节点的标签计算损失。这种半监督学习方式使得GCN能利用未标注节点的图结构信息来提升分类效果。

大白话 GCN的训练就像"在社交网络中给少数人贴标签，然后推断所有人的标签"。假设你只知道10%的人的兴趣爱好（标注节点），你要推断其余90%的人的兴趣。GCN的做法是：让整个社交网络中的信息流动（通过图卷积），然后只看那10%标注的人预测得对不对，以这个为"考试分数"来调整模型。因为信息在图上流动，未标注的90%的人也能帮助模型理解图结构，从而提升对标注节点的预测准确率。

为什么（原理）：GCN之所以能利用未标注节点，是因为图卷积操作同时作用于所有节点（标注和未标注）。未标注节点的特征通过消息传递影响标注节点的表示，从而提供了额外的结构信息。这类似于"近朱者赤，近墨者黑"——如果一个未标注节点连接了两个标注节点，它的特征可以间接帮助模型理解这两个标注节点之间的关系。

import numpy as np

# GCN训练演示：半监督节点分类
# 展示2层GCN如何利用图结构进行分类

class TwoLayerGCN:
    def __init__(self, d_in=4, d_hidden=3, d_out=2, lr=0.1):
        np.random.seed(42)
        # 第一层权重：输入→隐藏
        self.W1 = np.random.randn(d_in, d_hidden) * 0.3
        # 第二层权重：隐藏→输出（类别数）
        self.W2 = np.random.randn(d_hidden, d_out) * 0.3
        self.lr = lr

    def gcn_layer(self, X, A, W):
        """GCN层：H = ReLU(D^{-1/2}(A+I)D^{-1/2} · X · W)"""
        A_tilde = A + np.eye(A.shape[0])
        D_tilde = np.diag(np.sum(A_tilde, axis=1))
        D_inv_sqrt = np.diag(1.0 / np.sqrt(np.diag(D_tilde)))
        A_norm = D_inv_sqrt @ A_tilde @ D_inv_sqrt
        return np.maximum(0, A_norm @ X @ W)

    def forward(self, X, A):
        """2层GCN前向传播"""
        # 第一层：ReLU激活
        H1 = self.gcn_layer(X, A, self.W1)
        # 第二层：无激活（输出logits）
        A_tilde = A + np.eye(A.shape[0])
        D_tilde = np.diag(np.sum(A_tilde, axis=1))
        D_inv_sqrt = np.diag(1.0 / np.sqrt(np.diag(D_tilde)))
        A_norm = D_inv_sqrt @ A_tilde @ D_inv_sqrt
        H2 = A_norm @ H1 @ self.W2
        return H2

    def train_step(self, X, A, y, train_mask):
        """一步训练：计算损失并更新权重"""
        # 前向传播
        logits = self.forward(X, A)

        # Softmax得到概率
        logits = logits - np.max(logits, axis=1, keepdims=True)
        probs = np.exp(logits) / np.sum(np.exp(logits), axis=1, keepdims=True)

        # 交叉熵损失（仅计算标注节点）
        loss = -np.sum(np.log(probs[train_mask] + 1e-8) * y[train_mask]) / np.sum(train_mask)

        # 简化梯度更新（仅演示，实际需要完整反向传播）
        # 这里只更新W2
        error = probs - y  # 简化的梯度
        self.W2 -= self.lr * H1.T @ (error * train_mask.reshape(-1, 1)) / np.sum(train_mask)

        # 预测准确率
        pred = np.argmax(probs, axis=1)
        true = np.argmax(y, axis=1)
        acc = np.mean(pred[train_mask] == true[train_mask])

        return loss, acc


# 创建示例
A = np.array([
    [0, 1, 0, 1, 0, 0],
    [1, 0, 1, 0, 1, 0],
    [0, 1, 0, 0, 0, 1],
    [1, 0, 0, 0, 1, 0],
    [0, 1, 0, 1, 0, 1],
    [0, 0, 1, 0, 1, 0],
])

X = np.random.randn(6, 4) * 0.5

# 标签：节点0-2为类别0，节点3-5为类别1
y = np.array([
    [1, 0], [1, 0], [1, 0],
    [0, 1], [0, 1], [0, 1],
])

# 半监督：只标注节点0和节点3
train_mask = np.array([True, False, False, True, False, False])

gcn_model = TwoLayerGCN(d_in=4, d_hidden=3, d_out=2, lr=0.1)

print("=== GCN半监督节点分类训练 ===\n")
print(f"总节点数: 6，标注节点数: {np.sum(train_mask)}")
print(f"训练前：")

for epoch in range(5):
    loss, acc = gcn_model.train_step(X, A, y, train_mask)
    print(f"轮次 {epoch+1}: 损失={loss:.4f}, 标注节点准确率={acc:.2%}")

print("\n→ GCN利用图结构，仅用2个标注节点就能学习分类")
print("→ 未标注节点的特征通过图卷积影响标注节点的表示")
print("→ 这就是半监督学习的威力！")

大白话 2层GCN就是"两次朋友圈讨论"。第一次讨论后，每个人形成了初步意见（隐藏层）；第二次讨论后，每个人形成了最终判断（分类结果）。这两次讨论的"思考方式"（W^{(0)}和W^{(1)}）是通过标注数据学习到的。只标注了少数节点，但因为信息在图上的流动，所有人的判断都会受到影响——这就是半监督学习。

什么用（应用）：GCN的半监督节点分类在学术论文分类（Cora、CiteSeer、PubMed）中取得了里程碑式的结果。在Cora数据集上，仅用5%的标注节点（约140个），GCN就能达到约81%的准确率。这种半监督能力在标注成本高的场景中特别有价值——如医学文献分类、社交网络中的异常检测、推荐系统中的用户画像等。

哪些坑（缺点）：GCN的转导学习限制意味着它不能直接泛化到训练时未见过的图（inductive learning）。如果新增节点或新图，需要重新训练。此外，GCN的全批次训练需要将整个图加载到内存中，对于大图（百万节点级别）不可行。这些限制推动了GraphSAGE（归纳学习+采样）等后续工作。

概念关系图谱

重点答疑

Q1: GCN为什么通常只用2层？

实验表明，GCN在2层时效果最好，超过3层性能急剧下降。原因是"过平滑"（over-smoothing）——每层图卷积相当于对节点特征做一次平滑（邻居平均），多层后所有节点的特征趋于相同，失去区分度。数学上，多层GCN等价于图拉普拉斯矩阵的幂迭代，最终收敛到图的平稳分布。这也是为什么GCN论文中W^{(0)}和W^{(1)}的大小不同（输入→隐藏→输出），而非简单的堆叠相同层。

Q2: GCN的"卷积"和CNN的卷积有什么本质区别？

CNN的卷积有固定的卷积核大小（如3×3），在所有位置共享权重，提取的是"局部模式"。GCN的"卷积"其实是邻居聚合——每个节点聚合所有邻居（数量不固定），没有共享的卷积核（W是全局的，但聚合模式由图的局部结构决定）。严格来说，GCN的"卷积"更接近"图上的平均操作+线性变换"，而非传统意义上的卷积。

Q3: GCN如何处理有向图？

标准GCN假设图是无向的（A对称），对称归一化D^{-1/2}AD^{-1/2}也要求A对称。对于有向图，可以有两种处理方式：①将A+A^T转为无向图（丢失方向信息）；②使用非对称归一化D^{-1}A（保留方向，但丢失对称性）。在实践中，如果方向信息重要（如"论文A引用论文B"），需要专门的GCN变体来处理有向图。

章节单词汇总