图神经网络在自然语言处理中的应用：文本图构建与表示学习

图神经网络在自然语言处理中的应用：文本图构建与表示学习

【免费下载链接】pytorch_geometric 项目地址: https://gitcode.com/gh_mirrors/pyt/pytorch_geometric

引言：突破序列建模的语义壁垒

你是否注意到传统自然语言处理（Natural Language Processing, NLP）模型在处理长文本依赖关系时的局限性？当面对需要理解句子间逻辑关联、实体共现关系或文档层级结构的任务时，基于序列的Transformer架构往往因注意力机制的二次复杂度而难以高效建模。图神经网络（Graph Neural Network, GNN）通过将文本建模为图结构（文本图），为突破这一困境提供了全新范式。本文将系统介绍如何利用PyTorch Geometric（PyG）构建文本图并实现高效表示学习，读完你将掌握：

• 文本图的核心构建方法（节点定义、边关系设计、异构图表示）
• PyG中处理文本图数据的关键API与数据结构
• 基于GNN的文本表示学习模型实现（含完整代码示例）
• 三个典型NLP应用场景的端到端解决方案

文本图构建基础：从非结构化文本到结构化图

文本图的核心构成要素

文本图（Text Graph）通过将语言单元映射为图节点，语义关系映射为图边，实现对文本语义结构的显式建模。其核心构成包括：

节点类型	定义示例	数据来源	PyG实现类
词节点（Word Node）	词汇表中的唯一词项	分词后的文本序列	torch_geometric/data/data.py
句子节点（Sentence Node）	文档中的句子单元	句分割后的文本块	torch_geometric/data/hetero_data.py
实体节点（Entity Node）	命名实体（如人名、组织）	NER模型识别结果	torch_geometric/data/storage.py
文档节点（Document Node）	完整文档单元	文档级文本数据	torch_geometric/data/in_memory_dataset.py

边关系设计是文本图构建的核心挑战，常见边类型包括：

文本图构建的三大策略

1. 基于共现的无监督构建

通过滑动窗口捕捉词共现关系，适用于缺乏标注数据的场景：

from torch_geometric.data import Data
import torch
from collections import defaultdict

def build_word_cooccurrence_graph(text, window_size=3):
    words = text.split()
    word2id = {word: i for i, word in enumerate(set(words))}
    edge_index = []
    
    # 构建共现边
    for i in range(len(words)):
        for j in range(max(0, i-window_size), min(len(words), i+window_size+1)):
            if i != j:
                u = word2id[words[i]]
                v = word2id[words[j]]
                edge_index.append([u, v])
    
    # 转换为PyG格式
    edge_index = torch.tensor(edge_index).t().contiguous()
    x = torch.randn(len(word2id), 300)  # 随机初始化词嵌入
    return Data(x=x, edge_index=edge_index)

2. 基于知识的半监督构建

融合外部知识图谱增强语义关联，如利用WordNet构建同义词边：

from torch_geometric.data import HeteroData
import torch

def build_heterogeneous_text_graph(document, entity_links, wordnet_synonyms):
    hetero_data = HeteroData()
    
    # 添加词节点
    words = list(set(document.split()))
    hetero_data['word'].x = torch.randn(len(words), 300)
    
    # 添加实体节点
    entities = list(entity_links.keys())
    hetero_data['entity'].x = torch.randn(len(entities), 300)
    
    # 添加词-实体关联边
    word_entity_edges = []
    for entity, words in entity_links.items():
        e_id = entities.index(entity)
        for word in words:
            if word in words:
                w_id = words.index(word)
                word_entity_edges.append((w_id, e_id))
    
    hetero_data['word', 'mentions', 'entity'].edge_index = torch.tensor(
        word_entity_edges).t().contiguous()
    
    # 添加同义词边
    synonym_edges = []
    for word, synonyms in wordnet_synonyms.items():
        if word in words:
            w_id = words.index(word)
            for syn in synonyms:
                if syn in words:
                    syn_id = words.index(syn)
                    synonym_edges.append((w_id, syn_id))
    
    hetero_data['word', 'synonym', 'word'].edge_index = torch.tensor(
        synonym_edges).t().contiguous()
    
    return hetero_data

3. 基于任务的有监督构建

针对特定NLP任务设计任务相关边，如在关系抽取任务中添加实体对关系边。PyG的异构图数据结构完美支持这种复杂场景：

# 异构图构建示例（DBLP数据集）
from torch_geometric.datasets import DBLP
from torch_geometric.transforms import Constant

dataset = DBLP(root='data/DBLP', transform=Constant(node_types='conference'))
data = dataset[0]
print(data)
# 输出：HeteroData(
#   author={ x=[4057, 128], y=[4057], train_mask=[4057], val_mask=[4057], test_mask=[4057] },
#   paper={ x=[14328, 128] },
#   conference={ x=[20, 1] },
#   term={ x=[7723, 128] },
#   (author, writes, paper)={ edge_index=[2, 19645] },
#   (paper, published_in, conference)={ edge_index=[2, 14328] },
#   (paper, has_term, term)={ edge_index=[2, 85810] },
#   (author, affiliated_with, institution)={ edge_index=[2, 5342] }
# )

上述代码来自examples/hetero/hetero_conv_dblp.py，展示了学术文献场景下的异构图构建，包含作者、论文、会议等多种节点类型及写作、发表等多种关系类型。

PyG文本图数据处理核心技术

异构图数据结构与操作

PyG通过HeteroData类支持文本图的复杂异构图表示，其核心设计如下：

处理异构图的关键API包括：

• data.metadata(): 获取异构图的元数据（节点类型和边类型）
• HeteroConv: 支持异构卷积操作的封装类
• to_hetero(): 将同构GNN模型转换为异构GNN模型

文本图数据加载与批处理

PyG提供专为图数据设计的加载器，解决文本图的批处理挑战：

from torch_geometric.loader import DataLoader, NeighborLoader

# 1. 普通图数据加载
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# 2. 大图邻居采样（适用于大型文本图）
loader = NeighborLoader(
    data,
    num_neighbors=[10, 5],  # 每层采样的邻居数
    batch_size=128,
    input_nodes=('author', data['author'].train_mask),  # 指定输入节点
)

for batch in loader:
    print(f'Batch size: {batch.num_nodes}')
    print(f'Node types in batch: {batch.node_types}')

文本表示学习的GNN模型实现

同构文本图的表示学习

基于GCN的文本分类模型

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

class TextGCN(torch.nn.Module):
    def __init__(self, num_features, hidden_channels, num_classes):
        super().__init__()
        self.conv1 = GCNConv(num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, num_classes)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

# 模型训练
model = TextGCN(num_features=300, hidden_channels=128, num_classes=10)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
criterion = torch.nn.CrossEntropyLoss()

def train():
    model.train()
    optimizer.zero_grad()
    out = model(data.x, data.edge_index)
    loss = criterion(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()
    return loss.item()

异构文本图的表示学习

利用PyG实现异构GNN模型处理复杂文本图：

from torch_geometric.nn import HeteroConv, SAGEConv, Linear

class HeteroTextGNN(torch.nn.Module):
    def __init__(self, metadata, hidden_channels, out_channels, num_layers):
        super().__init__()
        self.convs = torch.nn.ModuleList()
        for _ in range(num_layers):
            conv = HeteroConv({
                edge_type: SAGEConv((-1, -1), hidden_channels)
                for edge_type in metadata[1]
            })
            self.convs.append(conv)
        self.lin = Linear(hidden_channels, out_channels)

    def forward(self, x_dict, edge_index_dict):
        for conv in self.convs:
            x_dict = conv(x_dict, edge_index_dict)
            x_dict = {key: F.leaky_relu(x) for key, x in x_dict.items()}
        return self.lin(x_dict['author'])  # 针对作者分类任务

# 模型初始化与训练
model = HeteroTextGNN(data.metadata(), hidden_channels=64, out_channels=4, num_layers=2)
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)

def train():
    model.train()
    optimizer.zero_grad()
    out = model(data.x_dict, data.edge_index_dict)
    mask = data['author'].train_mask
    loss = F.cross_entropy(out[mask], data['author'].y[mask])
    loss.backward()
    optimizer.step()
    return float(loss)

完整实现可参考examples/hetero/hetero_conv_dblp.py，该示例展示了如何使用异构图卷积网络解决作者分类任务。

典型应用场景与实战案例

场景一：文本分类任务

基于文档-句子-词三级文本图的层次化分类模型：

实现要点：

1. 使用HeteroData构建三级节点结构
2. 应用HeteroConv分别处理不同层级关系
3. 融合多层级特征进行最终分类

场景二：实体关系抽取

基于实体-关系二部图的抽取模型：

from torch_geometric.nn import GATConv

class RelationExtractionGAT(torch.nn.Module):
    def __init__(self, hidden_channels, num_relations):
        super().__init__()
        self.conv1 = GATConv(hidden_channels, hidden_channels)
        self.conv2 = GATConv(hidden_channels, num_relations)
        
    def forward(self, x, edge_index, edge_type):
        x = self.conv1(x, edge_index).relu()
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x[edge_index[0]]  # 返回边预测结果

场景三：文档推荐系统

基于异构图的协同过滤推荐模型：

# 参考[examples/hetero/recommender_system.py](https://gitcode.com/gh_mirrors/pyt/pytorch_geometric/blob/a1251ab36449f40dd682d4598de53561322cd447/examples/hetero/recommender_system.py?utm_source=gitcode_repo_files)
from torch_geometric.nn import HGTConv

class RecommenderHGT(torch.nn.Module):
    def __init__(self, metadata, hidden_channels, out_channels, num_heads, num_layers):
        super().__init__()
        self.lin_dict = torch.nn.ModuleDict()
        for node_type in metadata[0]:
            self.lin_dict[node_type] = Linear(-1, hidden_channels)
            
        self.convs = torch.nn.ModuleList()
        for _ in range(num_layers):
            conv = HGTConv(hidden_channels, hidden_channels, metadata, num_heads)
            self.convs.append(conv)
            
        self.lin = Linear(hidden_channels, out_channels)
        
    def forward(self, x_dict, edge_index_dict):
        x_dict = {
            node_type: self.lin_dictnode_type.relu_()
            for node_type, x in x_dict.items()
        }
        
        for conv in self.convs:
            x_dict = conv(x_dict, edge_index_dict)
            
        return self.lin(x_dict['user'])

挑战与未来方向

当前技术瓶颈

1. 动态文本图处理：文本是动态演化的（如新词出现、语义变化），现有静态GNN难以适应
2. 大规模文本图效率：面对百万级词汇表的文本图，现有GNN的计算复杂度仍然过高
3. 低资源场景适应性：在少样本或零样本场景下，文本图构建质量显著下降

PyG生态的解决方案

PyG提供多种工具应对上述挑战：

• 大图处理：torch_geometric/loader/neighbor_loader.py实现的邻居采样技术
• 动态图支持：torch_geometric/data/dynamic.py提供的动态图数据结构
• 分布式训练：torch_geometric/distributed/目录下的分布式训练组件

总结与学习资源

本文系统介绍了文本图构建的核心方法与基于PyG的表示学习实现，关键要点包括：

1. 文本图构建的三大策略：共现无监督、知识半监督和任务有监督
2. PyG异构图数据结构HeteroData是处理复杂文本图的核心工具
3. HeteroConv和to_hetero()为异构文本图模型提供便捷实现途径
4. 邻居采样技术是处理大规模文本图的关键

进阶学习资源

• 官方文档：docs/source/tutorial/index.rst
• 异构图教程：examples/hetero/目录下的完整示例
• GNN模型库：torch_geometric/nn/conv/提供的卷积层实现
• 分布式训练：examples/multi_gpu/展示的大规模训练方案

社区贡献与反馈

欢迎通过项目GitHub仓库提交issue或PR，参与文本图处理工具的开发与改进。特别推荐贡献：

• 文本图专用转换工具（torch_geometric/transforms/）
• NLP任务特定数据集（torch_geometric/datasets/）
• 预训练文本图模型（examples/contrib/）

通过将GNN与NLP深度融合，我们正开启语言理解的新篇章。PyG作为领先的图学习框架，为这一交叉领域提供了强大的技术支撑。期待你基于本文介绍的方法，开发出更创新的文本图模型！

附录：PyG文本图处理常用API速查

功能描述	API路径	关键方法
异构图数据结构	torch_geometric/data/hetero_data.py	HeteroData, metadata(), to_homogeneous()
异构卷积层	torch_geometric/nn/conv/hetero_conv.py	HeteroConv, forward()
图批处理	torch_geometric/loader/dataloader.py	DataLoader, batch_size, shuffle
邻居采样	torch_geometric/loader/neighbor_loader.py	NeighborLoader, num_neighbors
异构模型转换	torch_geometric/nn/to_hetero.py	to_hetero(), to_hetero_with_bases()

【免费下载链接】pytorch_geometric 项目地址: https://gitcode.com/gh_mirrors/pyt/pytorch_geometric