Detectando entidades com expressões regulares

Semelhante à detecção de entidades com dicionários, você pode usar correspondências de padrão de expressão regular para detectar entidades.

As expressões regulares não são fornecidas em arquivos como dicionários, mas, sim, na memória dentro de uma configuração de expressão regular. É possível usar várias configurações de expressão regular durante a mesma extração.

As expressões regulares que você define com o Watson Natural Language Processing podem usar limites de token. Desta forma, é possível assegurar que sua expressão regular faça a correspondência dentro de um ou mais tokens. Esta é uma clara vantagem sobre mecanismos de expressão regular mais simples, especialmente quando você trabalha com um idioma que não é separado por espaço em branco, como o chinês.

As expressões regulares são processadas por um componente dedicado chamado Rule-Based Runtime, ou RBR na forma abreviada.

Criando configurações de expressão regular

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 é usado temporariamente para armazenar os arquivos criados pelo treinamento RBR. Este diretório de módulo pode ser o mesmo diretório que você criou e usou para extração de entidade baseada em dicionário. Dicionários e expressões regulares podem ser usados na mesma execução de treinamento.

Para criar o diretório do módulo em seu bloco de notas, insira o seguinte em uma célula de código. Observe que o diretório do módulo não pode conter um traço (-).

import os
import watson_nlp
module_folder = "NLP_RBR_Module_2"
os.makedirs(module_folder, exist_ok=True)

Uma configuração de expressão regular é um dicionário Python, com os atributos a seguir:

Atributos disponíveis nas configurações de regex com seus valores, descrições de uso e indicação se necessário ou não
Atributo Valor Descrição Necessário
name sequência O nome da expressão regular. As correspondências da expressão regular no texto de entrada são marcadas com este nome na saída. Sim
regexes lista (sequência de caracteres de padrões de expressão regular baseados em Perl) Deve ser não vazio. Várias expressões regulares podem ser fornecidas. Sim
flags Sequência de caracteres delimitada de sinalizações válidas Sinalizações como UNICODE ou CASE_INSENSITIVE controlam a correspondência. Também pode ser uma combinação de sinalizações. Para as sinalizações suportadas, consulte Padrão (Java Platform SE 8). Não (padrões para DOTALL)
token_boundary.min int token_boundary indica se deve-se corresponder à expressão regular apenas nos limites de token. Especificado como um objeto dict com os atributos min e max. Não (retorna a correspondência sem sobreposição mais longa em cada posição de caractere no texto de entrada)
token_boundary.max int max é um atributo opcional para token_boundary e necessário quando o limite precisa se estender por um intervalo (entre os tokens min e max ). token_boundary.max precisa ser >= token_boundary.min Não (se token_boundary for especificado, o atributo min poderá ser especificado sozinho)
groups lista (rótulos de sequência de caracteres para grupos de correspondência) O índice de sequência na lista corresponde ao grupo combinado no padrão começando com 1, em que o índice 0 corresponde à combinação inteira. Por exemplo: regex: (a)(b) no ab com group: ['full', 'first', 'second'] gerará full: ab, first: a, second: b Não (padronizado para rotular correspondência na correspondência integral)

As configurações de expressão regular podem ser carregadas utilizando os métodos auxiliares a seguir:

  • Para carregar uma única configuração de expressão regular, use watson_nlp.toolkit.RegexConfig.load(<regex configuration>)
  • Para carregar várias configurações de expressão regular, use watson_nlp.toolkit.RegexConfig.load_all([<regex configuration>)])

Código de amostra

Esta amostra exibe como carregar duas configurações de expressão regular diferentes. A primeira configuração detecta nomes de pessoas. Ela usa o atributo de grupos para permitir fácil acesso ao nome, sobrenome e nome completo em um estágio posterior.

A segunda configuração detecta acrônimos como uma sequência de caracteres somente maiúsculos. Ao utilizar o atributo token_boundary, ele evita correspondências de palavras que contenham caracteres maiúsculos e minúsculos.

from watson_nlp.toolkit.rule_utils import RegexConfig

# Load some regex configs, for instance to match First names or acronyms
regexes = RegexConfig.load_all([
    {
        'name': 'full names',
        'regexes': ['([A-Z][a-z]*) ([A-Z][a-z]*)'],
        'groups': ['full name', 'first name', 'last name']
    },
    {
        'name': 'acronyms',
        'regexes': ['([A-Z]+)'],
        'groups': ['acronym'],
        'token_boundary': {
            'min': 1,
            'max': 1
        }
    }
])

Treinando um modelo que contenha expressões regulares

Depois de carregar as configurações de expressão regular, crie um modelo RBR usando o método RBR.train(). No método, especifique:

  • O diretório do módulo
  • O idioma do texto
  • As configurações de expressão regular a serem usadas

Este é o mesmo método que é usado para treinar a RBR com extração baseada em dicionário. É possível transmitir a configuração do dicionário na mesma chamada de método.

Código de amostra

# Train the RBR model
custom_regex_block = watson_nlp.resources.feature_extractor.RBR.train(module_path=module_folder, language='en', regexes=regexes)

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_regex_block.run('Bruce Wayne works for NASA')

Saída da amostra de código:

{(0, 11): ['regex::full names'], (0, 5): ['regex::full names'], (6, 11): ['regex::full names'], (22, 26): ['regex::acronyms']}

Para mostrar os subgrupos correspondentes ou o texto correspondente:

import json
# Get the raw response including matching groups
full_regex_result = custom_regex_block.executor.get_raw_response('Bruce Wayne works for NASA‘, language='en')
print(json.dumps(full_regex_result, indent=2))

Saída da amostra de código:

{
  "annotations": {
    "View_full names": [
      {
        "label": "regex::full names",
        "fullname": {
          "location": {
            "begin": 0,
            "end": 11
          },
          "text": "Bruce Wayne"
        },
        "firstname": {
          "location": {
            "begin": 0,
            "end": 5
          },
          "text": "Bruce"
        },
        "lastname": {
          "location": {
            "begin": 6,
            "end": 11
          },
          "text": "Wayne"
        }
      }
    ],
    "View_acronyms": [
      {
        "label": "regex::acronyms",
        "acronym": {
          "location": {
            "begin": 22,
            "end": 26
          },
          "text": "NASA"
        }
      }
    ]
  },
...
}