Treinamento incremental com Amazon SageMaker JumpStart

Republicado por Platão

seguidores: 0

Em dezembro de 2020, AWS anunciou a disponibilidade geral do Amazon SageMaker JumpStart, uma capacidade de Amazon Sage Maker que ajuda você a começar a usar machine learning (ML) de maneira rápida e fácil. SageMaker JumpStart fornece ajuste fino e implantação com um clique de uma ampla variedade de modelos pré-treinados em tarefas populares de ML, bem como uma seleção de soluções de ponta a ponta que resolvem problemas comuns de negócios. Esses recursos eliminam o trabalho pesado de cada etapa do processo de ML, facilitando o desenvolvimento de modelos de alta qualidade e reduzindo o tempo de implantação.

Todo o conteúdo do JumpStart estava disponível anteriormente apenas por meio de Estúdio Amazon SageMaker, que fornece uma interface gráfica amigável para interagir com o recurso. Recentemente, nós também anunciou o lançamento de fácil utilização APIs JumpStart como uma extensão do SageMaker Python SDK, permitindo que você implemente programaticamente e ajuste uma vasta seleção de modelos pré-treinados com suporte do JumpStart em seus próprios conjuntos de dados. Este lançamento desbloqueia o uso dos recursos do JumpStart em seus fluxos de trabalho de código, pipelines de MLOps e em qualquer outro lugar em que você esteja interagindo com o SageMaker via SDK.

Neste post, temos o prazer de anunciar que todos os modelos JumpStart treináveis agora suportam treinamento incremental. O treinamento incremental permite treinar um modelo que você já ajustou usando um conjunto de dados expandido que contém um padrão subjacente não contabilizado em execuções de ajuste fino anteriores, o que resultou em um desempenho insatisfatório do modelo. O treinamento incremental economiza tempo e recursos porque você não precisa treinar novamente o modelo do zero. Se você quiser ir direto para o código da API JumpStart que explicamos neste post, você pode consultar o caderno de amostra.

Visão geral do JumpStart

O JumpStart é um produto multifacetado que inclui diferentes recursos para ajudá-lo a começar rapidamente com ML no SageMaker. No momento em que escrevo, o JumpStart permite que você faça o seguinte:

Implante modelos pré-treinados para tarefas comuns de ML – O JumpStart permite que você resolva tarefas comuns de ML sem esforço de desenvolvimento, fornecendo fácil implantação de modelos pré-treinados em grandes conjuntos de dados disponíveis publicamente. A comunidade de pesquisa de ML fez um grande esforço para tornar a maioria dos modelos desenvolvidos recentemente disponíveis publicamente para uso; O JumpStart hospeda uma coleção de mais de 300 modelos, abrangendo as 15 tarefas de ML mais populares, como detecção de objetos, classificação de texto e geração de texto, facilitando o uso deles para iniciantes. Esses modelos são extraídos de hubs de modelos populares, como TensorFlow, PyTorch, Hugging Face e MXNet Hub.
Ajustar modelos pré-treinados – O JumpStart permite ajustar modelos pré-treinados sem a necessidade de escrever seu próprio algoritmo de treinamento. No ML, a capacidade de transferir o conhecimento aprendido em um domínio para outro é chamada de transferir aprendizado. Você pode usar o aprendizado de transferência para produzir modelos precisos em seus conjuntos de dados menores, com custos de treinamento muito menores do que os envolvidos no treinamento do modelo original. O JumpStart também inclui algoritmos de treinamento populares baseados em LightGBM, CatBoost, XGBoost e Scikit-learn que você pode treinar do zero para regressão e classificação tabulares.
Use soluções pré-construídas – O JumpStart fornece um conjunto de 17 soluções para casos de uso comuns de ML, como previsão de demanda e aplicativos industriais e financeiros, que você pode implantar com apenas alguns cliques. As soluções são aplicativos de ML de ponta a ponta que reúnem vários serviços da AWS para resolver um caso de uso de negócios específico. Eles usam Formação da Nuvem AWS modelos e arquiteturas de referência para implantação rápida, o que significa que são totalmente personalizáveis.
Use exemplos de notebook para algoritmos do SageMaker – O SageMaker fornece um conjunto de algoritmos integrados para ajudar cientistas de dados e profissionais de ML a começar a treinar e implantar modelos de ML rapidamente. O JumpStart fornece blocos de anotações de exemplo que você pode usar para aplicar rapidamente esses algoritmos.
Revise vídeos de treinamento e blogs – O JumpStart também fornece várias postagens de blog e vídeos que ensinam como usar diferentes funcionalidades do SageMaker.

O JumpStart aceita configurações personalizadas de VPC e Serviço de gerenciamento de chaves AWS (AWS KMS) para que você possa usar os modelos e soluções disponíveis com segurança em seu ambiente empresarial. Você pode passar suas configurações de segurança para o JumpStart no Studio ou por meio do SageMaker Python SDK.

Classificação de imagem

A classificação de imagem refere-se à classificação de uma imagem em um dos rótulos de classe no conjunto de dados de treinamento. Você pode ajustar o modelo para qualquer conjunto de dados que inclua imagens pertencentes a qualquer número de classes. O modelo disponível para ajuste fino no JumpStart anexa uma camada de classificação ao modelo do extrator de recursos correspondente e inicializa os parâmetros da camada com valores aleatórios. A dimensão de saída da camada de classificação é determinada com base no número de classes nos dados de entrada. A etapa de ajuste fino ajusta os parâmetros da camada de classificação, enquanto mantém os parâmetros do modelo do extrator de recursos congelados e retorna o modelo ajustado. O objetivo é minimizar o erro de previsão nos dados de entrada.

Para nosso conjunto de dados, a entrada é um diretório com tantos subdiretórios quanto o número de classes. Cada subdiretório deve ter imagens pertencentes a essa classe no formato .jpg. O diretório de entrada deve se parecer com a seguinte hierarquia se os dados de treinamento contiverem imagens de duas classes: roses e dandelion:

input_directory |--roses |--abc.jpg |--def.jpg |--dandelion |--ghi.jpg |--jkl.jpg

Os nomes das pastas, classes e nomes de arquivos .jpg podem ser qualquer coisa.

Nós fornecemos o tf_flowers¹conjunto de dados como um conjunto de dados padrão para ajustar o modelo. Este conjunto de dados compreende imagens de cinco tipos de flores. O conjunto de dados foi baixado de TensorFlow.

Visão geral do passo a passo

As seções a seguir fornecem uma demonstração passo a passo para realizar a classificação de imagens com o JumpStart, tanto por meio da interface do usuário do Studio quanto das APIs do JumpStart.

Percorremos os seguintes passos:

Acesse o JumpStart pela interface do Studio:
1. Ajuste o modelo pré-treinado.
2. Implante o modelo ajustado.
3. Treine incrementalmente o modelo ajustado e reimplemente.
Use o JumpStart programaticamente com o SageMaker Python SDK:
1. Ajuste o modelo pré-treinado.
2. Implante o modelo ajustado.
3. Treine incrementalmente o modelo ajustado e reimplemente.

Acesse o JumpStart pela interface do Studio

Nesta seção, demonstramos como ajustar e implantar modelos JumpStart por meio da interface do usuário do Studio. Além disso, mostramos como treinar incrementalmente um modelo que você ajustou anteriormente.

Ajuste o modelo pré-treinado

O vídeo a seguir mostra como encontrar um modelo de classificação de imagem pré-treinado no JumpStart e ajustá-lo. A página do modelo contém informações valiosas sobre o modelo, como usá-lo, formato de dados esperado e alguns detalhes de ajuste fino.

Para fins de demonstração, ajustamos o modelo usando o conjunto de dados fornecido por padrão, que é o tf_flowers conjunto de dados, composto por diferentes variedades de flores. O ajuste fino em seu próprio conjunto de dados envolve a formatação correta dos dados (conforme explicado na página do modelo), carregá-los para Serviço de armazenamento simples da Amazon (Amazon S3) e especificando sua localização na configuração da fonte de dados.

Usamos os mesmos valores de hiperparâmetros definidos por padrão (número de épocas, taxa de aprendizado e tamanho do lote). Também usamos uma instância ml.p3.2xlarge com suporte de GPU como nossa instância de treinamento do SageMaker.

Você pode monitorar seu trabalho de treinamento diretamente no console do Studio e ser notificado após sua conclusão.

Implante o modelo ajustado

Após a conclusão do treinamento, você pode implantar o modelo ajustado na mesma página que contém os detalhes do trabalho de treinamento. Para implantar nosso modelo, escolhemos um tipo de instância diferente, ml.p2.xlarge. Ele ainda fornece a aceleração de GPU necessária para baixa latência de inferência, mas a um preço mais baixo. Depois de configurar a instância de hospedagem do SageMaker, escolha Implantação. Pode levar de 5 a 10 minutos até que seu endpoint persistente esteja funcionando.

Então seu endpoint está operacional e pronto para responder a solicitações de inferência!

Para acelerar o tempo de inferência, o JumpStart fornece um bloco de anotações de exemplo que mostra como executar a inferência em seu endpoint recém-implantado. Escolher Abra o Notebook para Usar ponto final do Estúdio.

Treine incrementalmente o modelo ajustado e implemente

Quando o ajuste fino estiver concluído, você poderá treinar ainda mais o modelo para aumentar o desempenho. Esta etapa é muito semelhante ao processo de ajuste fino inicial, exceto que usamos o modelo já ajustado como ponto de partida. Você pode usar novos dados, mas o formato do conjunto de dados deve ser o mesmo (mesmo conjunto de classes).

Use o JumpStart programaticamente com o SDK do SageMaker

Nas seções anteriores, mostramos como você pode usar a IU do JumpStart para ajustar, implantar e treinar incrementalmente um modelo de forma interativa em questão de alguns cliques. Você também pode usar os modelos do JumpStart e o ajuste fino fácil programaticamente usando APIs integradas ao SDK do SageMaker. Vamos agora ver um exemplo rápido de como você pode replicar o processo anterior. Todas as etapas desta demonstração estão disponíveis nos notebooks que acompanham Introdução ao JumpStart - Classificação de imagens.

Ajuste o modelo pré-treinado

Para ajustar um modelo selecionado, precisamos obter o URI desse modelo, bem como o do script de treinamento e a imagem do contêiner usada para treinamento. Felizmente, essas três entradas dependem apenas do nome do modelo, versão (para obter uma lista de modelos disponíveis, consulte Tabela de modelos disponíveis do JumpStart) e o tipo de instância em que você deseja treinar. Isso é demonstrado no trecho de código a seguir:

from sagemaker import image_uris, model_uris, script_uris model_id, model_version = "pytorch-ic-mobilenet-v2", "1.0.0"
training_instance_type = "ml.p3.2xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve( region=None, framework=None, model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training") # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

Nós recuperamos o model_id correspondendo ao mesmo modelo que usamos anteriormente. O ic no identificador corresponde à classificação da imagem.

Agora você pode ajustar esse modelo JumpStart em seu próprio conjunto de dados personalizado usando o SDK do SageMaker. Usamos o mesmo tf_flowers conjunto de dados hospedado publicamente no Amazon S3, convenientemente focado na análise de sentimentos. Seu conjunto de dados deve ser estruturado para ajuste fino, conforme explicado na seção anterior. Veja o seguinte código de exemplo:

# URI of your training dataset
training_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tf_flowers/"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning") # Create SageMaker Estimator instance
ic_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=s3_output_location,
) # Launch a SageMaker Training job by passing s3 path of the training data
ic_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Obtemos os mesmos hiperparâmetros padrão para nosso modelo selecionado que vimos na seção anterior, usando sagemaker.hyperparameters.retrieve_default(). Em seguida, instanciamos um estimador do SageMaker e chamamos o método .fit para começar a ajustar nosso modelo, passando o URI do Amazon S3 para nossos dados de treinamento. Como você pode ver, o entry_point script fornecido é nomeado transfer_learning.py (o mesmo para outras tarefas e modelos), e o canal de dados de entrada passado para .fit deve ser nomeado training.

Como implantar o modelo ajustado

Quando o treinamento estiver concluído, você poderá implantar seu modelo ajustado. Para fazer isso, tudo o que precisamos obter é o URI do script de inferência (o código que determina como o modelo é usado para inferência uma vez implantado) e o URI da imagem do contêiner de inferência, que inclui um servidor de modelo apropriado para hospedar o modelo que escolhemos. Veja o seguinte código:

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
)
# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="inference"
) endpoint_name = name_from_base(f"jumpstart-example-FT-{model_id}-") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = ic_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

Após alguns minutos, nosso modelo é implantado e podemos obter previsões em tempo real!

Em seguida, invocamos o endpoint para prever que tipo de flores existem na imagem de exemplo. Nós usamos o query_endpoint e parse_response funções auxiliares, que são definidas no anexo caderno.

query_response = finetuned_predictor.predict( img, {"ContentType": "application/x-image", "Accept": "application/json;verbose"} )
model_predictions = json.loads(query_response)
predicted_label = model_predictions["predicted_label"]
display( HTML( f'<img src={image_filename} alt={image_filename} align="left" style="width: 250px;"/>' f"<figcaption>Predicted Label: {predicted_label}</figcaption>" )
)

Treine incrementalmente o modelo ajustado e reimplemente

Podemos aumentar o desempenho de um modelo ajustado ao treiná-lo ainda mais em novas imagens. Você pode usar qualquer quantidade de imagens novas ou antigas para isso, porém o formato do conjunto de dados deve permanecer o mesmo (mesmo conjunto de classes). A etapa de treinamento incremental é semelhante ao processo de ajuste fino, com uma diferença importante: no ajuste fino inicial começamos com um modelo pré-treinado, enquanto que no treinamento incremental começamos com um modelo já existente. Veja o seguinte código:

last_trained_model_path = f"{s3_output_location}/{last_training_job_name}/output/model.tar.gz"
incremental_s3_output_location = f"s3://{output_bucket}/{incremental_output_prefix}/output"incremental_train_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=last_trained_model_path, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=incremental_s3_output_location, base_job_name=incremental_training_job_name,
) incremental_train_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Quando o treinamento estiver concluído, podemos usar as mesmas etapas descritas na seção anterior para implantar o modelo.

Conclusão

O JumpStart é um recurso do SageMaker que permite que você comece rapidamente com o ML. O JumpStart usa modelos pré-treinados de código aberto para resolver problemas comuns de ML, como classificação de imagens, detecção de objetos, classificação de texto, classificação de pares de frases e resposta a perguntas.

Neste post, mostramos como ajustar e implantar um modelo de classificação de imagem pré-treinado. Também mostramos como treinar incrementalmente um modelo ajustado para classificação de imagens. Com o JumpStart, você pode realizar esse processo facilmente sem a necessidade de codificar. Experimente a solução por conta própria e deixe-nos saber como foi nos comentários. Para saber mais sobre o JumpStart, confira o vídeo AWS re:Invent 2020 Comece a usar ML em minutos com o Amazon SageMaker JumpStart.

Referências

A equipe do TensorFlow, 2019

Sobre os autores

Vivek Madan é um cientista aplicado da equipe Amazon SageMaker JumpStart. Ele obteve seu doutorado. pela University of Illinois at Urbana-Champaign e foi pesquisadora de pós-doutorado na Georgia Tech. Ele é um pesquisador ativo em aprendizado de máquina e design de algoritmos e publicou artigos em conferências EMNLP, ICLR, COLT, FOCS e SODA.

João moura é arquiteto de soluções especialista em IA/ML na Amazon Web Services. Ele se concentra principalmente em casos de uso de PNL e em ajudar os clientes a otimizar o treinamento e a implantação de modelos de aprendizado profundo. Ele também é um defensor ativo de soluções de ML de baixo código e hardware especializado em ML.

Dr. é um Cientista Aplicado Sênior com JumpStart do Amazon SageMaker e Algoritmos integrados do Amazon SageMaker e ajuda a desenvolver algoritmos de aprendizado de máquina. Ele é um pesquisador ativo em aprendizado de máquina e inferência estatística e publicou muitos artigos nas conferências NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.