Detecção de entidades com expressões regulares

Da mesma forma que na detecção de entidades com dicionários, você pode usar padrões de expressões regulares 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ões regulares. É possível usar várias configurações de expressões regulares durante a mesma extração.

As expressões regulares definidas com o processamento de linguagem natural d Watson podem utilizar limites de tokens. Dessa forma, você pode garantir que sua expressão regular corresponda a um ou mais tokens. Essa é uma vantagem clara em relação aos mecanismos de expressões regulares mais simples, especialmente quando se trabalha com uma língua que não é separada por espaços em branco, como o chinês.

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

Criação de configurações de expressões regulares

Comece criando um diretório de módulos dentro do seu notebook. Este é um diretório dentro do sistema de arquivos do notebook que é usado temporariamente para armazenar os arquivos criados pelo treinamento RBR. Esse diretório de módulos pode ser o mesmo diretório que você criou e utilizou para a extração de entidades baseada em dicionário. Dicionários e expressões regulares podem ser usados na mesma sessão de treinamento.

Para criar o diretório do módulo no seu notebook, digite 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 do tipo ` Python `, com os seguintes atributos:

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	Obrigatório
`name`	sequência	O nome da expressão regular. As ocorrências da expressão regular no texto de entrada são identificadas com esse nome na saída.	True
`regexes`	lista (sequência de padrões de expressões regulares em Perl)	Deve ser diferente de vazio. É possível fornecer várias expressões regulares.	True
`flags`	Sequência delimitada de sinalizadores válidos	Sinalizadores como UNICODE ou CASE_INSENSITIVE controlam a correspondência. Também pode ser uma combinação de sinalizadores. Para conhecer os sinalizadores suportados, consulte Pattern (Java Platform SE 8).	Não (o padrão é DOTALL)
`token_boundary.min`	int	`token_boundary` indica se a expressão regular deve ser aplicada apenas nos limites dos tokens. Especificado como um objeto dicionário com os `max` atributos `min` e.	Não (retorna a correspondência mais longa que não se sobreponha 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 `min` atributo pode ser especificado sozinho)
`groups`	lista (rótulos de texto para grupos correspondentes)	O índice da string na lista corresponde ao grupo correspondente no padrão, começando pelo 1, sendo que o índice 0 corresponde à correspondência completa. Por exemplo: `regex: (a)(b)` on `ab` with `group: ['full', 'first', 'second']` resultará em `full: ab, first: a, second: b`	Não (por padrão, a correspondência de rótulo é feita com base na correspondência completa)

As configurações de expressões regulares podem ser carregadas usando os seguintes métodos auxiliares:

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ões regulares, use watson_nlp.toolkit.RegexConfig.load_all([<regex configuration>)])

Amostra de código

Este exemplo mostra como carregar duas configurações diferentes de expressões regulares. A primeira configuração identifica nomes de pessoas. Ele utiliza o atributo "groups" para permitir o acesso fácil ao nome completo, nome e sobrenome posteriormente.

A segunda configuração reconhece acrônimos como uma sequência de caracteres em maiúsculas. Ao usar o atributo `token_boundary`, evita-se a correspondência em 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
        }
    }
])

Treinar um modelo que contenha expressões regulares

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

O diretório do módulo
O idioma do texto
As configurações de expressões regulares a serem utilizadas

Este é o mesmo método utilizado para treinar o RBR com extração baseada em dicionário. Você pode passar a configuração do dicionário na mesma chamada de método.

Amostra de código

# 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 a novos dados

Depois de treinar os dicionários, aplique o modelo a novos dados usando o run() método, da mesma forma que faria com qualquer um dos blocos pré-treinados existentes.

Amostra de código

custom_regex_block.run('Bruce Wayne works for NASA')

Resultado do exemplo 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))

Resultado do exemplo 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"
        }
      }
    ]
  },
...
}