Classificando o texto com um modelo de classificação customizado

Formato de dados de entrada para treinamento

Os blocos de classificação aceitam dados de treinamento em formatos CSV e JSON.

• O Formato CSV

  O arquivo CSV não deve conter nenhum cabeçalho. Cada linha no arquivo CSV representa um registro de exemplo. Cada registro possui uma ou mais colunas, em que a primeira coluna representa o texto e as colunas subsequentes representam os rótulos associados a esse texto.

  • Os algoritmos SVM e CNN não suportam dados de treinamento em que uma instância não possui rótulos. Portanto, se você estiver usando o algoritmo SVM, o algoritmo CNN ou um conjunto que inclua um desses algoritmos, cada linha do CSV deverá ter pelo menos um rótulo, ou seja, duas colunas.
  • Os algoritmos BERT-based e Slate-based Transformer suportam dados de treinamento em que cada instância tem 0, 1 ou mais de um rótulo.

  Example 1,label 1
  Example 2,label 1,label 2
  

• O Formato JSON

  Os dados de treinamento são representados como uma matriz com vários objetos JSON. Cada objeto JSON representa uma instância de treinamento, e deve ter um campo de texto e de rótulos. O texto representa o exemplo de treinamento e os rótulos armazenam os rótulos associados ao exemplo (0, 1 ou mais rótulos).

  [
      {
      "text": "Example 1",
      "labels": ["label 1"]
      },
      {
      "text": "Example 2",
      "labels": ["label 1", "label 2"]
      },
      {
      "text": "Example 3",
      "labels": []
      }
  ]
  

  Nota:

  • "labels": [] denota um exemplo sem rótulos. Os algoritmos SVM e CNN não suportam dados de treinamento em que uma instância não possui rótulos. Assim, se você estiver usando o algoritmo SVM ou o algoritmo CNN, ou um Ensemble incluindo um desses algoritmos, cada objeto JSON deve ter pelo menos um rótulo.
  • Os algoritmos BERT-based e Slate-based Transformer suportam dados de treinamento em que cada instância tem 0, 1 ou mais de um rótulo.

Requisitos de dados de entrada

Para algoritmos SVM e CNN:

• Número mínimo de rótulos exclusivos necessários: 2
• Número mínimo de exemplos de texto necessários por rótulo: 5

Para os algoritmos BERT-based e Slate-based Transformer:

• Número mínimo de rótulos exclusivos necessários: 1
• Número mínimo de exemplos de texto necessários por rótulo: 5

Os dados de treinamento no formato CSV ou JSON são convertidos em um DataStream antes do treinamento. Em vez de treinar arquivos de dados, também é possível passar fluxos de dados diretamente para as funções de treinamento de blocos de classificação.

Palavras vazias

É possível fornecer suas próprias palavras vazias que serão removidas durante o pré-processamento. Entradas de arquivo de palavras vazias são esperadas em um formato padrão: um arquivo de texto único com uma frase por linha. Palavras vazias podem ser fornecidas como uma lista ou como um arquivo em um formato padrão.

Palavras vazias podem ser usadas apenas com o classificador Ensemble.

Treinamento de algoritmos SVM

SVM é um classificador de máquina vetorial de suporte que pode ser treinado utilizando predições em qualquer tipo de entrada fornecida pelos blocos de integração ou de vetorização como vetores de recurso, por exemplo, por meio de integrações do USE (Universal Sentence Encoder) e vetorizadores do TF-IDF. Ele oferece suporte à classificação de texto multiclasse e multirrótulo e produz pontuações de confiança usando o Platt Scaling.

Para todas as opções que estão disponíveis para configurar o treinamento SVM, insira:

help(watson_nlp.blocks.classification.svm.SVM.train)

Para treinar algoritmos SVM:

1. Comece com essas etapas de pré-processamento:

   import watson_nlp
   from watson_nlp.toolkit.classification_utils.train_util import prepare_data_from_json
   from watson_nlp.blocks.classification.svm import SVM
   
   training_data_file = "train_data.json"
   
   # Load a Syntax model
   syntax_model = watson_nlp.load('syntax_izumo_en_stock')
   
   # Create datastream from training data
   train_stream = prepare_data_from_json(training_data_file, syntax_model)
   syntax_stream, labels_stream = train_stream[0], train_stream[1]
   

2. Treine o modelo de classificação usando integrações USE. Consulte Embeddings de USE pré-treinados que estão incluídos em para obter uma lista de blocos pré-treinados disponíveis.

   # download embedding
   use_embedding_model = watson_nlp.load('embedding_use_en_stock')
   
   use_train_stream = use_embedding_model.stream(syntax_stream, doc_embed_style='raw_text')
   # NOTE: doc_embed_style can be changed to `avg_sent` as well. For more information check the documentation for Embeddings
   # Or the USE run function API docs
   use_svm_train_stream = watson_nlp.data_model.DataStream.zip(use_train_stream, labels_stream)
   
   # Train SVM using Universal Sentence Encoder (USE) training stream
   classification_model = SVM.train(use_svm_train_stream)
   

Treinando o algoritmo CNN

CNN é uma arquitetura de rede convolucional simples, construída para classificação de texto de diversas classes e de diversos rótulos em textos curtos. Ele utiliza integrações do GloVe. As integrações do GloVe codificam semântica de nível de palavra em um espaço vetorial. As integrações do GloVe para cada idioma são treinadas no corpus da Wikipédia nesse idioma. Para obter informações sobre o uso de GloVe Embeddings, consulte GloVe Embeddings.

Para todas as opções que estão disponíveis para configurar o treinamento CNN, insira:

help(watson_nlp.blocks.classification.cnn.CNN.train)

Para treinar os algoritmos da CNN:

import watson_nlp
from watson_nlp.toolkit.classification_utils.train_util import prepare_data_from_json
from watson_nlp.blocks.classification.cnn import CNN

training_data_file = "train_data.json"

# Load a Syntax model
syntax_model = watson_nlp.load('syntax_izumo_en_stock')

# Create datastream from training data
train_stream = prepare_data_from_json(training_data_file, syntax_model)
syntax_stream, labels_stream = train_stream[0], train_stream[1]

# Download GloVe embeddings
glove_embedding_model = watson_nlp.load('embedding_glove_en_stock')

# Train CNN
classification_model = CNN.train(watson_nlp.data_model.DataStream.zip(syntax_stream, labels_stream), embedding=glove_embedding_model.embedding)

Treinamento do algoritmo de transformação usando o modelo IBM Slate

O algoritmo de transformação que usa um modelo Slate IBM Foundation pré-treinado pode ser usado para classificação de texto multiclasse e multirrótulo em textos curtos.

Para ver todas as opções disponíveis para configurar o treinamento do Transformer, digite:

help(watson_nlp.blocks.classification.transformer.Transformer.train)

Para obter uma lista dos modelos de Slate disponíveis, consulte esta tabela:

Para treinar os algoritmos do Transformer:

import watson_nlp
from watson_nlp.blocks.classification.transformer import Transformer
from watson_nlp.toolkit.classification_utils.train_util import prepare_stream_of_train_records
from watson_nlp import data_model as dm

training_data_file = "train_data.json"

# Create datastream from training data
train_data_stream = dm.DataStream.from_file(training_data_file)
train_record_data_stream = prepare_stream_of_train_records(train_data_stream)

# Load pre-trained slate model
pretrained_model_resource = watson_nlp.load('<pretrained Slate model>')

# Train model - note that Transformer uses Slatea by default
classification_model = Transformer.train(train_data_stream=train_record_data_stream,
                                         pretrained_model_resource=pretrained_model_resource)

Treinamento de um modelo de transformador personalizado usando um modelo fornecido por Hugging Face

Você pode treinar seu modelo personalizado baseado em transformador usando um modelo pré-treinado do site Hugging Face.

Para usar um modelo Hugging Face, especifique o nome do modelo como o parâmetro pretrained_model_resource no método train de watson_nlp.blocks.classification.transformer.Transformer. Vá para https://huggingface.co/models para copiar o nome do modelo.

Para obter uma lista de todas as opções disponíveis para configurar o treinamento de um transformador, digite este código:

help(watson_nlp.blocks.classification.transformer.Transformer.train)

Para obter informações sobre como treinar algoritmos de transformador, consulte este exemplo de código:

import watson_nlp
from watson_nlp.blocks.classification.transformer import Transformer
from watson_nlp.toolkit.classification_utils.train_util import prepare_stream_of_train_records
from watson_nlp import data_model as dm

training_data_file = "train_data.json"

# Create datastream from training data
train_data_stream = dm.DataStream.from_file(training_data_file)
train_record_data_stream = prepare_stream_of_train_records(train_data_stream)

# Specify the name of the Hugging Face model
huggingface_model_name = 'xml-roberta-base'

# Train model
classification_model = Transformer.train(train_data_stream=train_record_data_stream,
                                         pretrained_model_resource=huggingface_model_name)

Treinamento de um modelo de conjunto

O modelo de conjunto é um conjunto ponderado desses três algoritmos: CNN, SVM com TF-IDF e SVM com USE. Ele calcula a média ponderada de um conjunto de previsões de classificação usando escores de confiança. O modelo de conjunto é muito fácil de usar.

O classificador GenericEnsemble permite mais flexibilidade para o usuário escolher entre os três classificadores de base TFIDF-SVM, USE-SVM e CNN. Para textos que variam de 50 a 1.000 caracteres, o uso da combinação dos classificadores TFIDF-SVM e USE-SVM geralmente produz um bom equilíbrio entre qualidade e desempenho. Em alguns documentos médios ou longos (mais de 500 a 1000 caracteres), adicionar a CNN ao Ensemble poderia ajudar a aumentar a qualidade, mas isso geralmente acarreta um impacto significativo no desempenho do tempo de execução (menor rendimento e maior tempo de carregamento do modelo).

Para ver todas as opções disponíveis para configurar o treinamento do Ensemble, digite:

help(watson_nlp.workflows.classification.GenericEnsemble)

Para treinar algoritmos Ensemble:

import watson_nlp
from watson_nlp.workflows.classification.generic_ensemble import GenericEnsemble
from watson_nlp.workflows.classification.base_classifier import GloveCNN
from watson_nlp.workflows.classification.base_classifier import TFidfSvm

training_data_file = "train_data.json"

# Syntax model
syntax_model = watson_nlp.load('syntax_izumo_en_stock')

# GloVE Embedding model
glove_embedding_model = watson_nlp.load('embedding_glove_en_stock')

# Train classifier using the manually defined base classifier and manually defined weights¶
classification_model = GenericEnsemble.train(training_data_file,
                                             syntax_model,
                                             base_classifiers_params=[
                                                TFidfSvm.TrainParams(syntax_model=syntax_model),
                                                GloveCNN.TrainParams(syntax_model=syntax_model,
                                                                     glove_embedding_model=glove_embedding_model,
                                                                    )],
                                             weights=[2,1])

Melhores práticas de treinamento

Há determinadas restrições quanto à qualidade e quantidade de dados para assegurar que o treinamento do modelo de classificações possa ser concluído em um tempo razoável e que também atenda a vários critérios de desempenho. Elas são listadas abaixo. Note que não há restrições rígidas. No entanto, quanto mais um se afasta dessas diretrizes, maior a chance de que o modelo falhe em treinar ou o modelo não será satisfatório.

• Quantidade de dados

  • O maior número de modelos de classificação de classes que foi testado é acima de 1200.
  • O tamanho de texto mais adequado para treinamento e teste de dados para classificação é em torno de 3.000 pontos de código. No entanto, textos maiores também podem ser processados, mas o desempenho do tempo de execução pode ser mais lento.
  • O tempo de treinamento aumentará com base no número de exemplos e no número de rótulos.
  • O tempo de inferência será aumentado com base no número de rótulos.

• Qualidade de dados

  • O tamanho de cada amostra (por exemplo, número de frases em cada amostra de treinamento) pode afetar a qualidade.
  • A separação de classe é importante. Em outras palavras, as classes entre os dados de treinamento (e de teste) devem ser semanticamente distinguíveis entre si, a fim de evitar classificações equivocadas. Uma vez que os algoritmos classificadores no Watson Natural Language Processing dependem de integrações de palavras, as classes de treinamento que contiverem exemplos de texto com sobreposição de semântica demasiada podem tornar a classificação de alta qualidade computacionalmente intratável. Embora uma heurística mais sofisticada possa existir para avaliar a similaridade de semântica entre as classes, deve-se começar com um simples "teste ocular" de alguns exemplos de cada classe para discernir se eles parecem ou não separados adequadamente.
  • Recomenda-se a utilização de dados balanceados para treinamento. Idealmente deve haver aproximadamente números iguais de exemplos de cada classe nos dados de treinamento, caso contrário, os classificadores poderão ser propensos às classes com maior representação nos dados de treinamento.
  • É melhor evitar circunstâncias em que algumas classes nos dados de treinamento sejam altamente sub-representadas em comparação com outras classes.

Limitações e ressalvas:

• O bloco de classificação CNN tem um comprimento de sequência predefinido de 1.000 pontos de código. Esse limite pode ser configurado no tempo de treinamento, alterando o parâmetro max_phrase_len. Não há limite máximo para este parâmetro, mas aumentar o comprimento máximo da frase afetará o consumo de CPU e de memória.
• Os blocos de SVM não possuem esse limite de comprimento de sequência e podem ser usados com textos mais longos.

Aplicando o modelo em novos dados

Depois de ter treinado o modelo em um conjunto de dados, 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

• Para os modelos Ensemble:

  # run Ensemble model on new text
  ensemble_prediction = ensemble_classification_model.run("new input text")
  

• Para os modelos SVM e CNN, por exemplo, para CNN:

  # run Syntax model first
  syntax_result = syntax_model.run("new input text")
  # run CNN model on top of syntax result
  cnn_prediction = cnn_classification_model.run(syntax_result)
  

Escolhendo o algoritmo certo para o seu caso de uso

É necessário escolher o algoritmo do modelo que melhor se adeque ao seu caso de uso.

Ao escolher entre SVM, CNN e Transformers, considere o seguinte:

• Slate baseado em transformador

  • Escolha quando a alta qualidade é necessária e quando os recursos de computação superiores estão disponíveis.

• CNN

  • Escolha quando dados de tamanho decente estão disponíveis
  • Escolha se a integração do GloVe está disponível para o idioma necessário
  • Escolha se você tem a opção entre rótulo único versus diversos rótulos
  • O CNN faz um ajuste preciso das integrações, para que possa proporcionar o melhor desempenho para termos desconhecidos ou domínios mais recentes.

• SVM

  • Escolha se um modelo mais fácil e mais simples é necessário
  • O SVM tem os tempos de treinamento e de inferência mais rápidos
  • Escolha se o seu tamanho de conjunto de dados é pequeno

Se você selecionar SVM, será necessário considerar o seguinte ao escolher entre as várias implementações da SVM:

• Os SVMs treinam classificadores de diversos rótulos.
• Quanto maior o número de classes, mais longo será o tempo de treinamento.
• TF-IDF:
  • Escolha a vetorização TF-IDF com SVM se o conjunto de dados for pequeno, ou seja, se possui um pequeno número de classes, um pequeno número de exemplos e tamanho de texto mais curto, por exemplo, sentenças contendo menos frases.
  • O TF-IDF com SVM pode ser mais rápido do que outros algoritmos no bloco de classificação.
  • Escolha TF-IDF se as integrações para o idioma necessário não estiverem disponíveis.
• Use:
  • Escolha Universal Sentença Encoder (USE) com SVM se o conjunto de dados possuir uma ou mais sentenças no texto de entrada.
  • O USE pode se apresentar melhor em conjuntos de dados nos quais o entendimento do contexto de palavras ou de sentenças é importante.

O modelo Ensemble combina múltiplos modelos individuais (diversos) juntos para oferecer poder de predição superior. Considere os dados principais a seguir para este modelo de modelo:

• O modelo de combinação combina CNN, SVM com TF-IDF e SVM com USE.
• É o modelo mais fácil de usar.
• Ele pode proporcionar um desempenho melhor do que os algoritmos individuais.
• Funciona para todos os tipos de conjuntos de dados. No entanto, o tempo de treinamento para conjuntos de dados grandes (mais de 20.000 exemplos) pode ser alto.
• Um modelo de combinação permite que você configure pesos. Esses pesos decidem como o modelo de conjunto combina os resultados de classificadores individuais. Atualmente, a seleção de pesos é uma heurística e precisa ser definida por tentativa e erro. Os pesos padrão que são fornecidos na própria função são um bom ponto de partida para a exploração.