Modelos e algoritmos do Amazon SageMaker JumpStart agora disponíveis via API

Em dezembro de 2020, AWS anunciou a disponibilidade geral of JumpStart do Amazon SageMaker, uma capacidade de Amazon Sage Maker que ajuda você a começar de maneira rápida e fácil com o aprendizado de máquina (ML). O 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.

Anteriormente, todo o conteúdo do JumpStart estava disponível apenas por meio de Estúdio Amazon SageMaker, que fornece uma interface gráfica amigável para interagir com o recurso. Hoje, temos o prazer de anunciar o lançamento de um software fácil de usar APIs JumpStart como uma extensão do SageMaker Python SDK. Essas APIs permitem que você implante programaticamente e ajuste uma vasta seleção de modelos pré-treinados compatíveis com 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, fornecemos uma atualização sobre o estado atual dos recursos do JumpStart e orientamos você pelo fluxo de uso da API do JumpStart com um exemplo de caso de uso.

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 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 do zero. 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 de dados tabulares.
• Use soluções pré-construídas – JumpStart fornece um conjunto de 17 soluções pré-construídas 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 usar rapidamente esses algoritmos.
• Aproveite os 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 chaves de criptografia 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 SageMaker Studio ou por meio do SageMaker Python SDK.

Tarefas de ML compatíveis com JumpStart e notebooks de exemplo de API

Atualmente, o JumpStart oferece suporte a 15 das tarefas de ML mais populares; 13 delas são tarefas baseadas em visão e PNL, das quais 8 suportam ajuste fino sem código. Ele também suporta quatro algoritmos populares para modelagem de dados tabulares. As tarefas e links para seus blocos de anotações de amostra estão resumidos na tabela a seguir.

Dependendo da tarefa, os blocos de anotações de exemplo vinculados na tabela anterior podem orientá-lo em todos ou em um subconjunto dos seguintes processos:

• Selecione um modelo pré-treinado compatível com JumpStart para sua tarefa específica.
• Hospede um modelo pré-treinado, obtenha previsões dele em tempo real e exiba adequadamente os resultados.
• Ajuste um modelo pré-treinado com sua própria seleção de hiperparâmetros e implante-o para inferência.

Ajuste e implante um modelo de detecção de objetos com APIs JumpStart

Nas seções a seguir, fornecemos um passo a passo de como usar as novas APIs JumpStart na tarefa representativa de detecção de objetos. Mostramos como usar um modelo de detecção de objetos pré-treinado para identificar objetos de um conjunto predefinido de classes em uma imagem com caixas delimitadoras. Por fim, mostramos como ajustar um modelo pré-treinado em seu próprio conjunto de dados para detectar objetos em imagens específicas às suas necessidades de negócios, simplesmente trazendo seus próprios dados. Nós fornecemos um caderno de acompanhamento para este passo a passo.

Percorremos as seguintes etapas de alto nível:

1. Execute a inferência no modelo pré-treinado.
   1. Recupere artefatos JumpStart e implante um endpoint.
   2. Consulte o endpoint, analise a resposta e exiba as previsões do modelo.
2. Ajuste o modelo pré-treinado em seu próprio conjunto de dados.
   1. Recupere artefatos de treinamento.
   2. Correr treinando.

Executar inferência no modelo pré-treinado

Nesta seção, escolhemos um modelo pré-treinado apropriado no JumpStart, implantamos esse modelo em um terminal SageMaker e mostramos como executar a inferência no terminal implantado. Todos os passos estão disponíveis no caderno Jupyter que acompanha.

Recupere artefatos JumpStart e implante um endpoint

SageMaker é uma plataforma baseada em containers Docker. O JumpStart usa o framework específico disponível Contêineres de aprendizado profundo do SageMaker (DLC). Buscamos quaisquer pacotes adicionais, bem como scripts para lidar com treinamento e inferência para a tarefa selecionada. Finalmente, os artefatos de modelo pré-treinados são buscados separadamente com model_uris, que oferece flexibilidade à plataforma. Você pode usar qualquer número de modelos pré-treinados para a mesma tarefa com um único script de treinamento ou inferência. Veja o seguinte código:

infer_model_id, infer_model_version = "pytorch-od-nvidia-ssd", "*" # Retrieve the inference docker container uri. This is the base container PyTorch image for the model selected above. deploy_image_uri = image_uris.retrieve(region=None, framework=None, image_scope="inference",model_id=infer_model_id, model_version=infer_model_version, instance_type=inference_instance_type) # Retrieve the inference script uri. This includes all dependencies and scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, script_scope="inference") # Retrieve the base model uri. This includes the pre-trained nvidia-ssd model and parameters.
base_model_uri = model_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, model_scope="inference")

Em seguida, alimentamos os recursos em um Modelo SageMaker instância e implante um endpoint:

# Create the SageMaker model instance
model = Model(image_uri=deploy_image_uri, source_dir=deploy_source_uri, model_data=base_model_uri, entry_point="inference.py", role=aws_role, predictor_cls=Predictor, name=endpoint_name) # deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name)

A implantação do endpoint pode levar alguns minutos para ser concluída.

Consulte o endpoint, analise a resposta e exiba previsões

Para obter inferências de um modelo implantado, uma imagem de entrada precisa ser fornecida em formato binário junto com um tipo de aceitação. No JumpStart, você pode definir o número de caixas delimitadoras retornadas. No trecho de código a seguir, prevemos dez caixas delimitadoras por imagem anexando ;n_predictions=10 para Accept. Para prever xx caixas, você pode alterá-lo para ;n_predictions=xx , ou obtenha todas as caixas previstas omitindo ;n_predictions=xx inteiramente.

def query(model_predictor, image_file_name): with open(image_file_name, "rb") as file: input_img_rb = file.read() return model_predictor.predict(input_img_rb,{ "ContentType": "application/x-image", "Accept": "application/json;verbose;n_predictions=10"}) query_response = query(base_model_predictor, Naxos_Taverna)

O snippet de código a seguir mostra como é a detecção de objetos. A probabilidade prevista para cada classe de objeto é visualizada, juntamente com sua caixa delimitadora. Nós usamos o parse_response e display_predictions funções auxiliares, que são definidas no anexo caderno.

normalized_boxes, classes_names, confidences = parse_response(query_response)
display_predictions(Naxos_Taverna, normalized_boxes, classes_names, confidences)

A captura de tela a seguir mostra a saída de uma imagem com rótulos de previsão e caixas delimitadoras.

Ajuste um modelo pré-treinado em seu próprio conjunto de dados

Os modelos de detecção de objetos existentes no JumpStart são pré-treinados nos conjuntos de dados COCO ou VOC. No entanto, se você precisar identificar classes de objeto que não existem no conjunto de dados de pré-treinamento original, será necessário ajustar o modelo em um novo conjunto de dados que inclua esses novos tipos de objeto. Por exemplo, se você precisar identificar utensílios de cozinha e executar inferência em um modelo de SSD pré-treinado implantado, o modelo não reconhecerá nenhuma característica dos novos tipos de imagem e, portanto, a saída estará incorreta.

Nesta seção, demonstramos como é fácil ajustar um modelo pré-treinado para detectar novas classes de objeto usando APIs JumpStart. O exemplo de código completo com mais detalhes está disponível no caderno de acompanhamento.

Recuperar artefatos de treinamento

Os artefatos de treinamento são semelhantes aos artefatos de inferência discutidos na seção anterior. O treinamento requer um contêiner base do Docker, ou seja, o contêiner MXNet no código de exemplo a seguir. Quaisquer pacotes adicionais necessários para treinamento estão incluídos com os scripts de treinamento em train_sourcer_uri. O modelo pré-treinado e seus parâmetros são empacotados separadamente.

train_model_id, train_model_version, train_scope = "mxnet-od-ssd-512-vgg16-atrous-coco","*","training"
training_instance_type = "ml.p2.xlarge" # Retrieve the docker image. This is the base container MXNet image for the model selected above. train_image_uri = image_uris.retrieve(region=None, framework=None, model_id=train_model_id, model_version=train_model_version, image_scope=train_scope,instance_type=training_instance_type) # Retrieve the training script and dependencies. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(model_id=train_model_id, model_version=train_model_version, script_scope=train_scope) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope)

Executar treinamento

Para executar o treinamento, simplesmente alimentamos os artefatos necessários junto com alguns parâmetros adicionais para um Avaliador do SageMaker e ligue para o .fit função:

# Create SageMaker Estimator instance
od_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", # Entry-point file in source_dir and present in train_source_uri. 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
od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Enquanto o algoritmo treina, você pode monitorar seu progresso no notebook SageMaker onde você está executando o próprio código ou no Amazon CloudWatch. Quando o treinamento é concluído, os artefatos de modelo ajustados são carregados no Serviço de armazenamento simples da Amazon (Amazon S3) local de saída especificado na configuração de treinamento. Agora você pode implantar o modelo da mesma maneira que o modelo pré-treinado. Você pode acompanhar o restante do processo no caderno de acompanhamento.

Conclusão

Neste post, descrevemos o valor das APIs JumpStart recém-lançadas e como usá-las. Fornecemos links para 17 blocos de anotações de exemplo para as diferentes tarefas de ML com suporte no JumpStart e orientamos você pelo bloco de anotações de detecção de objetos.

Estamos ansiosos para ouvir de você enquanto você experimenta o JumpStart.

Sobre os autores

Vivek Madan é um cientista aplicado da equipe Amazon SageMaker JumpStart. Ele obteve seu doutorado na Universidade de Illinois em Urbana-Champaign e foi pesquisador 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 Deep Learning.

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 e ACL.

• Coinsmart. A melhor troca de Bitcoin e criptografia da Europa.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. ACESSO LIVRE.
• CryptoHawk. Radar Altcoin. Teste grátis.
• Fonte: https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-jumpstart-models-and-algorithms-now-available-via-api/