Habilitando fluxos de trabalho híbridos de ML no Amazon EKS e Amazon SageMaker com Kubeflow de um clique na implantação da AWS

Hoje, muitos clientes da AWS estão criando plataformas de aprendizado de máquina (ML) prontas para empresas em Serviço Amazon Elastic Kubernetes (Amazon EKS) usando Kubeflow na AWS (uma distribuição do Kubeflow específica da AWS) em muitos casos de uso, incluindo visão computacional, compreensão de linguagem natural, tradução de fala e modelagem financeira.

Com o versão mais recente do Kubeflow v1.6.1 de código aberto, a comunidade Kubeflow continua a apoiar essa adoção em larga escala do Kubeflow para casos de uso corporativo. A versão mais recente inclui muitos novos recursos interessantes, como suporte para Kubernetes v1.22, Python SDK combinado para PyTorch, MXNet, MPI, XGBoost no operador de treinamento distribuído do Kubeflow, novos CRDs ClusterServingRuntime e ServingRuntime para serviço de modelo e muito mais.

As contribuições da AWS para o Kubeflow com o recente lançamento do Kubeflow no AWS 1.6.1 oferecem suporte a todos os recursos upstream de código aberto do Kubeflow e incluem muitas novas integrações com os serviços da AWS altamente otimizados, nativos da nuvem e prontos para empresas que ajudarão você a criar serviços altamente confiáveis, sistemas de ML seguros, portáteis e escaláveis.

Nesta postagem, discutimos os novos recursos do Kubeflow na AWS v1.6.1 e destacamos três integrações importantes que foram agrupadas em uma plataforma para oferecer a você::

• Solução de um clique de infraestrutura como código (IaaC) que automatiza a instalação de ponta a ponta do Kubeflow, incluindo a criação de cluster EKS
• Suporte para treinamento distribuído em Amazon Sage Maker utilização Operadores do Amazon SageMaker para Kubernetes (ACK) e Componentes do SageMaker para pipelines do Kubeflow e localmente no Kubernetes usando Operadores de treinamento do Kubeflow. Muitos clientes estão usando esse recurso para criar arquiteturas híbridas de aprendizado de máquina, nas quais aproveitam a computação do Kubernetes para a fase de experimentação e o SageMaker para executar cargas de trabalho em escala de produção.
• Monitoramento e observabilidade aprimorados para cargas de trabalho de ML, incluindo Amazon EKS, métricas Kubeflow e logs de aplicativos usando Prometheus, Grafana e Amazon CloudWatch integrações

O caso de uso neste blog se concentrará especificamente na integração do SageMaker com o Kubeflow na AWS, que pode ser adicionado aos seus fluxos de trabalho existentes do Kubernetes, permitindo que você crie arquiteturas híbridas de aprendizado de máquina.

Kubeflow na AWS

O Kubeflow on AWS 1.6.1 fornece um caminho claro para usar o Kubeflow, com a adição dos seguintes serviços da AWS além dos recursos existentes:

• Integração do SageMaker com o Kubeflow para executar fluxos de trabalho híbridos de ML usando SageMaker Operators for Kubernetes (ACK) e SageMaker Components for Kubeflow Pipelines.
• As opções de implantação automatizada foram aprimoradas e simplificadas usando scripts Kustomize e gráficos Helm.
• Adicionado suporte para implantação de um clique de Infraestrutura como Código (IaC) para Kubeflow na AWS usando Terraform para todos os recursos disponíveis opções de implantação. Este script automatiza a criação dos seguintes recursos da AWS:
• Suporte para AWS PrivateLink para Amazon S3, permitindo que usuários de regiões não comerciais se conectem a seus respectivos endpoints S3.
• Integração adicionada com Amazon Managed Service para Prometheus (AMP) e Grafana gerenciada pela Amazon para monitorar métricas com o Kubeflow na AWS.
• Contêineres de servidor de notebook Kubeflow atualizados com as imagens de contêiner de aprendizagem profunda mais recentes baseadas em TensorFlow 2.10.0 e PyTorch 1.12.1.
• Integração com AWS DLCs para execução distribuída treinamento e inferência cargas de trabalho.

O diagrama de arquitetura a seguir é um instantâneo rápido de todas as integrações de serviço (incluindo as já mencionadas) que estão disponíveis para controle do Kubeflow e componentes do plano de dados no Kubeflow na AWS. O plano de controle Kubeflow é instalado sobre o Amazon EKS, que é um serviço de contêiner gerenciado usado para executar e escalar aplicativos Kubernetes na nuvem. Essas integrações de serviço da AWS permitem desacoplar partes críticas do plano de controle do Kubeflow do Kubernetes, fornecendo um design seguro, escalável, resiliente e com custo otimizado. Para obter mais detalhes sobre o valor que essas integrações de serviço agregam ao Kubeflow de código aberto, consulte Crie e implante um sistema de aprendizado de máquina escalável no Kubernetes com o Kubeflow na AWS.

Vamos discutir com mais detalhes como os principais recursos do Kubeflow na AWS 1.6.1 podem ser úteis para sua organização.

Detalhes do recurso Kubeflow on AWS

Com a versão 1.6.1 do Kubeflow, tentamos fornecer ferramentas melhores para diferentes tipos de clientes que facilitam a introdução ao Kubeflow, independentemente das opções escolhidas. Essas ferramentas fornecem um bom ponto de partida e podem ser modificadas para atender às suas necessidades exatas.

Opções de implantação

Oferecemos diferentes opções de implantação para diferentes casos de uso do cliente. Aqui você pode escolher com quais serviços da AWS deseja integrar sua implantação do Kubeflow. Se você decidir alterar as opções de implantação posteriormente, recomendamos que faça uma nova instalação para a nova implantação. As seguintes opções de implantação estão disponíveis:

Se você deseja implantar o Kubeflow com alterações mínimas, considere o baunilha opção de implantação. Todas as opções de implantação disponíveis podem ser instaladas usando Kustomize, Helm ou Terraform.

Também temos diferentes implantações complementares que podem ser instaladas sobre qualquer uma dessas opções de implantação:

Opções de instalação

Depois de decidir qual opção de implantação atende melhor às suas necessidades, você pode escolher como deseja instalar essas implantações. Em um esforço para atender especialistas e recém-chegados, temos diferentes níveis de automação e configuração.

Opção 1: Terraforma (IaC)

Isso cria um cluster EKS e todos os recursos de infraestrutura AWS relacionados e, em seguida, implanta o Kubeflow em um único comando usando o Terraform. Internamente, isso usa esquemas EKS e gráficos Helm.

Esta opção tem as seguintes vantagens:

• Ele fornece flexibilidade para as empresas implantarem o Amazon EKS e o Kubeflow com um comando sem precisar se preocupar com configurações específicas de componentes do Kubeflow. Isso ajudará imensamente a acelerar a avaliação da tecnologia, a prototipagem e o ciclo de vida de desenvolvimento do produto, fornecendo flexibilidade para usar módulos terraform e modificá-los para atender a quaisquer necessidades específicas do projeto.
• Muitas organizações hoje que têm o Terraform como o centro de sua estratégia de nuvem agora podem usar o Kubeflow na solução AWS Terraform para atingir seus objetivos de nuvem.

Opção 2: Gráficos Kustomize ou Helm:

Essa opção permite implantar o Kubeflow em um processo de duas etapas:

1. Crie recursos da AWS como Amazon EKS, Amazon RDS, Amazon S3 e Amazon Cognito, seja por meio de scripts automatizados incluídos na distribuição da AWS ou manualmente seguindo um passo-a-passo.
2. Instale implantações do Kubeflow usando gráficos Helm ou Kustomize.

Esta opção tem as seguintes vantagens:

• O principal objetivo desta opção de instalação é fornecer configurações do Kubernetes relacionadas ao Kubeflow. Portanto, você pode optar por criar ou trazer clusters EKS existentes ou qualquer um dos recursos relacionados da AWS, como Amazon RDS, Amazon S3 e Amazon Cognito, e configurá-los e gerenciá-los para trabalhar com o Kubeflow na AWS.
• É mais fácil passar de um manifesto Kustomize Kubeflow de código aberto para a distribuição do AWS Kubeflow.

O diagrama a seguir ilustra as arquiteturas de ambas as opções.

Integração com SageMaker

O SageMaker é um serviço totalmente gerenciado projetado e otimizado especificamente para gerenciar fluxos de trabalho de ML. Ele remove o trabalho pesado indiferenciado do gerenciamento de infraestrutura e elimina a necessidade de investir em TI e DevOps para gerenciar clusters para criação, treinamento e inferência de modelos de ML.

Muitos clientes da AWS que têm requisitos de portabilidade ou restrições padrão locais usam o Amazon EKS para configurar pipelines de ML repetíveis executando cargas de trabalho de treinamento e inferência. No entanto, isso exige que os desenvolvedores escrevam um código personalizado para otimizar a infraestrutura de ML subjacente, fornecer alta disponibilidade e confiabilidade e cumprir os requisitos regulamentares e de segurança apropriados. Esses clientes, portanto, desejam usar o SageMaker para infraestrutura gerenciada e com custo otimizado para treinamento e implantações de modelos e continuar usando o Kubernetes para orquestração e pipelines de ML para manter a padronização e a portabilidade.

Para atender a essa necessidade, a AWS permite que você treine, ajuste e implante modelos no SageMaker do Amazon EKS usando as duas opções a seguir:

• Amazon SageMaker ACK Operators for Kubernetes, que são baseados no Controladores AWS para Kubernetes (ACK). ACK é a estratégia da AWS que traz padronização para criar controladores personalizados do Kubernetes que permitem que os usuários do Kubernetes provisionem recursos da AWS, como bancos de dados ou filas de mensagens, simplesmente usando a API do Kubernetes. Os SageMaker ACK Operators facilitam para desenvolvedores de ML e cientistas de dados que usam o Kubernetes como plano de controle treinar, ajustar e implantar modelos de ML no SageMaker sem fazer login no console do SageMaker.
• A Componentes do SageMaker para pipelines do Kubeflow, que permitem integrar o SageMaker com a portabilidade e orquestração do Kubeflow Pipelines. Com os componentes do SageMaker, cada trabalho no fluxo de trabalho do pipeline é executado no SageMaker em vez do cluster Kubernetes local. Isso permite que você crie e monitore trabalhos nativos de treinamento, ajuste, implantação de endpoint e transformação em lote do SageMaker de seus Kubeflow Pipelines, permitindo que você mova a computação completa, incluindo processamento de dados e trabalhos de treinamento do cluster Kubernetes para o serviço gerenciado otimizado para aprendizado de máquina do SageMaker.

Começando com o Kubeflow no AWS v1.6.1, todas as opções de implantação do Kubeflow disponíveis reúnem as duas opções de integração do Amazon SageMaker por padrão em uma plataforma. Isso significa que agora você pode enviar trabalhos SageMaker usando operadores SageMaker ACK de um servidor Kubeflow Notebook em si, enviando o recurso SageMaker personalizado ou da etapa do pipeline Kubeflow usando componentes SageMaker.

Existem duas versões dos componentes do SageMaker – boto3 (AWS SDK para AWS SDK para Python) versão 1 baseada em componentes e SageMaker Operator for K8s (ACK) versão 2 baseada em componentes. A nova versão 2 dos componentes do SageMaker oferece suporte às APIs de treinamento mais recentes do SageMaker e continuaremos a adicionar mais recursos do SageMaker a esta versão do componente. No entanto, você tem a flexibilidade de combinar os componentes do Sagemaker versão 2 para treinamento e a versão 1 para outros recursos do SageMaker, como ajuste de hiperparâmetros, tarefas de processamento, hospedagem e muito mais.

Integração com Prometheus e Grafana

O Prometheus é uma ferramenta de agregação de métricas de software livre que você pode configurar para executar em clusters Kubernetes. Ao executar em clusters Kubernetes, um servidor Prometheus principal raspa periodicamente os terminais do pod.

Os componentes do Kubeflow, como Kubeflow Pipelines (KFP) e Notebook, emitem métricas do Prometheus para permitir o monitoramento de recursos do componente, como o número de experimentos em execução ou a contagem de notebooks.

Essas métricas podem ser agregadas por um servidor Prometheus em execução no cluster Kubernetes e consultadas usando Prometheus Query Language (PromQL). Para obter mais detalhes sobre os recursos compatíveis com o Prometheus, consulte o Documentação do Prometheus.

A distribuição do Kubeflow na AWS fornece suporte para a integração com os seguintes serviços gerenciados da AWS:

1. Amazon Managed Prometheus (AMP) que é um Prometeu- serviço de monitoramento compatível para infraestrutura de contêiner e métricas de aplicativo para contêineres que facilita para os clientes monitorar com segurança os ambientes de contêiner em escala. Usando o AMP, você pode visualizar, analisar e emitir alarmes sobre suas métricas, logs e rastreamentos coletados de várias fontes de dados em seu sistema de observabilidade, incluindo AWS, ISVs de terceiros e outros recursos em seu portfólio de TI.
2. Amazon Managed Grafana, um serviço de visualização de dados totalmente gerenciado e seguro baseado no código aberto grafana projeto, que permite aos clientes consultar instantaneamente, correlacionar e visualizar métricas operacionais, logs e rastreamentos para seus aplicativos de várias fontes de dados. O Amazon Managed Grafana descarrega o gerenciamento operacional do Grafana, dimensionando automaticamente a infraestrutura de computação e banco de dados à medida que as demandas de uso aumentam, com atualizações de versão automatizadas e patches de segurança.

A distribuição do Kubeflow na AWS fornece suporte para a integração do Amazon Managed Service for Prometheus e do Amazon Managed Grafana para facilitar a ingestão e a visualização das métricas do Prometheus com segurança em escala.

As seguintes métricas são ingeridas e podem ser visualizadas:

• Métricas emitidas de componentes do Kubeflow, como Kubeflow Pipelines e o servidor Notebook
• Kubeflow métricas do plano de controle

Para configurar o Amazon Managed Service for Prometheus e o Amazon Managed Grafana para seu cluster Kubeflow, consulte Use Prometheus, Amazon Managed Service for Prometheus e Amazon Managed Grafana para monitorar métricas com Kubeflow na AWS.

Visão geral da solução

Neste caso de uso, usamos a implantação do Kubeflow vanilla usando a opção de instalação do Terraform. Quando a instalação estiver concluída, efetuamos login no painel do Kubeflow. No painel, criamos um servidor de notebook Kubeflow Jupyter para criar um pipeline Kubeflow que usa o SageMaker para executar treinamento distribuído para um modelo de classificação de imagem e um endpoint SageMaker para implantação de modelo.

Pré-requisitos

Certifique-se de atender aos seguintes pré-requisitos:

• Você tem uma Conta da AWS.
• Certifique-se de que você está no us-west-2 Região para executar este exemplo.
• Use o Google Chrome para interagir com o Console de gerenciamento da AWS e Kubeflow.
• Certifique-se de que sua conta tenha o limite de tipo de recurso de treinamento do SageMaker para ml.p3.2xlarge aumentado para 2 usando o console Cotas de serviço.
• Opcionalmente, você pode usar Nuvem AWS9, um ambiente de desenvolvimento integrado (IDE) baseado em nuvem que permite concluir todo o trabalho do seu navegador da web. Para obter instruções de configuração, consulte Configurar Cloud9 IDE. Selecione Ubuntu Server 18.04 como uma plataforma nas configurações do AWS Cloud9.Em seguida, no ambiente do AWS Cloud9, escolha o sinal de mais e abra um novo terminal.

Você também configura um Interface de linha de comando da AWS (AWS CLI). Para fazer isso, você precisa de um ID de chave de acesso e uma chave de acesso secreta de um Gerenciamento de acesso e identidade da AWS (IAM) usuário conta com privilégios administrativos (anexe a política gerenciada existente) e acesso programático. Veja o seguinte código:

aws configure --profile=kubeflow

AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

Verifique as permissões que o cloud9 usará para chamar os recursos da AWS.

aws sts get-caller-identity

Verifique na saída abaixo se você vê o arn do usuário administrador que você configurou no perfil da AWS CLI. Neste exemplo, é “kubeflow-user”

{
    "UserId": "*******",
    "Account": "********",
    "Arn": "arn:aws:iam::*******:user/kubeflow-user"
}

Instale o Amazon EKS e o Kubeflow na AWS

Para instalar o Amazon EKS e o Kubeflow na AWS, conclua as seguintes etapas:

1. Configure seu ambiente para implantar o Kubeflow na AWS:

   #Clone the awslabs/kubeflow-manifests and the kubeflow/manifests repositories and check out the release branches of your choosing
   export KUBEFLOW_RELEASE_VERSION=v1.6.1
   export AWS_RELEASE_VERSION=v1.6.1-aws-b1.0.0
   git clone https://github.com/awslabs/kubeflow-manifests.git && cd kubeflow-manifests
   git checkout ${AWS_RELEASE_VERSION}
   git clone --branch ${KUBEFLOW_RELEASE_VERSION} https://github.com/kubeflow/manifests.git upstream
   
   export MANIFEST_DIR=$PWD

   #Install the necessary tools with the following command:
   make install-tools
   source ~/.bash_profile

2. Implante a versão básica do Kubeflow na AWS e recursos relacionados da AWS, como EKS, usando o Terraform. Observe que os volumes EBS usados ​​no grupo de nós EKS não são criptografados por padrão:

   #Define the following environment variables
   
   #Region to create the cluster in
   export CLUSTER_REGION=us-west-2
   #Name of the cluster to create
   export CLUSTER_NAME=

   cd deployments/vanilla/terraform
   
   #Save the variables to a .tfvars file
   cat < sample.auto.tfvars
   cluster_name="${CLUSTER_NAME}"
   cluster_region="${CLUSTER_REGION}"
   EOF
   
   #Run the following one-click command to deploy terraform to install EKS infrastructure and Kubeflow
   make deploy

Configurar as permissões do Kubeflow

1. Adicione permissões ao pod Notebook e ao pod de componentes Pipeline para fazer chamadas de API SageMaker, S3 e IAM usando kubeflow_iam_permissions.sh script.

   export NAMESPACE=kubeflow-user-example-com
   
   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/kubeflow_iam_permissions.sh
   chmod +x kubeflow_iam_permissions.sh
   ./kubeflow_iam_permissions.sh $NAMESPACE $CLUSTER_NAME $CLUSTER_REGION

2. Crie a função de execução do SageMaker para permitir que o trabalho de treinamento do SageMaker acesse o conjunto de dados de treinamento do serviço S3 usando sagemaker_role.sh script.

   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/sagemaker_role.sh
   chmod +x sagemaker_role.sh
   ./sagemaker_role.sh

Acesse o painel do Kubeflow

Para acessar o painel do Kubeflow, conclua as seguintes etapas:

1. Você pode executar o painel Kubeflow localmente no ambiente Cloud9 sem expor seus URLs à Internet pública executando os comandos abaixo.

   # Configure Kubecontext
   $(terraform output -raw configure_kubectl)
   
   cd ${MANIFEST_DIR}
   make port-forward

2. Escolha Pré-visualizar aplicativo em execução.
3. Escolha o ícone no canto do painel do Kubeflow para abri-lo como uma guia separada no Chrome.
4. Digite as credenciais padrão (user@example.com/12341234) para fazer login no painel do Kubeflow.

Configurar o Kubeflow no ambiente AWS

Depois de fazer login no painel do Kubeflow, certifique-se de ter o namespace correto (kubeflow-user-example-com) escolhido. Conclua as etapas a seguir para configurar seu Kubeflow no ambiente da AWS:

1. No painel do Kubeflow, escolha Notebooks no painel de navegação.
2. Escolha Novo caderno.
3. Escolha Nome, entrar aws-nb.
4. Escolha Imagem de registro do Jupyter, escolha a imagem jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (o último disponível jupyter-pytorch imagem DLC).
5. Escolha CPU, entrar 1.
6. Escolha Memória, entrar 5.
7. Escolha GPUs, deixe como nenhum.
8. Não faça nenhuma alteração no Área de trabalho e Volumes de dados .
9. Selecionar Permitir acesso ao Kubeflow Pipelines no configurações seção e escolha Iniciar.
10. Verifique se o seu notebook foi criado com sucesso (pode levar alguns minutos).
11. Escolha CONTATE-NOS para fazer login no JupyterLab.
12. Clone o repositório digitando https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git no Clonar um repositório campo.
13. Escolha clone.

Executar um exemplo de treinamento distribuído

Depois de configurar o notebook Jupyter, você pode executar a demonstração inteira usando as seguintes etapas de alto nível da pasta eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training no repositório clonado:

1. Execute o script de treinamento PyTorch Distributed Data Parallel (DDP) – Consulte o script de treinamento PyTorch DDP cifar10-distributed-gpu-final.py, que inclui um exemplo de rede neural convolucional e lógica para distribuir o treinamento em um cluster de CPU e GPU de vários nós.
2. Criar um pipeline do Kubeflow - Executar o notebook STEP1.0_create_pipeline_k8s_sagemaker.ipynb para criar um pipeline que executa e implanta modelos no SageMaker. Certifique-se de instalar a biblioteca SageMaker como parte da primeira célula do notebook e reinicie o kernel antes de executar o restante das células do notebook.
3. Invocar um endpoint do SageMaker - Executar o notebook STEP1.1_invoke_sagemaker_endpoint.ipynb para invocar e testar o ponto de extremidade de inferência do modelo SageMaker criado no notebook anterior.

Nas seções subsequentes, discutiremos cada uma dessas etapas em detalhes.

Execute o script de treinamento PyTorch DDP

Como parte do treinamento distribuído, treinamos um modelo de classificação criado por uma rede neural convolucional simples que opera no conjunto de dados CIFAR10. O roteiro de treinamento cifar10-distributed-gpu-final.py contém apenas as bibliotecas de código aberto e é compatível para execução em clusters de treinamento Kubernetes e SageMaker em dispositivos de GPU ou instâncias de CPU. Vejamos alguns aspectos importantes do script de treinamento antes de executarmos nossos exemplos de notebook.

Usamos o torch.distributed módulo, que contém suporte a PyTorch e primitivas de comunicação para paralelismo de vários processos entre nós no cluster:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

Criamos um modelo simples de classificação de imagens usando uma combinação de camadas convolucionais, max pooling e lineares às quais um relu a função de ativação é aplicada na passagem direta do treinamento do modelo:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

Se o cluster de treinamento tiver GPUs, o script executa o treinamento em dispositivos CUDA e a variável de dispositivo mantém o dispositivo CUDA padrão:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

Antes de executar o treinamento distribuído usando o PyTorch DistributedDataParallel para executar o processamento distribuído em vários nós, você precisa inicializar o ambiente distribuído chamando init_process_group. Isso é inicializado em cada máquina do cluster de treinamento.

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

Instanciamos o modelo do classificador e copiamos o modelo para o dispositivo de destino. Se o treinamento distribuído estiver habilitado para execução em vários nós, o DistributedDataParallel A classe é usada como um objeto wrapper em torno do objeto modelo, o que permite o treinamento distribuído síncrono em várias máquinas. Os dados de entrada são divididos na dimensão do lote e uma réplica do modelo é colocada em cada máquina e cada dispositivo. Veja o seguinte código:

model = Net().to(device)

if is_distributed:
model = torch.nn.parallel.DistributedDataParallel(model)

...

Criar um pipeline do Kubeflow

O caderno usa o SDK do Kubeflow Pipelines e seu conjunto fornecido de pacotes Python para especificar e executar os pipelines de fluxo de trabalho de ML. Como parte deste SDK, usamos o decorador de pacote de linguagem específica de domínio (DSL) dsl.pipeline, que decora as funções do Python para retornar um pipeline.

O pipeline do Kubeflow usa o componente SageMaker V2 para enviar treinamento ao SageMaker usando SageMaker ACK Operators. A criação e a implantação do modelo do SageMaker usam o componente SageMaker V1, que são componentes do SageMaker baseados em Boto3. Usamos uma combinação de ambos os componentes neste exemplo para demonstrar a flexibilidade que você tem na escolha.

1. Carregue os componentes do SageMaker usando o seguinte código:

   # Loads SageMaker training components v2 for Kubeflow pipeline from the URL
   sagemaker_train_ack_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/d4aaa03035f221351ebe72fbd74fcfccaf25bb66/components/aws/sagemaker/TrainingJob/component.yaml')
   
   # Loads SageMaker components v1 for Kubeflow pipeline from the URL
   sagemaker_model_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/model/component.yaml')
   sagemaker_deploy_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/deploy/component.yaml')

   No código a seguir, criamos o pipeline Kubeflow onde executamos o treinamento distribuído do SageMaker usando dois ml.p3.2xlarge instâncias:

   # Create Kubeflow Pipeline using Amazon SageMaker Service
   @dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
   def pytorch_cnn_pipeline(region=target_region,
   train_image=aws_dlc_sagemaker_train_image,
   serving_image=aws_dlc_sagemaker_serving_image,
   learning_rate='0.01',
   pytorch_backend='gloo',
   training_job_name=pytorch_distributed_jobname,
   instance_type='ml.p3.2xlarge',
   instance_count='2',
   network_isolation='False',
   traffic_encryption='False',
   ):
   
   # Step to run training on SageMaker using SageMaker Components V2 for Pipeline.
   training = sagemaker_train_ack_op(
   region=region,
   algorithm_specification=(f'{{ '
   f'"trainingImage": "{train_image}",'
   '"trainingInputMode": "File"'
   f'}}'),
   training_job_name=training_job_name,
   hyper_parameters=(f'{{ '
   f'"backend": "{pytorch_backend}",'
   '"batch-size": "64",'
   '"epochs": "10",'
   f'"lr": "{learning_rate}",'
   '"model-type": "custom",'
   '"sagemaker_container_log_level": "20",'
   '"sagemaker_program": "cifar10-distributed-gpu-final.py",'
   f'"sagemaker_region": "{region}",'
   f'"sagemaker_submit_directory": "{source_s3}"'
   f'}}'),
   resource_config=(f'{{ '
   f'"instanceType": "{instance_type}",'
   f'"instanceCount": {instance_count},'
   '"volumeSizeInGB": 50'
   f'}}'),
   input_data_config=training_input(datasets),
   output_data_config=training_output(bucket_name),
   enable_network_isolation=network_isolation,
   enable_inter_container_traffic_encryption=traffic_encryption,
   role_arn=role,
   stopping_condition={"maxRuntimeInSeconds": 3600}
   )
   
   model_artifact_url = get_s3_model_artifact_op(
   training.outputs["model_artifacts"]
   ).output
   
   # This step creates SageMaker Model which refers to model artifacts and inference script to deserialize the input image
   create_model = sagemaker_model_op(
   region=region,
   model_name=training_job_name,
   image=serving_image,
   model_artifact_url=model_artifact_url,
   network_isolation=network_isolation,
   environment=(f'{{ '
   '"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",'
   '"SAGEMAKER_PROGRAM": "inference.py",'
   f'"SAGEMAKER_REGION": "{region}",'
   f'"SAGEMAKER_SUBMIT_DIRECTORY": "{model_artifact_url}"'
   f'}}'),
   role=role
   )
   
   # This step creates SageMaker Endpoint which will be called to run inference
   prediction = sagemaker_deploy_op(
   region=region,
   model_name_1=create_model.output,
   instance_type_1='ml.c5.xlarge'
   )
   
   #Disable pipeline cache
   training.execution_options.caching_strategy.max_cache_staleness = "P0D"

   Depois que o pipeline é definido, você pode compilar o pipeline para uma especificação Argo YAML usando o SDK do Kubeflow Pipelines kfp.compiler pacote. Você pode executar esse pipeline usando o cliente Kubeflow Pipelines SDK, que chama o ponto de extremidade do serviço Pipelines e transmite os cabeçalhos de autenticação apropriados diretamente do bloco de anotações. Veja o seguinte código:

   # DSL Compiler that compiles pipeline functions into workflow yaml.
   kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")
   
   # Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
   client = kfp.Client()
   
   experiment = client.create_experiment(name="ml_workflow")
   
   # Run a specified pipeline
   my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")
   
   # Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

2. Escolha o Detalhes da execução link abaixo da última célula para visualizar o pipeline do Kubeflow. A captura de tela a seguir mostra os detalhes do nosso pipeline para o componente de treinamento e implantação do SageMaker.
3. Escolha a etapa do job de treinamento e no Logs guia, escolha o link de logs do CloudWatch para acessar os logs do SageMaker.
   A captura de tela a seguir mostra os logs do CloudWatch para cada uma das duas instâncias ml.p3.2xlarge.
4. Escolha qualquer um dos grupos para ver os logs.
5. Capture o terminal do SageMaker escolhendo o Sagemaker - Modelo de Implantação passo e copiando o endpoint_name valor do artefato de saída.

Invocar um endpoint do SageMaker

O caderno STEP1.1_invoke_sagemaker_endpoint.ipynb invoca o endpoint de inferência do SageMaker criado na etapa anterior. Certifique-se de atualizar o nome do endpoint:

# Invoke SageMaker Endpoint. * Ensure you update the endpoint
# You can grab the SageMaker Endpoint name by either 1) going to the pipeline visualization of Kubeflow console and click the component for deployment, or 2) Go to SageMaker console and go to the list of endpoints, and then substitute the name to the EndpointName='...' in this cell.

endpointName=''

response = client.invoke_endpoint(EndpointName=endpointName,
ContentType='application/x-image',
Body=payload)

pred = json.loads(response['Body'].read().decode())

output_vector_list=pred['score']

# Get outout vector of 10 classes
output_vector = output_vector_list[0]

# Find the class with highest probability
max=output_vector[0]
index = 0
for i in range(1,len(output_vector)):
if output_vector[i] > max:
max = output_vector[i]
index = i

print(f'Index of the maximum value is : {index}')

labels = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

print(labels[index])

limpar

Para limpar seus recursos, conclua as seguintes etapas:

1. Execute os seguintes comandos no AWS Cloud9 para excluir os recursos da AWS:

   cd ${MANIFEST_DIR}/deployments/vanilla/terraform
   make delete

2. Excluir função do IAM “sagemakerrole” usando o seguinte comando da AWS CLI:

   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   aws iam delete-role --role-name sagemakerrole

3. Exclua o endpoint do SageMaker usando o seguinte comando da AWS CLI:

   aws sagemaker delete-endpoint --endpoint-name  --region us-west-2

Resumo

Nesta postagem, destacamos o valor que o Kubeflow na AWS 1.6.1 fornece por meio de integrações nativas de serviços gerenciados pela AWS para atender à necessidade de casos de uso de IA e ML de nível empresarial. Você pode escolher entre várias opções de implantação para instalar o Kubeflow na AWS com várias integrações de serviço usando Terraform, Kustomize ou Helm. O caso de uso nesta postagem demonstrou uma integração do Kubeflow com o SageMaker que usa um cluster de treinamento gerenciado do SageMaker para executar treinamento distribuído para um modelo de classificação de imagem e endpoint do SageMaker para implantação de modelo.

Também disponibilizamos um exemplo de pipeline de amostra que usa os componentes mais recentes do SageMaker; você pode executá-lo diretamente no painel do Kubeflow. Este canal requer o Dados do Amazon S3 e Função IAM de execução do SageMaker como as entradas necessárias.

Para começar a usar o Kubeflow na AWS, consulte as opções de implantação integrada à AWS disponíveis em Kubeflow na AWS. Você pode seguir o Repositório do AWS Labs para rastrear todas as contribuições da AWS para o Kubeflow. Você também pode nos encontrar no Kubeflow #AWS Canal Slack; seus comentários nos ajudarão a priorizar os próximos recursos para contribuir com o projeto Kubeflow.

Sobre os autores

Kanwaljit Khurmi é arquiteto de soluções sênior da Amazon Web Services. Ele trabalha com os clientes da AWS para fornecer orientação e assistência técnica, ajudando-os a melhorar o valor de suas soluções ao usar a AWS. A Kanwaljit é especializada em ajudar os clientes com aplicativos em contêiner e de aprendizado de máquina.

Kartik Kalamadi é um engenheiro de desenvolvimento de software na Amazon AI. Atualmente focado em projetos de código aberto de Machine Learning Kubernetes, como Kubeflow e AWS SageMaker Controller para k8s. No meu tempo livre, gosto de jogar jogos de PC e brincar com VR usando o motor Unity.

Rahul Kharse é um engenheiro de desenvolvimento de software na Amazon Web Services. Seu trabalho se concentra na integração de serviços da AWS com plataformas ML Ops de contêineres de código aberto para melhorar sua escalabilidade, confiabilidade e segurança. Além de se concentrar nas solicitações de recursos dos clientes, Rahul também gosta de experimentar os mais recentes desenvolvimentos tecnológicos na área.