使用SpaCy进行复杂模式匹配：解决重叠匹配中的优先级问题-Python教程-PHP中文网

使用SpaCy进行复杂模式匹配：解决重叠匹配中的优先级问题

本文深入探讨了在spacy中进行复杂实体模式匹配时，如何处理重叠模式的优先级问题。通过分析一个具体的案例，即当短模式意外地优先于长模式时，我们展示了`matcher.add()`方法中的`greedy`参数如何有效解决这一挑战。教程将提供详细的代码示例，并解释`greedy="longest"`选项在确保匹配最长可能跨度方面的关键作用，从而帮助开发者构建更精确、更鲁棒的nlp模式匹配系统。

引言：SpaCy Matcher与模式匹配挑战

SpaCy的Matcher是一个功能强大的工具，用于基于词法、语法和自定义属性在文本中查找特定模式。它允许开发者定义复杂的令牌序列模式，以识别文本中的特定实体或短语。然而，在处理具有重叠或包含关系的模式时，可能会遇到一个常见挑战：当多个模式可以匹配同一段文本时，Matcher的默认行为可能不会优先选择我们期望的最长或最具体的匹配。

本教程将通过一个具体示例，深入探讨这一问题，并提供一个有效的解决方案，确保Matcher能够按照预期优先匹配更长的模式。

理解问题：短模式优先于长模式

假设我们有一段葡萄牙语文本，并希望识别其中表示“组件”的短语。我们定义了一系列模式，其中包含一些相互重叠的模式，例如：

[{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}] (名词介词名词形容词)
[{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}] (名词介词名词)

在文本“proteção contra descargas atmosféricas”（防雷保护）中，模式1应该匹配“proteção contra descargas atmosféricas”，而模式2则会匹配“proteção contra descargas”。如果我们的匹配逻辑没有正确处理优先级，可能会出现模式2（较短的匹配）先被识别并消耗掉令牌，导致模式1（较长的匹配）无法被发现的情况。

以下是原始问题中使用的文本和SpaCy模型加载代码：

import spacy
from spacy.matcher import Matcher
from spacy.tokens import Span

txt = "Os edifícios multifamiliares devem ser providos de proteção contra descargas atmosféricas, atendendo ao estabelecido na ABNT NBR 5419 e demais Normas Brasileiras aplicáveis, nos casos previstos na legislação vigente."
nlp = spacy.load("pt_core_news_md")
doc = nlp(txt)

# 打印分词和POS标签，以便理解文本结构
print("--- 文本分词与POS标签 ---")
for token in doc:
    print(f"{token.text:<15} {token.pos_:<10} {token.dep_:<10}")
print("-" * 30)

登录后复制

通过观察doc对象的POS标签，我们可以看到“proteção contra descargas atmosféricas”对应的POS序列确实是NOUN ADP NOUN ADJ。

初始匹配尝试与局限性

为了实现非重叠的顺序模式匹配，原始代码定义了一个自定义函数buscar_padroes_sequencialmente。这个函数旨在遍历预定义的模式列表，并在找到匹配后，将已匹配的令牌标记为已处理，以防止它们在后续的模式搜索中再次被匹配。

WowTo

用AI建立视频知识库

查看详情

def buscar_padroes_sequencialmente(doc, patterns_config):
    resultados = []
    tokens_processados = set()

    # 外层循环遍历不同的模式配置（例如，不同的标签COMPONENTE）
    for pat_config in patterns_config:
        label = pat_config["label"]
        # 为每个标签创建一个新的Matcher实例，以避免不同标签之间的干扰
        # 并且为了处理内部的多个子模式，我们会在每次外部循环时重新添加
        matcher = Matcher(doc.vocab)

        # 内层循环遍历当前标签下的所有具体模式
        for i, padrao_atual in enumerate(pat_config["pattern"]):
            # 问题在于这里，如果不对匹配行为进行控制，短模式可能优先
            matcher.add(f"{label}_{i}", [padrao_atual]) # 为每个子模式添加一个唯一ID

        # 执行匹配
        for padrao_id, inicio, fim in matcher(doc):
            rótulo_base = matcher.vocab.strings[padrao_id].split('_')[0] # 获取原始标签

            # 检查是否有任何令牌已被处理
            if any(token.i in tokens_processados for token in doc[inicio:fim]):
                continue

            # 将当前匹配的令牌索引添加到已处理集合
            tokens_processados.update(token.i for token in doc[inicio:fim])

            # 将匹配的令牌转换为Span对象并添加到结果
            span = Span(doc, inicio, fim, label=rótulo_base)
            resultados.append((rótulo_base, span))

    return resultados

# 定义模式
patterns= [
    {"label": "COMPONENTE", "pattern": [
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}], # 模式A (长)
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "ADJ"}],
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}], # 模式B (短，与模式A重叠)
        [{"POS": "NOUN", "DEP":"nsubj"},{"POS": "ADJ"},{"POS": "ADJ"}],
        [{"POS": "NOUN", "DEP":"nsubj"}],
        [{"POS": "NOUN"},{"POS": "ADJ"}]
    ]}
]

# 运行函数并打印结果
resultados = buscar_padroes_sequencialmente(doc, patterns)

print("\n--- 初始匹配结果 ---")
for i, (rotulo, span) in enumerate(resultados, start=1):
    pos_tokens = [token.pos_ for token in span]
    print(f"OSemantic {i}:", span.text, f'({rotulo})')
    print("POStoken:", pos_tokens)
    print()

登录后复制

运行上述代码，我们发现“proteção contra descargas atmosféricas”并没有被完整匹配。相反，我们得到了一个较短的匹配：“proteção contra descargas”，其POS标签为NOUN ADP NOUN。这表明模式[{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}]优先于更长的模式[{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}]被匹配。即使调整模式在列表中的顺序，也无法解决这个问题，因为Matcher在内部处理时，可能仍然会先发现并报告较短的匹配。

解决方案：使用greedy参数控制匹配行为

SpaCy Matcher.add()方法提供了一个greedy参数，用于控制当多个模式可以匹配同一段文本时，Matcher应如何选择。greedy参数可以接受两个值："FIRST"和"LONGEST"。

greedy="FIRST": Matcher将返回它找到的第一个匹配。这通常意味着匹配发生在文本中最早的位置，并且对于相同起始位置的匹配，其内部发现顺序可能决定优先级。
greedy="LONGEST": Matcher将始终尝试返回最长的可能匹配。这是解决我们当前问题的关键。当多个模式重叠时，greedy="LONGEST"会确保优先匹配覆盖最多令牌的模式。

通过将greedy="LONGEST"添加到matcher.add()调用中，我们可以强制Matcher在存在重叠匹配时，优先选择最长的匹配。

修正后的代码

我们将修改buscar_padroes_sequencialmente函数中的matcher.add()行，以包含greedy="LONGEST"参数。

def buscar_padroes_sequencialmente_corrigido(doc, patterns_config):
    resultados = []
    tokens_processados = set()

    for pat_config in patterns_config:
        label = pat_config["label"]
        matcher = Matcher(doc.vocab)

        for i, padrao_atual in enumerate(pat_config["pattern"]):
            # 关键修改：添加 greedy="LONGEST"
            matcher.add(f"{label}_{i}", [padrao_atual], greedy="LONGEST") 

        # 执行匹配
        for padrao_id, inicio, fim in matcher(doc):
            rótulo_base = matcher.vocab.strings[padrao_id].split('_')[0]

            # 检查是否有任何令牌已被处理
            if any(token.i in tokens_processados for token in doc[inicio:fim]):
                continue

            # 将当前匹配的令牌索引添加到已处理集合
            tokens_processados.update(token.i for token in doc[inicio:fim])

            # 将匹配的令牌转换为Span对象并添加到结果
            span = Span(doc, inicio, fim, label=rótulo_base)
            resultados.append((rótulo_base, span))

    return resultados

# 运行修正后的函数并打印结果
resultados_corrigidos = buscar_padroes_sequencialmente_corrigido(doc, patterns)

print("\n--- 修正后的匹配结果 ---")
for i, (rotulo, span) in enumerate(resultados_corrigidos, start=1):
    pos_tokens = [token.pos_ for token in span]
    print(f"OSemantic {i}:", span.text, f'({rotulo})')
    print("POStoken:", pos_tokens)
    print()

登录后复制

运行修正后的代码，我们可以看到现在“proteção contra descargas atmosféricas”被正确地识别为COMPONENTE，其POS标签为NOUN ADP NOUN ADJ。这证明了greedy="LONGEST"参数的有效性。

完整示例代码

import spacy
from spacy.matcher import Matcher
from spacy.tokens import Span

# 示例文本和SpaCy模型加载
txt = "Os edifícios multifamiliares devem ser providos de proteção contra descargas atmosféricas, atendendo ao estabelecido na ABNT NBR 5419 e demais Normas Brasileiras aplicáveis, nos casos previstos na legislação vigente."
nlp = spacy.load("pt_core_news_md")
doc = nlp(txt)

# 打印分词和POS标签，以便理解文本结构
print("--- 文本分词与POS标签 ---")
for token in doc:
    print(f"{token.text:<15} {token.pos_:<10} {token.dep_:<10}")
print("-" * 30)

# 定义模式
patterns = [
    {"label": "COMPONENTE", "pattern": [
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}], # 模式A (长)
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "ADJ"}],
        [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}], # 模式B (短，与模式A重叠)
        [{"POS": "NOUN", "DEP":"nsubj"},{"POS": "ADJ"},{"POS": "ADJ"}],
        [{"POS": "NOUN", "DEP":"nsubj"}],
        [{"POS": "NOUN"},{"POS": "ADJ"}]
    ]}
]

# 修正后的匹配函数
def buscar_padroes_sequencialmente_corrigido(doc, patterns_config):
    resultados = []
    tokens_processados = set()

    for pat_config in patterns_config:
        label = pat_config["label"]
        matcher = Matcher(doc.vocab)

        for i, padrao_atual in enumerate(pat_config["pattern"]):
            # 关键修改：添加 greedy="LONGEST"
            # 确保在重叠匹配中优先选择最长的模式
            matcher.add(f"{label}_{i}", [padrao_atual], greedy="LONGEST") 

        # 执行匹配
        for padrao_id, inicio, fim in matcher(doc):
            rótulo_base = matcher.vocab.strings[padrao_id].split('_')[0]

            # 检查是否有任何令牌已被处理，以实现非重叠匹配
            if any(token.i in tokens_processados for token in doc[inicio:fim]):
                continue

            # 将当前匹配的令牌索引添加到已处理集合
            tokens_processados.update(token.i for token in doc[inicio:fim])

            # 将匹配的令牌转换为Span对象并添加到结果
            span = Span(doc, inicio, fim, label=rótulo_base)
            resultados.append((rótulo_base, span))

    return resultados

# 运行修正后的函数并打印结果
resultados_corrigidos = buscar_padroes_sequencialmente_corrigido(doc, patterns)

print("\n--- 修正后的匹配结果 ---")
for i, (rotulo, span) in enumerate(resultados_corrigidos, start=1):
    pos_tokens = [token.pos_ for token in span]
    print(f"OSemantic {i}:", span.text, f'({rotulo})')
    print("POStoken:", pos_tokens)
    print()

登录后复制

注意事项与总结

greedy参数的重要性：在设计SpaCy Matcher模式时，尤其当存在重叠或包含关系的模式时，greedy参数是控制匹配行为的关键。greedy="LONGEST"能够有效解决短模式优先于长模式的问题，确保更具体、更完整的实体被识别。
模式顺序与greedy：虽然greedy="LONGEST"解决了长度优先级问题，但在某些复杂场景下，模式在Matcher.add()中的添加顺序仍然可能影响匹配结果，特别是在多个长度相同的模式重叠时。通常建议将更具体或更长的模式放在前面，但greedy参数提供了更强大的控制。
自定义匹配逻辑：本教程中的buscar_padroes_sequencialmente_corrigido函数通过维护一个tokens_processados集合，实现了非重叠的顺序匹配。这对于确保每个令牌只属于一个匹配结果非常有用。
性能考虑：添加大量复杂模式或在大型文档上运行Matcher时，应注意性能。greedy="LONGEST"可能会略微增加匹配的计算复杂性，因为它需要评估所有可能的匹配以找到最长的。
调试：当匹配结果不符合预期时，打印doc的令牌及其属性（如token.text, token.pos_, token.dep_）是非常有用的调试方法，可以帮助理解文本结构和模式匹配的潜在问题。

通过理解和恰当使用Matcher.add()中的greedy参数，开发者可以构建出更加精确和鲁棒的SpaCy模式匹配系统，有效处理各种复杂的文本分析场景。

以上就是使用SpaCy进行复杂模式匹配：解决重叠匹配中的优先级问题的详细内容，更多请关注php中文网其它相关文章！