Detectando entidades com um dicionário customizado

Se você tiver um conjunto fixo de termos que deseja detectar, como uma lista de nomes de produtos ou de organizações, é possível criar um dicionário. A correspondência de dicionário é um recurso muito rápido e eficiente.

Os dicionários do Watson Natural Language Processing contêm recursos de correspondência avançada que vão além de uma simples correspondência de sequência de caracteres, incluindo:

  • Os termos do dicionário podem consistir em um token único, por exemplo, roda, ou vários tokens, por exemplo, volante.
  • A correspondência de termo de dicionário pode fazer distinção entre maiúsculas ou minúsculas ou não. Com uma correspondência com distinção entre maiúsculas e minúsculas, é possível assegurar que siglas, como ABS, não correspondam a termos no idioma regular, como abs, que têm um significado diferente.
  • É possível especificar como consolidar correspondências quando várias entradas de dicionário correspondem ao mesmo texto. Dadas as duas entradas do dicionário, Watson e Watson Natural Language Processing, é possível configurar qual entrada deve corresponder a "Eu gosto do Watson Natural Language Processing": seja apenas ao Watson Natural Language Processing, já que ele contém Watson, ou a ambos.
  • É possível especificar para corresponder ao lema em vez de enumerar todas as inflexões. Desta forma, a entrada de dicionário única rato detectará rato e camundongo no texto.
  • É possível anexar um rótulo a cada entrada de dicionário, por exemplo, Categoria da organização, para incluir metadados adicionais na correspondência.

Todos esses recursos podem ser configurados, para que você possa escolher a opção certa para o seu caso de uso.

Tipos de arquivos de dicionário

O Watson Natural Language Processing suporta dois tipos de arquivos de dicionários:

  • Lista de termos (terminando em .dict)

    Exemplo de lista de termos:

    Arthur
Allen
Albert
Alexa

  • Tabela (terminando em .csv)

    Exemplo de uma tabela:

    "label", "entry"
"ORGANIZATION", "NASA"
"COUNTRY", "USA"
"ACTOR", "Christian Bale"

É possível usar vários dicionários durante a mesma extração. Você também pode usar ambos os tipos ao mesmo tempo, por exemplo, executar uma única extração com três dicionários, uma lista de termos e duas tabelas.

Criando arquivos de dicionário

Comece criando um diretório de módulo dentro do seu bloco de notas. Este é um diretório dentro do sistema de arquivos de bloco de notas que será usado temporariamente para armazenar seus arquivos de dicionário.

Para criar arquivos de dicionário em seu bloco de notas:

  1. Crie um diretório de módulo. Note que o nome da pasta do módulo não pode conter traços, pois isso causará erros.
    import os
import watson_nlp
module_folder = "NLP_Dict_Module_1"
os.makedirs(module_folder, exist_ok=True)
  2. Crie arquivos de dicionário e armazene-os no diretório do módulo. É possível ler em uma lista externa ou arquivo CSV ou criar arquivos de dicionário da seguinte forma:
    # Create a term list dictionary
term_file = "names.dict"
with open(os.path.join(module_folder, term_file), 'w') as dictionary:
    dictionary.write('Bruce')
    dictionary.write('\n')
    dictionary.write('Peter')
    dictionary.write('\n')

# Create a table dictionary
table_file = 'Places.csv'
with open(os.path.join(module_folder, table_file), 'w') as places:
    places.write("\"label\", \"entry\"")
    places.write("\n")
    places.write("\"SIGHT\", \"Times Square\"")
    places.write("\n")
    places.write("\"PLACE\", \"5th Avenue\"")
    places.write("\n")

Carregando os dicionários e configurando opções de correspondência

Os dicionários podem ser carregados usando os métodos auxiliares a seguir.

  • Para carregar um único dicionário, use watson_nlp.toolkit.rule_utils.DictionaryConfig (<dictionary configuration>)
  • Para carregar vários dicionários, use watson_nlp.toolkit.rule_utils.DictionaryConfig.load_all([<dictionary configuration>)])

Para cada dicionário, é necessário especificar uma configuração de dicionário. A configuração do dicionário é um dicionário Python, com os seguintes atributos:

Atributo Valor Descrição Necessário
name sequência O nome do dicionário True
source sequência O caminho para o dicionário, relativo a module_folder True
dict_type arquivo ou tabela Se o artefato do dicionário é uma lista de termos (arquivo) ou uma tabela de mapeamentos (tabela) Nº O padrão é arquivo
consolidate ContainedWithin (Keep the longest match and deduplicate) / NotContainedWithin (Keep the shortest match and deduplicate) / ContainsButNotEqual (Keep longest match but keep duplicate matches) / ExactMatch (Deduplicate) / LeftToRight (Keep the leftmost longest non-overlapping span) O que fazer com as correspondências de dicionário que se sobrepõem. Nº O padrão é não consolidar correspondências.
case exata / sem distinção entre maiúsculas e minúsculas Se será correspondência exata ou sem distinção entre maiúsculas e minúsculas. Nº O padrão é correspondência exata.
lemma True / False Corresponder aos termos no dicionário com as lemas do texto. O dicionário deve conter apenas formas de lema. Por exemplo, inclua mouse no dicionário para corresponder ao mouse e mice no texto. Não inclua mice no dicionário. Para corresponder aos termos que consistem em vários tokens no texto, separe os lemas desses termos no dicionário por um caractere de espaço. Nº O padrão é False.
mappings.columns (mapeamentos as attribute of de colunas: {}) lista [string] Lista de cabeçalhos de coluna na mesma ordem que os presentes na tabela CSV Sim, se dict_type: table
mappings.entry (mapeamentos as attribute of de entrada: {}) sequência O nome do cabeçalho da coluna que contém a sequência para corresponder ao documento. Sim, se dict_type: table
label sequência O rótulo para anexar às correspondências. Não

Código de amostra

# Load the dictionaries
dictionaries = watson_nlp.toolkit.rule_utils.DictionaryConfig.load_all([{
    'name': 'Names',
    'source': term_file,
    'case':'insensitive'
}, {
    'name': 'places_and_sights_mappings',
    'source': table_file,
    'dict_type': 'table',
    'mappings': {
        'columns': ['label', 'entry'],
        'entry': 'entry'
    }
}])

Treinando um modelo que contém dicionários

Depois de carregar os dicionários, crie um modelo de dicionário e treine o modelo usando o método RBR.train(). No método, especifique:

  • O diretório do módulo
  • A linguagem das entradas do dicionário
  • Os dicionários a serem usados

Código de amostra

custom_dict_block = watson_nlp.resources.feature_extractor.RBR.train(module_folder,
language='en', dictionaries=dictionaries)

Aplicando o modelo em novos dados

Depois de ter treinado os dicionários, aplique o modelo em novos dados usando o método run(), tal como você usaria em qualquer um dos blocos pré-treinados existentes.

Código de amostra

custom_dict_block.run('Bruce is at Times Square')

Saída da amostra de código:

{(0, 5): ['Names'], (12, 24): ['SIGHT']}

Para mostrar os rótulos ou o nome do dicionário:

RBR_result = custom_dict_block.executor.get_raw_response('Bruce is at Times Square', language='en')
print(RBR_result)

Saída mostrando os rótulos:

{'annotations': {'View_Names': [{'label': 'Names', 'match': {'location': {'begin': 0, 'end': 5}, 'text': 'Bruce'}}], 'View_places_and_sights_mappings': [{'label': 'SIGHT', 'match': {'location': {'begin': 12, 'end': 24}, 'text': 'Times Square'}}]}, 'instrumentationInfo': {'annotator': {'version': '1.0', 'key': 'Text match extractor for NLP_Dict_Module_1'}, 'runningTimeMS': 3, 'documentSizeChars': 32, 'numAnnotationsTotal': 2, 'numAnnotationsPerType': [{'annotationType': 'View_Names', 'numAnnotations': 1}, {'annotationType': 'View_places_and_sights_mappings', 'numAnnotations': 1}], 'interrupted': False, 'success': True}}