BERT与知识图谱融合实战：从文本理解到结构化推理

1次阅读

共计 4132 个字符，预计需要花费 11 分钟才能阅读完成。

在构建问答系统或推荐引擎时，我们常常遇到这样的困境：BERT 等预训练语言模型虽然能捕捉丰富的上下文语义，但在需要结构化推理的场景中表现不佳。比如当用户询问 ” 特斯拉的创始人还创办了哪些公司 ” 时，纯 BERT 模型可能无法系统性地追踪 ” 特斯拉→创始人→其他公司 ” 这一关系链。

知识图谱 (KG) 的加入正好弥补了这一缺陷。KG 以三元组 (头实体, 关系, 尾实体) 的形式存储结构化知识，例如 (特斯拉, 创始人, 马斯克) 和(马斯克, 创办, SpaceX)。这种显式的知识表示方式让系统具备了逻辑推理能力。

两者的核心差异在于：

BERT 擅长隐式语义理解
KG 擅长显式关系推理

下图展示了典型的 BERT-KG 联合架构：

graph LR
    A[输入文本] --> B(BERT 编码器)
    A --> C(实体识别模块)
    C --> D[知识图谱查询]
    D --> E[子图嵌入]
    B --> F[文本表征]
    E --> G[融合层]
    F --> G
    G --> H[任务输出]

信息流动分为三个关键路径：

文本通过 BERT 获取上下文感知的向量表示
识别出的实体从知识图谱获取相关子图的结构化信息
两种表征在融合层进行交互

固定 BERT 参数，训练 KG 嵌入模块
固定 KG 模块，微调 BERT
循环直到收敛

优点：训练稳定，内存占用小

缺点：可能陷入局部最优

构建统一损失函数：L = L_task + λL_kg
同时更新所有参数

优点：参数协同优化

缺点：需要更多显存

import torch
import torch.nn as nn

class TransE(nn.Module):
    def __init__(self, ent_size, rel_size, dim=256, margin=1.0):
        super().__init__()
        self.ent_emb = nn.Embedding(ent_size, dim)  # 实体嵌入
        self.rel_emb = nn.Embedding(rel_size, dim)  # 关系嵌入
        self.margin = margin
        self._init_weights()

    def _init_weights(self):
        # 初始化遵循 TransE 原论文方案
        nn.init.xavier_uniform_(self.ent_emb.weight)
        nn.init.xavier_uniform_(self.rel_emb.weight)
        # 归一化处理
        self.ent_emb.weight.data = F.normalize(self.ent_emb.weight.data, p=2, dim=-1)
        self.rel_emb.weight.data = F.normalize(self.rel_emb.weight.data, p=2, dim=-1)

    def forward(self, heads, relations, tails, neg_heads=None, neg_tails=None):
        """
        输入维度说明:
        heads: [batch_size]
        relations: [batch_size]
        tails: [batch_size]
        """
        h = self.ent_emb(heads)  # [batch_size, dim]
        r = self.rel_emb(relations)  # [batch_size, dim]
        t = self.ent_emb(tails)  # [batch_size, dim]

        # 正样本得分
        pos_score = torch.norm(h + r - t, p=2, dim=-1)  # [batch_size]

        # 负采样训练
        if neg_heads is not None and neg_tails is not None:
            neg_h = self.ent_emb(neg_heads)  # [batch_size, dim]
            neg_t = self.ent_emb(neg_tails)  # [batch_size, dim]
            neg_score1 = torch.norm(neg_h + r - t, p=2, dim=-1)
            neg_score2 = torch.norm(h + r - neg_t, p=2, dim=-1)
            loss = F.relu(self.margin + pos_score - neg_score1).mean() \
                 + F.relu(self.margin + pos_score - neg_score2).mean()
            return loss

        return pos_score

关键修改点在 [CLS] 表征的处理：

from transformers import BertModel

class BertKGJoint(nn.Module):
    def __init__(self, bert_model, kg_model, hidden_size=768, kg_dim=256):
        super().__init__()
        self.bert = BertModel.from_pretrained(bert_model)
        self.kg = kg_model
        self.fusion = nn.Sequential(nn.Linear(hidden_size + kg_dim, hidden_size),
            nn.GELU(),
            nn.LayerNorm(hidden_size)
        )

    def forward(self, input_ids, attention_mask, ent_ids):
        # BERT 文本编码
        bert_out = self.bert(
            input_ids=input_ids,
            attention_mask=attention_mask
        )
        text_rep = bert_out.last_hidden_state[:, 0]  # [CLS]向量 [batch_size, hidden_size]

        # 知识图谱查询
        kg_rep = self.kg.get_entity_emb(ent_ids)  # [batch_size, kg_dim]

        # 特征融合
        combined = torch.cat([text_rep, kg_rep], dim=-1)  # [batch_size, hidden_size+kg_dim]
        output = self.fusion(combined)  # [batch_size, hidden_size]

        return output

子图采样：对每个实体只保留重要性最高的 k 跳邻居

def sample_subgraph(ent_id, kg, max_hop=2, max_neighbors=50):
    subgraph = set()
    queue = [(ent_id, 0)]
    while queue:
        current, hop = queue.pop(0)
        if hop > max_hop:
            continue
        neighbors = kg.get_neighbors(current)[:max_neighbors]
        subgraph.update(neighbors)
        for neighbor in neighbors:
            queue.append((neighbor[2], hop+1))  # (ent, rel, ent)
    return list(subgraph)

关系路径增强：对于重要但稀疏的关系，人工添加逆向关系

训练大型教师模型(BERT-large + KG)
使用教师模型标注未标注数据
训练小型学生模型(DistilBERT + 精简 KG)
对比原始方案与蒸馏方案的性能差异：

模型	F1-score	延迟(ms)
BERT-large+KG	89.2	120
DistilBERT+ 精简 KG	87.1	45

统计过滤：删除出现频次低于阈值的关系

DELETE WHERE {?s <rare_relation> ?o} 
GROUP BY ?relation 
HAVING (COUNT(?relation) < 5)

一致性检查：确保不存在矛盾的属性

SELECT ?entity WHERE {
    ?entity <birthDate> "1990-01-01" .
    ?entity <deathDate> "1985-01-01" .
}

众包验证：对关键实体关系进行人工复核

使用多头注意力机制区分不同上下文中的相同实体：

class EntityAwareAttention(nn.Module):
    def __init__(self, hidden_size, heads=4):
        super().__init__()
        self.mha = nn.MultiheadAttention(hidden_size, heads)
        self.entity_proj = nn.Linear(hidden_size, hidden_size)

    def forward(self, text_rep, ent_rep):
        """
        text_rep: [seq_len, batch_size, hidden_size]
        ent_rep: [batch_size, hidden_size]
        """
        ent_rep = self.entity_proj(ent_rep).unsqueeze(0)  # [1, batch_size, hidden_size]
        attn_out, _ = self.mha(
            query=ent_rep,
            key=text_rep,
            value=text_rep
        )
        return attn_out.squeeze(0)

虽然我们的实验显示加入知识图谱后模型性能提升了 3.2 个 F1 点，但如何量化评估这些提升中有多少真正来自于知识的可解释性？现有的自动评估指标 (如准确率、召回率) 难以反映模型是否真的 ” 理解 ” 了知识。可能的评估方向包括：