Configurar o AutoML para treinar um modelo de processamento de linguagem natural

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Neste artigo, você aprenderá a treinar modelos de NLP (processamento de idioma natural) com o ML automatizado no Azure Machine Learning. É possível criar modelos de NLP com ML automatizado por meio do SDK do Python v2 do Azure Machine Learning ou da CLI do Azure Machine Learning v2.

O ML automatizado oferece suporte a NLP, o que permite que profissionais de ML e cientistas de dados tragam seus próprios dados de texto e criem modelos personalizados para tarefas de NLP. As tarefas NPL incluem classificação de texto muticlasse, classificação de texto multirótulo e NER (reconhecimento de entidade nomeada).

Você pode se integrar com facilidade com a funcionalidade de rotulagem de dados do Azure Machine Learning para rotular os dados de texto ou trazer os seus dados rotulados existentes. O ML automatizado fornece a opção de usar o treinamento distribuído em clusters de computação com várias GPUs para ter um treinamento de modelo mais rápido. O modelo resultante pode ser operacionalizado em escala, usando as funcionalidades de MLOps do Azure Machine Learning.

Pré-requisitos

Selecionar sua tarefa de NLP

Determine qual tarefa de NLP você deseja realizar. Atualmente, o ML automatizado dá suporte às tarefas de NLP de rede neural profunda a seguir.

Thresholding

Thresholding é o recurso multi-rótulo que permite aos usuários escolher o limite do qual as probabilidades previstas levarão a um rótulo positivo. Valores mais baixos permitem mais rótulos, o que é melhor quando os usuários se preocupam mais com o recall, mas essa opção pode levar a mais falsos positivos. Valores mais altos permitem menos rótulos e, portanto, são melhores para usuários que se preocupam com a precisão, mas essa opção pode levar a mais falsos negativos.

Preparando dados

Em experimentos de NLP no ML automatizado, você pode trazer os dados no formato .csv em tarefas de classificação de várias classes ou vários rótulos. Para tarefas de NER, os arquivos .txt de duas colunas que usam um espaço como o separador e aderem ao formato CoNLL são compatíveis. As seções a seguir fornecem detalhes sobre o formato de dados aceito em cada tarefa.

Multiclasse

Para classificação multiclasse, o conjunto de dados pode conter várias colunas de texto e exatamente uma coluna de rótulo. O exemplo a seguir tem apenas uma coluna de texto.

text,labels
"I love watching Chicago Bulls games.","NBA"
"Tom Brady is a great player.","NFL"
"There is a game between Yankees and Orioles tonight","MLB"
"Stephen Curry made the most number of 3-Pointers","NBA"

Multirrótulo

Para a classificação multirrótulo, as colunas do conjunto de dados seriam iguais às da classificação multiclasse, no entanto, há requisitos de formato especiais para os dados na coluna de rótulo. Os dois formatos e exemplos aceitos estão na tabela a seguir.

Dados de exemplo de multirrótulo em formato de texto sem formatação.

text,labels
"I love watching Chicago Bulls games.","basketball"
"The four most popular leagues are NFL, MLB, NBA and NHL","football,baseball,basketball,hockey"
"I like drinking beer.",""

Dados de exemplo de multirrótulo no formato de lista em Python com aspas.

text,labels
"I love watching Chicago Bulls games.","['basketball']"
"The four most popular leagues are NFL, MLB, NBA and NHL","['football','baseball','basketball','hockey']"
"I like drinking beer.","[]"

NER (reconhecimento de entidade nomeada)

Ao contrário das classificações multiclasse ou multirrótulo, que usam os conjuntos de dados no formato .csv, o reconhecimento de entidade nomeada requer o formato CoNLL. O arquivo precisa conter exatamente duas colunas e, em cada linha, o token e o rótulo são separados por um espaço.

Por exemplo,

Hudson B-loc
Square I-loc
is O
a O
famous O
place O
in O
New B-loc
York I-loc
City I-loc

Stephen B-per
Curry I-per
got O
three O
championship O
rings O

Validação de dados

Antes de treinar um modelo, o ML automatizado aplica verificações de validação de dados nos dados de entrada para garantir que os dados possam ser pré-processados corretamente. Se qualquer uma dessas verificações falhar, a execução falhará e uma mensagem de erro relevante será exibida. Veja a seguir os requisitos para ser aprovado nas verificações de validação de dados de cada tarefa.

Configurar o experimento

A funcionalidade de NLP do ML automatizado é disparada por meio de trabalhos do tipo automl específicos da tarefa, que é o mesmo fluxo de trabalho para enviar experimentos de ML automatizado para tarefas de classificação, regressão e previsão. Os parâmetros são definidos da mesma forma que nesses experimentos, como experiment_name, compute_name e entradas de dados.

No entanto, há diferenças importantes:

• Você pode ignorar primary_metric, pois ele serve apenas para fins de relatório. Atualmente, o ML automatizado treina apenas um modelo por execução para NLP e não há nenhuma seleção de modelo.
• O parâmetro label_column_name só é necessário para tarefas de classificação de textos com multiclasse e multirrótulo.
• Se mais de 10% das amostras no conjunto de dados contiverem mais de 128 tokens, ele será considerado de longo alcance.
  • Para usar o recurso de texto de longo alcance, é necessário usar um NC6 ou SKUs superiores/melhores para GPU, como as séries NCv3 ou ND.

# general job parameters
compute_name = "gpu-cluster"
exp_name = "dpv2-nlp-text-classification-experiment"

# Create the AutoML job with the related factory-function.
text_classification_job = automl.text_classification(
    compute=compute_name,
    # name="dpv2-nlp-text-classification-multiclass-job-01",
    experiment_name=exp_name,
    training_data=my_training_data_input,
    validation_data=my_validation_data_input,
    target_column_name="Sentiment",
    primary_metric="accuracy",
    tags={"my_custom_tag": "My custom value"},
)

text_classification_job.set_limits(timeout=120)

Configurações de idioma

Como parte da funcionalidade do NLP, o ML automatizado dá suporte a 104 idiomas que usam modelos de DNN de texto pré-treinados multilíngues e com um idioma específico, como a família de modelos BERT. Atualmente, a seleção de idioma usa como padrão o inglês.

A tabela a seguir resume qual modelo é aplicado com base no tipo de tarefa e idioma. Confira a lista completa dos idiomas com suporte e os respectivos códigos.

featurization:
   dataset_language: "eng"

text_classification_job.set_featurization(dataset_language='eng')

Treinamento distribuído

Você também pode executar seus experimentos de NLP com o treinamento distribuído em um cluster de cálculo do Azure Machine Learning.

max_concurrent_iterations = number_of_vms
enable_distributed_dnn_training = True

Enviar o trabalho do AutoML

az ml job create --file ./hello-automl-job-basic.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

returned_job = ml_client.jobs.create_or_update(
    text_classification_job
)  # submit the job to the backend

print(f"Created job: {returned_job}")
ml_client.jobs.stream(returned_job.name)

Exemplos de código

Varredura de modelo e ajuste de hiperparâmetros (versão prévia)

O NLP do AutoML permite fornecer uma lista de modelos e combinações de hiperparâmetros por meio do espaço de pesquisa de hiperparâmetros na configuração. O Hyperdrive gera diversas execuções filhas, cada uma como uma execução de ajuste detalhado para um determinado modelo de NLP e um conjunto de valores de hiperparâmetro escolhidos e varridos com base no espaço de pesquisa fornecido.

Algoritmos de modelo com suporte

Todos os modelos de DNN de texto pré-treinados atualmente disponíveis no NLP do AutoML para ajuste detalhado estão listados abaixo:

• bert-base-cased
• bert-large-uncased
• bert-base-multilingual-cased
• bert-base-german-cased
• bert-large-cased
• distilbert-base-cased
• distilbert-base-uncased
• roberta-base
• roberta-large
• distilroberta-base
• xlm-roberta-base
• xlm-roberta-large
• xlnet-base-cased
• xlnet-large-cased

Observe que os modelos grandes são maiores do que as contrapartes básicas. Eles geralmente são mais eficientes, mas ocupam mais memória da GPU e tempo para treinamento. Por isso, seus requisitos de SKU são mais rigorosos: recomenda-se a execução em VMs da série ND para obter os melhores resultados.

Algoritmos de modelo compatíveis – HuggingFace (versão prévia)

Com o novo back-end que é executado em pipelines do Azure Machine Learning, você também pode usar qualquer modelo de classificação de texto/token do Hub HuggingFace para realizar Classificação de Texto e Classificação de Token, que faz parte da biblioteca de transformadores (como microsoft/deberta-large-mnli). Você também pode encontrar uma lista selecionada de modelos no registro de modelo do Azure Machine Learning que foram validados com os componentes de pipeline.

O uso de qualquer modelo HuggingFace disparará execuções usando componentes de pipeline. Se os modelos HuggingFace e herdado forem usados, todas as execuções/avaliações serão disparadas usando componentes.

Hiperparâmetros compatíveis

A tabela a seguir descreve os hiperparâmetros aos quais o NLP do AutoML dá suporte.

Todos os hiperparâmetros discretos permitem somente distribuições de escolha, como os hiperparâmetros do tipo inteiro training_batch_size e do tipo de cadeia de caracteres model_name. Todos os hiperparâmetros contínuos como learning_rate dão suporte a todas as distribuições.

Definir as configurações de varredura

É possível configurar todos os parâmetros relacionados à varredura. Diversos subespaços de modelo podem ser criados com hiperparâmetros condicionais ao respectivo modelo, conforme visto em cada exemplo de ajuste de hiperparâmetros.

As mesmas opções de distribuição discreta e contínua disponíveis para trabalhos gerais do HyperDrive são compatíveis aqui. Veja todas as nove opções em Ajuste de hiperparâmetro em um modelo

limits: 
  timeout_minutes: 120  
  max_trials: 4 
  max_concurrent_trials: 2 

sweep: 
  sampling_algorithm: grid 
  early_termination: 
    type: bandit 
    evaluation_interval: 10 
    slack_factor: 0.2 

search_space: 
  - model_name: 
      type: choice 
      values: [bert_base_cased, roberta_base] 
    number_of_epochs: 
      type: choice 
      values: [3, 4] 
  - model_name: 
      type: choice 
      values: [distilbert_base_cased] 
    learning_rate: 
      type: uniform 
      min_value: 0.000005 
      max_value: 0.00005 

text_ner_job.set_limits( 
                        timeout_minutes=120, 
                        trial_timeout_minutes=20, 
                        max_trials=4, 
                        max_concurrent_trials=2, 
                        max_nodes=4) 

text_ner_job.extend_search_space( 
    [ 
        SearchSpace( 
            model_name=Choice([NlpModels.BERT_BASE_CASED, NlpModels.ROBERTA_BASE]) 
        ), 
        SearchSpace( 
            model_name=Choice([NlpModels.DISTILROBERTA_BASE]), 
            learning_rate_scheduler=Choice([NlpLearningRateScheduler.LINEAR,  
                                            NlpLearningRateScheduler.COSINE]), 
            learning_rate=Uniform(5e-6, 5e-5) 
        ) 
    ] 
) 

text_ner_job.set_sweep( 
    sampling_algorithm="Random", 
    early_termination=BanditPolicy( 
        evaluation_interval=2, slack_factor=0.05, delay_evaluation=6 
    ) 
) 

Métodos de amostragem para a varredura

Ao varrer hiperparâmetros, você precisará especificar o método de amostragem a ser usado na varredura do espaço de parâmetro definido. Atualmente, os seguintes métodos de amostragem são compatíveis com o parâmetro sampling_algorithm:

Orçamento do experimento

Opcionalmente, é possível especificar o orçamento do experimento do trabalho de treinamento do NLP do AutoML usando o parâmetro timeout_minutes no limits (o tempo em minutos antes do término do experimento). Se nenhum for especificado, o tempo limite padrão do experimento será de sete dias (máximo de 60 dias).

O NLP do AutoML também dá suporte a trial_timeout_minutes, a quantidade máxima de tempo em minutos durante a qual uma avaliação individual pode ser executada antes de ser encerrada, e a max_nodes, o número máximo de nós do cluster de computação de apoio a ser usado no trabalho. Esses parâmetros também pertencem à seção limits.

APLICA-SE A: Extensão de ML da CLI do Azurev2 (atual)

limits: 
  timeout_minutes: 60 
  trial_timeout_minutes: 20 
  max_nodes: 2 

Políticas de término antecipado

Você pode encerrar automaticamente execuções de baixo desempenho com uma política de término antecipado. O encerramento antecipado melhora a eficiência computacional, pois economiza recursos de computação que, de outra forma, seriam gastos em configurações menos promissoras. O NLP do AutoML dá suporte a políticas de encerramento antecipado usando o parâmetro early_termination. Se nenhuma política de encerramento for especificada, todas as configurações serão executadas até a conclusão.

Saiba mais sobre como configurar a política de encerramento antecipado para a varredura de hiperparâmetro.

Recursos para a varredura

Você pode controlar os recursos gastos em sua varredura de hiperparâmetros especificando max_trials e max_concurrent_trials para a varredura.

Você pode configurar todos os parâmetros relacionados à varredura, conforme mostrado nesse exemplo.

APLICA-SE A: Extensão de ML da CLI do Azurev2 (atual)

sweep:
  limits:
    max_trials: 10
    max_concurrent_trials: 2
  sampling_algorithm: random
  early_termination:
    type: bandit
    evaluation_interval: 2
    slack_factor: 0.2
    delay_evaluation: 6

Problemas conhecidos

Lidar com pontuações baixas ou valores de perda mais altos:

Para determinados conjuntos de dados, independentemente da tarefa de NLP, as pontuações produzidas podem ser muito baixas, às vezes até zero. Essa pontuação é acompanhada por valores de perda mais altos, o que significa que a rede neural não convergiu. Essas pontuações podem acontecer com mais frequência em determinados SKUs de GPU.

Embora esses casos sejam incomuns, eles são possíveis e a melhor maneira de lidar com isso é aproveitar o ajuste de hiperparâmetros e fornecer uma variedade mais ampla de valores, especialmente para hiperparâmetros como taxas de aprendizado. Até que o nosso recurso de ajuste de hiperparâmetros esteja disponível na produção, recomendamos que os usuários que tiverem esses problemas usem os clusters de cálculo NC6 ou ND6. Esses clusters normalmente têm resultados de treinamento bastante estáveis.

Próximas etapas

• Implantar modelos do AutoML em um ponto de extremidade online (inferência em tempo real)
• Fazer ajuste de hiperparâmetro em um modelo