Ajuste fino distribuído de um modelo BERT Large para uma tarefa de resposta a perguntas usando Hugging Face Transformers no Amazon SageMaker

Desde o treinamento de novos modelos até sua implantação na produção, Amazon Sage Maker oferece o conjunto mais completo de ferramentas para startups e empresas aproveitarem o poder do aprendizado de máquina (ML) e do aprendizado profundo.

Com sua biblioteca de código aberto Transformers e plataforma de ML, a Hugging Face torna a aprendizagem por transferência e os modelos de ML mais recentes acessíveis à comunidade global de IA, reduzindo o tempo necessário para que cientistas de dados e engenheiros de ML em empresas ao redor do mundo aproveitem cada novo conhecimento científico. avanço.

A aplicação de Transformers a novas tarefas ou domínios de PNL requer o ajuste fino de grandes modelos de linguagem, uma técnica que aproveita o conhecimento acumulado de modelos pré-treinados para adaptá-los a uma nova tarefa ou tipo específico de documentos em um processo de treinamento adicional e eficiente.

O ajuste fino do modelo para produzir previsões precisas para o problema de negócios em questão requer o treinamento de grandes modelos de Transformers, por exemplo, BERT, BART, RoBERTa, T5, que podem ser desafiadores para serem executados de forma escalonável.

Hugging Face tem trabalhado em estreita colaboração com SageMaker para entregar Contêineres de Deep Learning prontos para uso (DLCs) que tornam o treinamento e a implantação dos modelos mais recentes de Transformers mais fáceis e rápidos do que nunca. Como recursos como SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), modo S3 pipe, são integrados ao contêiner, usá-los reduz drasticamente o tempo para as empresas criarem soluções de ML baseadas em Transformers, como resposta a perguntas, geração texto e imagens, otimizando os resultados da pesquisa e melhora a automação do suporte ao cliente, interfaces de conversação, pesquisa semântica, análise de documentos e muitos outros aplicativos.

Nesta postagem, nos concentramos na integração profunda das bibliotecas distribuídas do SageMaker com o Hugging Face, que permite aos cientistas de dados acelerar o treinamento e o ajuste fino dos modelos de Transformers de dias para horas, tudo no SageMaker.

Visão geral do treinamento distribuído

Os profissionais de ML e cientistas de dados enfrentam dois desafios de dimensionamento ao treinar modelos: dimensionar o tamanho do modelo (número de parâmetros e camadas) e dimensionar os dados de treinamento. Dimensionar o tamanho do modelo ou os dados de treinamento pode resultar em melhor precisão, mas pode haver casos no aprendizado profundo em que a quantidade de memória no acelerador (CPU ou GPU) limita a combinação do tamanho dos dados de treinamento e do tamanho do modelo. Por exemplo, ao treinar um modelo de linguagem grande, o tamanho do lote geralmente é limitado a um pequeno número de amostras, o que pode resultar em um modelo menos preciso.

O treinamento distribuído pode dividir a carga de trabalho para treinar o modelo entre vários processadores, chamados trabalhadores. Esses trabalhadores operam em paralelo para agilizar o treinamento do modelo.

Com base no que queremos dimensionar (modelo ou dados), existem duas abordagens para o treinamento distribuído: paralelo de dados e paralelo de modelo.

O paralelo de dados é a abordagem mais comum para treinamento distribuído. O paralelismo de dados envolve a criação de uma cópia da arquitetura do modelo e pesos em diferentes aceleradores. Então, em vez de passar todo o conjunto de treinamento para um único acelerador, podemos particionar o conjunto de treinamento entre os diferentes aceleradores e passar pelo conjunto de treinamento mais rapidamente. Embora isso acrescente a etapa dos aceleradores que precisam comunicar suas informações de gradiente de volta a um servidor de parâmetros, esse tempo é mais do que compensado pelo aumento de velocidade da iteração em uma fração de todo o conjunto de dados por acelerador. Por causa disso, o paralelismo de dados pode ajudar significativamente a reduzir o tempo de treinamento. Por exemplo, treinar um único modelo sem paralelização leva 4 horas. Usar o treinamento distribuído pode reduzir esse tempo para 24 minutos. O treinamento distribuído do SageMaker também implementa técnicas de ponta em atualizações de gradiente.

Uma abordagem de modelo paralelo é usada com modelos grandes, grandes demais para caber em um acelerador (GPU). Esta abordagem implementa uma estratégia de paralelização onde a arquitetura do modelo é dividida em fragmentos e colocada em diferentes aceleradores. A configuração de cada um desses fragmentos depende da arquitetura da rede neural e normalmente inclui várias camadas. A comunicação entre os aceleradores ocorre cada vez que os dados de treinamento passam de um dos shards para o próximo.

Para resumir, você deve usar o paralelismo de dados de treinamento distribuído para tarefas demoradas devido a grandes conjuntos de dados ou quando quiser acelerar seus experimentos de treinamento. Você deve usar o paralelismo de modelo quando seu modelo não caber em um acelerador.

Pré-requisitos

Para realizar o treinamento distribuído de modelos Hugging Face Transformers no SageMaker, você precisa preencher os seguintes pré-requisitos:

Implementar treinamento distribuído

A biblioteca Hugging Face Transformers fornece uma API Trainer que é otimizada para treinar ou ajustar os modelos que a biblioteca fornece. Você também pode usá-lo em seus próprios modelos se eles funcionarem da mesma maneira que os modelos Transformers; ver Treinador para mais detalhes. Esta API é usada em nosso scripts de exemplo, que mostram como pré-processar os dados para várias tarefas de PNL, que você pode usar como modelos para escrever um script que resolva seu próprio problema personalizado. A promessa da API Trainer é que esse script funcione imediatamente em qualquer configuração distribuída, incluindo SageMaker.

A API Trainer leva tudo o que é necessário para o treinamento. Isso inclui seus conjuntos de dados, seu modelo (ou uma função que retorna seu modelo), um compute_metrics função que retorna as métricas que você deseja rastrear a partir das matrizes de predicações e rótulos, seu otimizador e agendador de taxa de aprendizagem (bons padrões são fornecidos), bem como todos os hiperparâmetros que você pode ajustar para seu treinamento agrupados em uma classe de dados chamada TrainingArguments. Com tudo isso, ele expõe três métodos – treinar, avaliar e prever – para treinar seu modelo, obter resultados de métricas em qualquer conjunto de dados ou obter previsões em qualquer conjunto de dados. Para saber mais sobre o objeto Trainer, consulte Ajustando um modelo com a API Trainer e o video A API do treinador, que mostra um exemplo simples.

Nos bastidores, a API Trainer começa analisando o ambiente no qual você está iniciando seu script ao criar o TrainingArguments. Por exemplo, se você iniciou seu treinamento com SageMaker, ele analisa o SM_FRAMEWORK_PARAMS variável no ambiente para detectar se você ativou o paralelismo de dados ou o paralelismo de modelo do SageMaker. Em seguida, ele obtém as variáveis ​​relevantes (como a classificação do processo ou o tamanho do mundo) do ambiente antes de executar as etapas de inicialização necessárias (como smdistributed.dataparallel.torch.distributed.init_process_group()).

O Trainer contém todo o ciclo de treinamento, para que possa ajustar as etapas necessárias para garantir que o smdistributed.dataparallel backend é usado quando necessário, sem que você precise alterar uma linha de código em seu script. Ele ainda pode ser executado (embora muito mais lento) em sua máquina local para depuração. Ele lida com a fragmentação de seu conjunto de dados de forma que cada processo veja amostras diferentes automaticamente, com uma remodelação em cada época, sincronizando seus gradientes antes da etapa de otimização, treinamento de precisão mista se você o ativou, acúmulo de gradiente se você não conseguir ajustar um tamanho de lote grande em suas GPUs e muito mais otimizações.

Se você ativou o paralelismo de modelo, ele garante que os processos que precisam ver os mesmos dados (se seus dp_rank é o mesmo) obtém os mesmos lotes e processa com diferentes dp_rank não vemos as mesmas amostras, novamente com uma remodelação a cada época. Ele garante que os dicionários de estado do modelo ou otimizadores estejam devidamente sincronizados durante o checkpoint e, novamente, lida com todas as otimizações, como precisão mista e acúmulo de gradiente.

Ao utilizar os métodos de avaliação e previsão, o Trainer realiza uma avaliação distribuída, para aproveitar todas as suas GPUs. Ele lida adequadamente com a divisão de seus dados para cada processo (processo do mesmo dp_rank se o paralelismo de modelo estiver ativado) e garante que as previsões sejam coletadas corretamente na mesma ordem do conjunto de dados que você está usando antes de serem enviadas para o compute_metrics função ou apenas retornada. O uso da API Trainer não é obrigatório. Os usuários ainda podem usar Keras ou PyTorch no Hugging Face. No entanto, a API Trainer pode fornecer uma camada de abstração útil.

Treine um modelo usando SageMaker Hugging Face Estimators

Um Estimator é uma interface de alto nível para treinamento do SageMaker e lida com tarefas completas de treinamento e implantação do SageMaker. O treinamento do seu script é invocado quando você chama fit com um HuggingFace Estimador. No Estimador, você define qual script de ajuste fino usar como entry_point, o qual instance_type usar e quais hiperparâmetros são passados. Para obter mais informações sobre HuggingFace parâmetros, veja Abraçando o estimador de rosto.

Treinamento distribuído: dados paralelos

Neste exemplo, usamos os novos DLCs Hugging Face e SageMaker SDK para treinar um modelo de transformador Seq2Seq distribuído na tarefa de perguntas e respostas usando as bibliotecas de transformadores e conjuntos de dados. O bert-large-uncased-whole-word-masking modelo é ajustado no esquadra conjunto de dados.

Os exemplos de código a seguir mostram as etapas de criação de um HuggingFace estimador para treinamento distribuído com paralelismo de dados.

1. Escolha um script Hugging Face Transformers:

   # git configuration to download our fine-tuning script
   git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

Quando você cria um HuggingFace Estimator, você pode especificar um script de treinamento armazenado em um repositório GitHub como ponto de entrada para o Estimator, para que não seja necessário fazer download dos scripts localmente. Você pode usar git_config para executar os scripts de exemplo do Hugging Face Transformers e a 'ramificação' correta se o seu transformers_version precisa ser configurado. Por exemplo, se você usar transformers_version 4.6.1, você tem que usar 'branch':'v4.6.1'.

2. Configure hiperparâmetros de treinamento que são passados ​​para o trabalho de treinamento:

   # hyperparameters, which are passed into the training job
   hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
   }

Como hiperparâmetro, podemos definir qualquer Seq2SeqTrainingArgumentos e os definidos no roteiro de treinamento.

3. Defina os parâmetros de distribuição no HuggingFace Estimador:

   # configuration for running training on smdistributed Data Parallel
   distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Você pode usar o Biblioteca de paralelismo de dados SageMaker pronto para uso para treinamento distribuído. Adicionamos a funcionalidade de paralelismo de dados diretamente no Trainer. Para ativar o paralelismo de dados, você pode simplesmente adicionar um único parâmetro ao seu HuggingFace Estimador para permitir que seu código baseado no Trainer o use automaticamente.

4. Crie uma HuggingFace Estimador incluindo parâmetros definidos nas etapas anteriores e início do treinamento:

from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

A Abraçando o repositório de transformadores faciais contém vários exemplos e scripts para ajustar modelos em tarefas desde modelagem de linguagem até classificação de token. No nosso caso, usamos run_qa.py do examples/pytorch/question-answering exemplos.

smdistributed.dataparallel oferece suporte ao treinamento de modelo no SageMaker com apenas os seguintes tipos de instância. Para obter melhor desempenho, recomendamos usar um tipo de instância compatível Adaptador de tecido elástico (EFA):

• ml.p3.16xgrande
• ml.p3dn.24xlarge (recomendado)
• ml.p4d.24xlarge (recomendado)

Para obter o melhor desempenho e o máximo SMDataParallel, você deve usar pelo menos duas instâncias, mas também pode usar uma para testar este exemplo.

Os seguintes caderno de exemplo fornece orientação passo a passo mais detalhada.

Treinamento distribuído: modelo paralelo

Para treinamento distribuído com paralelismo de modelo, usamos os Hugging Face Transformers e a biblioteca de conjuntos de dados junto com o SageMaker SDK para classificação de sequência no Avaliação de Compreensão de Idioma Geral (GLUE) benchmark em um cluster multi-nós e multi-GPU usando o Biblioteca de paralelismo de modelos SageMaker.

Tal como acontece com o paralelismo de dados, primeiro definimos a configuração do git, os hiperparâmetros de treinamento e os parâmetros de distribuição no HuggingFace Estimador:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

A biblioteca de paralelismo de modelo usa MPI internamente, portanto, para usar o paralelismo de modelo, o MPI deve ser habilitado usando o parâmetro de distribuição. “processes_per_host”no código anterior especifica o número de processos que o MPI deve iniciar em cada host. Sugerimos estes para desenvolvimento e teste. No momento da produção, você pode entrar em contato com o AWS Support se solicitar ampla capacidade de GPU. Para mais informações, veja Execute um trabalho de treinamento paralelo de modelo distribuído do SageMaker.

Os seguintes caderno de exemplo contém os scripts de código completos.

Instâncias Spot

Com a extensão da estrutura Hugging Face para o SageMaker Python SDK, também podemos aproveitar as vantagens de recursos totalmente gerenciados Amazon Elastic Compute Nuvem (Amazon EC2) Instâncias Spot e economize até 90% do nosso custo de treinamento.

A menos que seu trabalho de treinamento seja concluído rapidamente, recomendamos que você use checkpoint com treinamento local gerenciado, portanto, você precisa definir checkpoint_s3_uri.

Para usar instâncias spot com o HuggingFace Estimador, temos que definir o use_spot_instances parâmetro como True e defina seu max_wait e max_run tempo. Para obter mais informações sobre o ciclo de vida de treinamento local gerenciado, consulte Treinamento de Spot Gerenciado no Amazon SageMaker.

A seguir está um trecho de código para configurar um Estimador de treinamento local:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

Os seguintes caderno contém os scripts de código completos.

Conclusão

Nesta postagem, discutimos o treinamento distribuído de Hugging Face Transformers usando SageMaker. Primeiro revisamos os casos de uso de paralelismo de dados versus paralelismo de modelo. O paralelismo de dados normalmente é mais apropriado, mas não necessariamente restrito a quando o treinamento é limitado pela computação, enquanto você pode usar o paralelismo de modelo quando um modelo não cabe na memória fornecida em um único acelerador. Em seguida, mostramos como treinar com os dois métodos.

No caso de uso de paralelismo de dados que discutimos, treinar um modelo em uma única instância p3.2xlarge (com uma única GPU) leva 4 horas e custa aproximadamente US$ 15 no momento da redação deste artigo. Com o paralelismo de dados, podemos treinar o mesmo modelo em 24 minutos a um custo de US$ 28. Embora o custo tenha duplicado, isso reduziu o tempo de treinamento por um fator de 10. Para uma situação em que é necessário treinar muitos modelos em um curto período de tempo, o paralelismo de dados pode permitir isso com um aumento de custo relativamente baixo. Quanto ao caso de uso de paralelismo de modelo, ele adiciona a capacidade de treinar modelos que não poderiam ter sido treinados anteriormente devido a limitações de hardware. Ambos os recursos permitem novos fluxos de trabalho para profissionais de ML e são facilmente acessíveis por meio do HuggingFace Estimador como parte do SageMaker Python SDK. A implantação desses modelos em endpoints hospedados segue o mesmo procedimento de outros estimadores.

Essa integração possibilita outros recursos que fazem parte do ecossistema SageMaker. Por exemplo, você pode usar instâncias spot adicionando um sinalizador simples ao Estimador para otimização adicional de custos. Na próxima etapa, você pode localizar e executar o demonstração de treinamento e caderno de exemplo.

Sobre os autores

Archis Joglekar é arquiteto de soluções de parceiros de AI / ML na equipe de tecnologias emergentes. Ele está interessado em aprendizado profundo escalonável e de alto desempenho e computação científica usando os blocos de construção da AWS. Suas experiências anteriores variam de pesquisa em física computacional ao desenvolvimento de plataforma de aprendizado de máquina na academia, laboratórios nacionais e startups. Ele passa o tempo longe do computador jogando futebol e com amigos e familiares.

James Yi é arquiteto sênior de soluções de parceiros de IA/ML na equipe de tecnologias emergentes da Amazon Web Services. Ele adora trabalhar com clientes empresariais e parceiros para projetar, implantar e dimensionar aplicativos de IA/ML para derivar seus valores de negócios. Fora do trabalho, ele gosta de jogar futebol, viajar e ficar com a família.

Philip Schmid é engenheiro de aprendizado de máquina e líder técnico na Hugging Face, onde lidera a colaboração com a equipe Amazon SageMaker. Ele é apaixonado por democratizar, otimizar e produzir modelos de PNL de ponta e melhorar a facilidade de uso do Deep Learning.

Sylvain Gugger é engenheiro de pesquisa da Hugging Face e um dos principais mantenedores da biblioteca Transformers. Ele adora software de código aberto e ajuda a comunidade a usá-lo.

Jeff Boudier desenvolve produtos na Hugging Face, criadora de Transformers, a principal biblioteca de ML de código aberto. Anteriormente, Jeff foi cofundador da Stupeflix, adquirida pela GoPro, onde atuou como diretor de Gestão de Produtos, Marketing de Produtos, Desenvolvimento de Negócios e Desenvolvimento Corporativo.

Fonte: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- transformadores-on-amazon-sagemaker/