spaCy Matcher重叠匹配优化技巧

本教程探讨在使用spaCy的`Matcher`进行文本模式匹配时，如何解决因模式重叠导致的匹配不准确问题。当存在多个可匹配相同文本段但长度不同的模式时，`Matcher`默认行为可能无法优先选择最长或最特定的模式。通过在`Matcher.add()`方法中设置`greedy="LONGEST"`参数，可以确保匹配器优先返回最长的匹配项，从而有效解决模式优先级冲突，提高匹配准确性。

引言：spaCy Matcher的挑战

spaCy是一个强大的自然语言处理库，其Matcher模块允许开发者基于词法属性（如词性、依赖关系、文本内容等）定义复杂的模式，从而高效地从文本中提取特定信息。然而，在实际应用中，我们经常会遇到这样的场景：为同一类实体定义了多个模式，而这些模式之间可能存在重叠，即一个模式是另一个模式的子集。例如，我们可能定义了[NOUN, ADP, NOUN]（名词、介词、名词）和[NOUN, ADP, NOUN, ADJ]（名词、介词、名词、形容词）两种模式来识别复合组件。在这种情况下，Matcher的默认行为可能不会优先选择更长、更具体的模式，从而导致匹配结果不准确。

问题场景复现

为了更好地理解这个问题，我们来看一个具体的例子。假设我们有以下葡萄牙语句子，并希望识别其中的“组件”：

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."

import spacy
nlp = spacy.load("pt_core_news_md")
doc = nlp(txt)

print("原始文本分词及词性标注:")
for token in doc:
    print(f"{token.text:<15} {token.pos_:<10} {token.dep_}")
print("-" * 30)

输出示例：

原始文本分词及词性标注:
Os              DET        det
edifícios       NOUN       nsubj:pass
multifamiliares ADJ        amod
devem           AUX        aux
ser             AUX        aux:pass
providos        VERB       ROOT
de              ADP        case
proteção        NOUN       obl
contra          ADP        case
descargas       NOUN       nmod
atmosféricas    ADJ        amod
,               PUNCT      punct
atendendo       VERB       advcl
ao              ADP        case
estabelecido    VERB       obl
na              ADP        case
ABNT            PROPN      nmod
NBR             PROPN      flat:name
5419            NUM        flat:name
e               CCONJ      cc
demais          ADJ        amod
Normas          NOUN       conj
Brasileiras     ADJ        amod
aplicáveis      ADJ        amod
,               PUNCT      punct
nos             ADP        case
casos           NOUN       obl
previstos       VERB       acl
na              ADP        case
legislação      NOUN       nmod
vigente         ADJ        amod
.               PUNCT      punct
------------------------------

我们定义了一组用于识别“COMPONENTE”的模式，其中包括一个较短的模式[NOUN, ADP, NOUN]和一个较长的模式[NOUN, ADP, NOUN, ADJ]：

patterns = [
    {"label": "COMPONENTE", "pattern": [
        [{"POS": "NOUN"}, {"POS": "ADP"}, {"POS": "NOUN"}, {"POS": "ADJ"}], # 模式1：名词 介词 名词 形容词 (期望匹配 "proteção contra descargas atmosféricas")
        [{"POS": "NOUN"}, {"POS": "ADP"}, {"POS": "ADJ"}],
        [{"POS": "NOUN"}, {"POS": "ADP"}, {"POS": "NOUN"}], # 模式3：名词 介词 名词 (可能导致 "proteção contra descargas" 被匹配)
        [{"POS": "NOUN", "DEP": "nsubj"}, {"POS": "ADJ"}, {"POS": "ADJ"}],
        [{"POS": "NOUN", "DEP": "nsubj"}],
        [{"POS": "NOUN"}, {"POS": "ADJ"}]
    ]}
]

为了避免重复匹配，我们使用了一个自定义的顺序搜索函数：

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

def buscar_padroes_sequencialmente_original(doc, all_patterns_dict):
    resultados = []
    tokens_processados = set()

    for pat_entry in all_patterns_dict:
        label = pat_entry["label"]
        patterns_for_label = pat_entry["pattern"]

        matcher = Matcher(doc.vocab)
        # 原始问题中的添加模式方式：循环添加，但没有指定greedy参数
        for i, padrao_atual in enumerate(patterns_for_label):
            matcher.add(f"{label}_{i}", [padrao_atual]) # 为每个子模式分配唯一ID

        for padrao_id, inicio, fim in matcher(doc):
            rótulo = doc.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(doc, inicio, fim, label=rótulo)
            resultados.append((rótulo, span))

    return resultados

resultados = buscar_padroes_sequencialmente_original(doc, patterns)

print("\n--- 原始代码运行结果 ---")
print("Frase:", txt)
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"，其词性序列为['NOUN', 'ADP', 'NOUN', 'ADJ']。然而，实际输出却是：

--- 原始代码运行结果 ---
Frase: 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.
OSemantic 1: edifícios multifamiliares (COMPONENTE)
POStoken: ['NOUN', 'ADJ']

OSemantic 2: proteção contra descargas (COMPONENTE)
POStoken: ['NOUN', 'ADP', 'NOUN']

OSemantic 3: Normas Brasileiras (COMPONENTE)
POStoken: ['NOUN', 'ADJ']

OSemantic 4: legislação vigente (COMPONENTE)
POStoken: ['NOUN', 'ADJ']

可以看到，"proteção contra descargas atmosféricas"被错误地匹配成了"proteção contra descargas"，对应的是较短的模式[NOUN, ADP, NOUN]，而我们期望的[NOUN, ADP, NOUN, ADJ]模式却没有被匹配。这是因为在默认情况下，当多个模式可以匹配同一段文本时，Matcher可能优先返回在内部处理顺序中先遇到的模式，而不是最长的模式。

解决方案：利用greedy="LONGEST"参数

spaCy Matcher在add()方法中提供了一个greedy参数，专门用于解决这种模式优先级冲突。greedy参数可以接收两个值："FIRST"和"LONGEST"。

• greedy="FIRST"：当多个模式匹配到相同的文本跨度时，优先返回在Matcher内部添加时顺序靠前的模式。
• greedy="LONGEST"：当多个模式匹配到相同的文本跨度时，优先返回匹配长度最长的模式。如果存在多个相同长度的最长匹配，则选择内部顺序靠前的那个。

对于我们遇到的问题，即希望优先匹配更长、更具体的模式，greedy="LONGEST"正是我们需要的解决方案。通过在matcher.add()方法中设置此参数，Matcher将自动在所有可匹配的模式中选择最长的结果。

需要注意的是，Matcher.add()方法可以接收一个列表的模式，作为同一个规则ID下的备选模式。当我们将所有相关模式一次性添加到Matcher时，greedy参数将作用于这些模式之间的选择。

优化后的代码实现

我们将修改buscar_padroes_sequencialmente函数，在matcher.add()方法中加入greedy="LONGEST"参数。为了确保greedy参数能正确作用于同一标签下的所有模式，我们将这些模式一次性添加。

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

def buscar_padroes_sequencialmente_optimizado(doc, all_patterns_dict):
    resultados = []
    tokens_processados = set()

    for pat_entry in all_patterns_dict:
        label = pat_entry["label"]
        patterns_for_label = pat_entry["pattern"]

        matcher = Matcher(doc.vocab)
        # 关键改动：将同一标签下的所有模式一次性添加，并设置greedy="LONGEST"
        matcher.add(label, patterns_for_label, greedy="LONGEST")

        for padrao_id, inicio, fim in matcher(doc):
            rótulo = doc.vocab.strings[padrao_id]

            # 检查当前匹配的任何token是否已被处理
            if any(token.i in tokens_processados for token in doc[inicio:fim]):
                continue

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

            # 创建Span对象
            span = Span(doc, inicio, fim, label=rótulo)
            resultados.