Abilitazione di flussi di lavoro ML ibridi su Amazon EKS e Amazon SageMaker con Kubeflow con un clic sulla distribuzione AWS

Oggi, molti clienti AWS stanno costruendo piattaforme di machine learning (ML) pronte per l'azienda Servizio Amazon Elastic Kubernetes (Amazon EKS) utilizzando Kubeflow su AWS (una distribuzione di Kubeflow specifica per AWS) in molti casi d'uso, tra cui visione artificiale, comprensione del linguaggio naturale, traduzione vocale e modellazione finanziaria.

Grazie alla ultima versione di Kubeflow open source v1.6.1, la community di Kubeflow continua a supportare questa adozione su larga scala di Kubeflow per i casi d'uso aziendali. L'ultima versione include molte nuove entusiasmanti funzionalità come il supporto per Kubernetes v1.22, l'SDK Python combinato per PyTorch, MXNet, MPI, XGBoost nell'operatore di formazione distribuito di Kubeflow, i nuovi ClusterServingRuntime e ServingRuntime CRD per il servizio modello e molti altri.

I contributi di AWS a Kubeflow con il recente lancio di Kubeflow su AWS 1.6.1 supportano tutte le funzionalità Kubeflow open source upstream e includono molte nuove integrazioni con i servizi AWS altamente ottimizzati, nativi per il cloud e pronti per l'impresa che ti aiuteranno a creare prodotti altamente affidabili, sistemi ML sicuri, portatili e scalabili.

In questo post, discutiamo delle nuove funzionalità di Kubeflow su AWS v1.6.1 e mettiamo in evidenza tre importanti integrazioni che sono state raggruppate su un'unica piattaforma per offrirti:

• Infrastructure as Code (IaaC) soluzione one-click che automatizza l'installazione end-to-end di Kubeflow, inclusa la creazione di cluster EKS
• Supporto per la formazione distribuita su Amazon Sage Maker utilizzando Operatori Amazon SageMaker per Kubernetes (ACK) e Componenti SageMaker per pipeline Kubeflow e localmente su Kubernetes utilizzando Operatori di formazione Kubeflow. Molti clienti utilizzano questa capacità per creare architetture ibride di machine learning in cui sfruttano sia il calcolo Kubernetes per la fase di sperimentazione sia SageMaker per eseguire carichi di lavoro su scala di produzione.
• Monitoraggio e osservabilità migliorati per i carichi di lavoro ML tra cui Amazon EKS, parametri Kubeflow e registri delle applicazioni utilizzando Prometheus, Grafana e Amazon Cloud Watch integrazioni

Il caso d'uso in questo blog si concentrerà in particolare sull'integrazione di SageMaker con Kubeflow su AWS che potrebbe essere aggiunta ai tuoi flussi di lavoro Kubernetes esistenti consentendoti di creare architetture ibride di machine learning.

Kubeflow su AWS

Kubeflow su AWS 1.6.1 fornisce un percorso chiaro per utilizzare Kubeflow, con l'aggiunta dei seguenti servizi AWS oltre alle funzionalità esistenti:

• Integrazione di SageMaker con Kubeflow per eseguire flussi di lavoro ML ibridi utilizzando SageMaker Operators for Kubernetes (ACK) e SageMaker Components for Kubeflow Pipelines.
• Le opzioni di distribuzione automatizzata sono state migliorate e semplificate utilizzando gli script Kustomize e i grafici Helm.
• Aggiunto il supporto per la distribuzione con un clic di Infrastructure as Code (IaC) per Kubeflow su AWS utilizzando Terraform per tutti i servizi disponibili opzioni di distribuzione. Questo script automatizza la creazione delle seguenti risorse AWS:
• Supporto per Collegamento privato AWS per Amazon S3 che consente agli utenti della regione non commerciale di connettersi ai rispettivi endpoint S3.
• Aggiunta integrazione con Servizio gestito da Amazon per Prometheus (AMP) e Grafana gestita da Amazon per monitorare i parametri con Kubeflow su AWS.
• Contenitori del server notebook Kubeflow aggiornati con le ultime immagini del contenitore di deep learning basate su TensorFlow 2.10.0 e PyTorch 1.12.1.
• Integrazione con i DLC AWS per l'esecuzione distribuita formazione ed inferenza carichi di lavoro.

Il seguente diagramma dell'architettura è una rapida istantanea di tutte le integrazioni di servizi (incluse quelle già menzionate) disponibili per il controllo Kubeflow e i componenti del piano dati in Kubeflow su AWS. Il piano di controllo Kubeflow è installato su Amazon EKS, che è un servizio container gestito utilizzato per eseguire e ridimensionare le applicazioni Kubernetes nel cloud. Queste integrazioni di servizi AWS ti consentono di disaccoppiare parti critiche del piano di controllo Kubeflow da Kubernetes, fornendo un design sicuro, scalabile, resiliente e ottimizzato in termini di costi. Per maggiori dettagli sul valore che queste integrazioni di servizi aggiungono rispetto a Kubeflow open source, fare riferimento a Crea e distribuisci un sistema di machine learning scalabile su Kubernetes con Kubeflow su AWS.

Discutiamo in modo più dettagliato su come le funzionalità chiave di Kubeflow su AWS 1.6.1 potrebbero essere utili per la tua organizzazione.

Dettagli sulle funzionalità di Kubeflow su AWS

Con la versione Kubeflow 1.6.1, abbiamo cercato di fornire strumenti migliori per diversi tipi di clienti che rendono facile iniziare con Kubeflow, indipendentemente dalle opzioni scelte. Questi strumenti forniscono un buon punto di partenza e possono essere modificati per soddisfare le tue esatte esigenze.

Opzioni di distribuzione

Forniamo diverse opzioni di implementazione per diversi casi d'uso dei clienti. Qui puoi scegliere con quali servizi AWS vuoi integrare la tua distribuzione Kubeflow. Se decidi di modificare le opzioni di distribuzione in un secondo momento, ti consigliamo di eseguire una nuova installazione per la nuova distribuzione. Sono disponibili le seguenti opzioni di distribuzione:

Se desideri distribuire Kubeflow con modifiche minime, considera il vaniglia opzione di distribuzione. Tutte le opzioni di distribuzione disponibili possono essere installate utilizzando Kustomize, Helm o Terraform.

Disponiamo inoltre di diverse distribuzioni di componenti aggiuntivi che possono essere installate in cima a una qualsiasi di queste opzioni di implementazione:

Opzioni di installazione

Dopo aver deciso quale opzione di distribuzione si adatta meglio alle tue esigenze, puoi scegliere come installare queste distribuzioni. Nel tentativo di servire allo stesso modo esperti e nuovi arrivati, abbiamo diversi livelli di automazione e configurazione.

Opzione 1: Terraform (IaC)

Questo crea un cluster EKS e tutte le relative risorse dell'infrastruttura AWS, quindi distribuisce Kubeflow tutto in un unico comando utilizzando Terraform. Internamente, questo utilizza i progetti EKS e i grafici Helm.

Questa opzione presenta i seguenti vantaggi:

• Fornisce flessibilità alle aziende per distribuire Amazon EKS e Kubeflow con un solo comando senza doversi preoccupare delle configurazioni specifiche dei componenti Kubeflow. Ciò contribuirà enormemente ad accelerare la valutazione della tecnologia, la prototipazione e il ciclo di vita dello sviluppo del prodotto, fornendo la flessibilità necessaria per utilizzare i moduli terraform e modificarli per soddisfare qualsiasi esigenza specifica del progetto.
• Molte organizzazioni oggi che hanno Terraform al centro della loro strategia cloud possono ora utilizzare Kubeflow sulla soluzione AWS Terraform per raggiungere i propri obiettivi cloud.

Opzione 2: Kustomize o grafici Helm:

Questa opzione ti consente di distribuire Kubeflow in un processo in due fasi:

1. Crea risorse AWS come Amazon EKS, Amazon RDS, Amazon S3 e Amazon Cognito, tramite gli script automatizzati inclusi nella distribuzione AWS o manualmente seguendo un passo-passo guida.
2. Installa le distribuzioni Kubeflow utilizzando i grafici Helm o Kustomize.

Questa opzione presenta i seguenti vantaggi:

• L'obiettivo principale di questa opzione di installazione è fornire configurazioni Kubernetes correlate a Kubeflow. Pertanto, puoi scegliere di creare o importare cluster EKS esistenti o una qualsiasi delle risorse AWS correlate come Amazon RDS, Amazon S3 e Amazon Cognito e configurarli e gestirli in modo che funzionino con Kubeflow su AWS.
• È più facile passare da un manifest Kustomize Kubeflow open source alla distribuzione AWS Kubeflow.

Il diagramma seguente illustra le architetture di entrambe le opzioni.

Integrazione con SageMaker

SageMaker è un servizio completamente gestito progettato e ottimizzato specificamente per la gestione dei flussi di lavoro ML. Rimuove il lavoro pesante indifferenziato della gestione dell'infrastruttura ed elimina la necessità di investire in IT e DevOps per gestire i cluster per la creazione di modelli di ML, la formazione e l'inferenza.

Molti clienti AWS che hanno requisiti di portabilità o restrizioni standard in locale utilizzano Amazon EKS per configurare pipeline ML ripetibili che eseguono carichi di lavoro di addestramento e inferenza. Tuttavia, ciò richiede agli sviluppatori di scrivere codice personalizzato per ottimizzare l'infrastruttura ML sottostante, fornire disponibilità e affidabilità elevate e rispettare i requisiti normativi e di sicurezza appropriati. Questi clienti desiderano quindi utilizzare SageMaker per un'infrastruttura gestita e ottimizzata in termini di costi per l'addestramento e le distribuzioni dei modelli e continuare a utilizzare Kubernetes per l'orchestrazione e le pipeline ML per mantenere la standardizzazione e la portabilità.

Per soddisfare questa esigenza, AWS ti consente di addestrare, mettere a punto e distribuire modelli in SageMaker da Amazon EKS utilizzando le due opzioni seguenti:

• Operatori ACK di Amazon SageMaker per Kubernetes, che si basano su Controller AWS per Kubernetes quadro (ACK). ACK è la strategia AWS che introduce la standardizzazione per la creazione di controller personalizzati Kubernetes che consentono agli utenti Kubernetes di eseguire il provisioning di risorse AWS come database o code di messaggi semplicemente utilizzando l'API Kubernetes. Gli operatori ACK di SageMaker rendono più facile per gli sviluppatori ML e i data scientist che utilizzano Kubernetes come piano di controllo addestrare, mettere a punto e distribuire modelli ML in SageMaker senza accedere alla console SageMaker.
• I Componenti SageMaker per pipeline Kubeflow, che ti consentono di integrare SageMaker con la portabilità e l'orchestrazione di Kubeflow Pipelines. Con i componenti SageMaker, ogni lavoro nel flusso di lavoro della pipeline viene eseguito su SageMaker anziché sul cluster Kubernetes locale. Ciò consente di creare e monitorare processi di formazione, messa a punto, implementazione degli endpoint e trasformazione in batch nativi di SageMaker dalle tue pipeline Kubeflow, consentendoti quindi di spostare il calcolo completo, inclusa l'elaborazione dei dati e i processi di formazione, dal cluster Kubernetes al servizio gestito ottimizzato per l'apprendimento automatico di SageMaker.

A partire da Kubeflow su AWS v1.6.1, tutte le opzioni di distribuzione Kubeflow disponibili riuniscono entrambe le opzioni di integrazione di Amazon SageMaker per impostazione predefinita su un'unica piattaforma. Ciò significa che ora puoi inviare i lavori SageMaker utilizzando gli operatori ACK SageMaker da un server notebook Kubeflow stesso inviando la risorsa SageMaker personalizzata o dalla fase della pipeline Kubeflow utilizzando i componenti SageMaker.

Esistono due versioni dei componenti SageMaker: Boto3 (AWS SDK for AWS SDK for Python) e componenti della versione 1 basati su SageMaker Operator for K8s (ACK). I nuovi componenti SageMaker versione 2 supportano le più recenti API di formazione SageMaker e continueremo ad aggiungere altre funzionalità SageMaker a questa versione del componente. Tuttavia, hai la flessibilità di combinare la versione 2 dei componenti Sagemaker per la formazione e la versione 2 per altre funzionalità di SageMaker come l'ottimizzazione degli iperparametri, l'elaborazione dei processi, l'hosting e molto altro.

Integrazione con Prometeo e Grafana

Prometheus è uno strumento di aggregazione di metriche open source che puoi configurare per l'esecuzione su cluster Kubernetes. Durante l'esecuzione su cluster Kubernetes, un server Prometheus principale esegue periodicamente lo scraping degli endpoint pod.

I componenti Kubeflow, come Kubeflow Pipelines (KFP) e Notebook, emettono metriche Prometheus per consentire il monitoraggio delle risorse dei componenti come il numero di esperimenti in esecuzione o il conteggio dei notebook.

Queste metriche possono essere aggregate da un server Prometheus in esecuzione nel cluster Kubernetes e interrogate utilizzando Prometheus Query Language (PromQL). Per maggiori dettagli sulle funzionalità supportate da Prometheus, consulta il Documentazione Prometeo.

La distribuzione Kubeflow su AWS fornisce supporto per l'integrazione con i seguenti servizi gestiti da AWS:

1. Amazon Managed Prometheus (AMP) che è un Prometeo-servizio di monitoraggio compatibile per l'infrastruttura dei container e le metriche dell'applicazione per i container che rende facile per i clienti monitorare in modo sicuro gli ambienti dei container su larga scala. Utilizzando AMP, puoi visualizzare, analizzare e inviare allarmi su parametri, log e tracce raccolti da più origini dati nel tuo sistema di osservabilità, tra cui AWS, ISV di terze parti e altre risorse nel tuo portafoglio IT.
2. Amazon Managed Grafana, un servizio di visualizzazione dei dati completamente gestito e sicuro basato sull'open source graminacee progetto, che consente ai clienti di interrogare, correlare e visualizzare istantaneamente metriche operative, registri e tracce per le loro applicazioni da più origini dati. Amazon Managed Grafana alleggerisce la gestione operativa di Grafana ridimensionando automaticamente l'infrastruttura di elaborazione e database all'aumentare delle richieste di utilizzo, con aggiornamenti automatici delle versioni e patch di sicurezza.

La distribuzione Kubeflow su AWS fornisce supporto per l'integrazione di Amazon Managed Service for Prometheus e Amazon Managed Grafana per facilitare l'acquisizione e la visualizzazione dei parametri Prometheus in modo sicuro e su larga scala.

Le seguenti metriche vengono acquisite e possono essere visualizzate:

• Metriche emesse da componenti Kubeflow come Kubeflow Pipelines e il server Notebook
• Kubeflow metriche del piano di controllo

Per configurare Amazon Managed Service per Prometheus e Amazon Managed Grafana per il tuo cluster Kubeflow, fai riferimento a Utilizza Prometheus, Amazon Managed Service for Prometheus e Amazon Managed Grafana per monitorare i parametri con Kubeflow su AWS.

Panoramica della soluzione

In questo caso d'uso, utilizziamo la distribuzione Vanilla Kubeflow utilizzando l'opzione di installazione Terraform. Al termine dell'installazione, accediamo alla dashboard di Kubeflow. Dalla dashboard, avviamo un server notebook Kubeflow Jupyter per creare una pipeline Kubeflow che utilizza SageMaker per eseguire l'addestramento distribuito per un modello di classificazione delle immagini e un endpoint SageMaker per la distribuzione del modello.

Prerequisiti

Assicurati di soddisfare i seguenti prerequisiti:

• Si dispone di un Account AWS.
• Assicurati di essere nel file us-west-2 Region per eseguire questo esempio.
• Usa Google Chrome per interagire con il Console di gestione AWS e KubeFlow.
• Assicurati che il tuo account abbia il limite del tipo di risorsa SageMaker Training per ml.p3.2xlarge aumentato a 2 utilizzando la console Service Quotas.
• Facoltativamente, puoi usare AWS Cloud9, un ambiente di sviluppo integrato (IDE) basato su cloud che consente di completare tutto il lavoro dal tuo browser web. Per le istruzioni di configurazione, fare riferimento a Configura Cloud9 IDE. Seleziona Ubuntu Server 18.04 come piattaforma nelle impostazioni di AWS Cloud9.Quindi dal tuo ambiente AWS Cloud9, scegli il segno più e apri un nuovo terminale.

Configura anche un file Interfaccia della riga di comando di AWS (AWS CLI). Per fare ciò, è necessario un ID chiave di accesso e una chiave di accesso segreta di un Gestione dell'identità e dell'accesso di AWS (SONO) Utente account con privilegi di amministratore (allegare la policy gestita esistente) e accesso programmatico. Vedere il codice seguente:

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

Verifica le autorizzazioni che cloud9 utilizzerà per chiamare le risorse AWS.

aws sts get-caller-identity

Verifica dall'output seguente di vedere l'arn dell'utente admin che hai configurato nel profilo AWS CLI. In questo esempio è "kubeflow-user"

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

Installa Amazon EKS e Kubeflow su AWS

Per installare Amazon EKS e Kubeflow su AWS, completa i seguenti passaggi:

1. Configura il tuo ambiente per la distribuzione di Kubeflow su 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. Distribuisci la versione vanilla di Kubeflow su AWS e le relative risorse AWS come EKS utilizzando Terraform. Tieni presente che i volumi EBS utilizzati nel gruppo di nodi EKS non sono crittografati per impostazione predefinita:

   #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

Imposta le autorizzazioni Kubeflow

1. Aggiungi autorizzazioni al pod Notebook e al pod del componente Pipeline per effettuare chiamate API SageMaker, S3 e IAM utilizzando 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. Crea il ruolo di esecuzione SageMaker per consentire al processo di addestramento SageMaker di accedere al set di dati di addestramento dal servizio S3 utilizzando 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

Accedi alla dashboard di Kubeflow

Per accedere al dashboard di Kubeflow, completare i seguenti passaggi:

1. Puoi eseguire il dashboard Kubeflow localmente nell'ambiente Cloud9 senza esporre i tuoi URL a Internet pubblico eseguendo i comandi seguenti.

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

2. Scegli Anteprima dell'applicazione in esecuzione.
3. Scegli l'icona nell'angolo della dashboard di Kubeflow per aprirla come scheda separata in Chrome.
4. Immettere le credenziali predefinite (user@example.com/12341234) per accedere alla dashboard di Kubeflow.

Configurare Kubeflow nell'ambiente AWS

Una volta effettuato l'accesso alla dashboard di Kubeflow, assicurati di disporre dello spazio dei nomi corretto (kubeflow-user-example-com) scelto. Completa i seguenti passaggi per configurare il tuo ambiente Kubeflow su AWS:

1. Nella dashboard di Kubeflow, scegli Notebook nel pannello di navigazione.
2. Scegli Nuovo notebook.
3. Nel Nome, accedere aws-nb.
4. Nel Immagine di Jupyter Docket, scegli l'immagine jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (l'ultimo disponibile jupyter-pytorch immagine DLC).
5. Nel CPU, accedere 1.
6. Nel Memorie, accedere 5.
7. Nel GPU, lascia come Nessuna.
8. Non apportare modifiche al Area di lavoro ed Volumi di dati .
9. Seleziona Consenti l'accesso alle pipeline Kubeflow nel Configurazioni sezione e scegliere Avvia.
10. Verifica che il tuo taccuino sia stato creato correttamente (potrebbero essere necessari un paio di minuti).
11. Scegli Connettiti per accedere a JupyterLab.
12. Clona il repository inserendo https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git nel Clona un repository campo.
13. Scegli clone.

Eseguire un esempio di training distribuito

Dopo aver configurato il notebook Jupyter, puoi eseguire l'intera demo utilizzando i seguenti passaggi di alto livello dalla cartella eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training nel repository clonato:

1. Esegui lo script di addestramento PyTorch Distributed Data Parallel (DDP). – Fare riferimento allo script di formazione PyTorch DDP cifar10-distributed-gpu-final.py, che include una rete neurale convoluzionale di esempio e la logica per distribuire l'addestramento su un cluster CPU e GPU multi-nodo.
2. Crea una pipeline Kubeflow – Eseguire il taccuino STEP1.0_create_pipeline_k8s_sagemaker.ipynb per creare una pipeline che esegue e distribuisce i modelli su SageMaker. Assicurati di installare la libreria SageMaker come parte della prima cella del notebook e riavvia il kernel prima di eseguire il resto delle celle del notebook.
3. Richiama un endpoint SageMaker – Eseguire il taccuino STEP1.1_invoke_sagemaker_endpoint.ipynb per richiamare e testare l'endpoint di inferenza del modello SageMaker creato nel notebook precedente.

Nelle sezioni successive, discuteremo in dettaglio ciascuno di questi passaggi.

Esegui lo script di addestramento PyTorch DDP

Come parte del training distribuito, formiamo un modello di classificazione creato da una semplice rete neurale convoluzionale che opera sul set di dati CIFAR10. Il copione di formazione cifar10-distributed-gpu-final.py contiene solo le librerie open source ed è compatibile per l'esecuzione su entrambi i cluster di formazione Kubernetes e SageMaker su dispositivi GPU o istanze CPU. Diamo un'occhiata ad alcuni aspetti importanti dello script di formazione prima di eseguire i nostri esempi di notebook.

Usiamo il torch.distributed modulo, che contiene il supporto PyTorch e le primitive di comunicazione per il parallelismo multiprocesso tra i nodi del 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
...

Creiamo un semplice modello di classificazione delle immagini utilizzando una combinazione di strati convoluzionali, max pooling e lineari a cui a relu la funzione di attivazione viene applicata nel passaggio in avanti dell'addestramento del modello:

# 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 il cluster di formazione dispone di GPU, lo script esegue il training sui dispositivi CUDA e la variabile del dispositivo contiene il dispositivo CUDA predefinito:

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

Prima di eseguire la formazione distribuita utilizzando PyTorch DistributedDataParallel per eseguire l'elaborazione distribuita su più nodi, è necessario inizializzare l'ambiente distribuito chiamando init_process_group. Viene inizializzato su ogni macchina del cluster di addestramento.

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

Istanziamo il modello classificatore e copiamo il modello sul dispositivo di destinazione. Se la formazione distribuita è abilitata per l'esecuzione su più nodi, il DistributedDataParallel class viene utilizzata come oggetto wrapper attorno all'oggetto modello, che consente l'addestramento distribuito sincrono su più macchine. I dati di input vengono suddivisi sulla dimensione batch e una replica del modello viene posizionata su ogni macchina e ogni dispositivo. Vedere il seguente codice:

model = Net().to(device)

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

...

Crea una pipeline Kubeflow

Il taccuino utilizza il SDK delle pipeline Kubeflow e il set fornito di pacchetti Python per specificare ed eseguire le pipeline del flusso di lavoro ML. Come parte di questo SDK, utilizziamo il decoratore di pacchetti DSL (Domain-Specific Language). dsl.pipeline, che decora le funzioni Python per restituire una pipeline.

La pipeline Kubeflow utilizza il componente SageMaker V2 per inviare la formazione a SageMaker utilizzando gli operatori ACK di SageMaker. La creazione e la distribuzione del modello SageMaker utilizza il componente SageMaker V1, che sono componenti SageMaker basati su Boto3. Usiamo una combinazione di entrambi i componenti in questo esempio per dimostrare la flessibilità che hai nella scelta.

1. Carica i componenti SageMaker utilizzando il seguente codice:

   # 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')

   Nel codice seguente, creiamo la pipeline Kubeflow in cui eseguiamo l'addestramento distribuito di SageMaker utilizzando due ml.p3.2xlarge istanze:

   # 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"

   Dopo che la pipeline è stata definita, puoi compilare la pipeline in base a una specifica Argo YAML utilizzando l'SDK di Kubeflow Pipelines kfp.compiler pacchetto. Puoi eseguire questa pipeline utilizzando il client Kubeflow Pipelines SDK, che chiama l'endpoint del servizio Pipelines e passa le intestazioni di autenticazione appropriate direttamente dal notebook. Vedere il seguente codice:

   # 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. Scegliere il Dettagli dell'esecuzione collegamento sotto l'ultima cella per visualizzare la pipeline Kubeflow. Lo screenshot seguente mostra i dettagli della nostra pipeline per il componente di addestramento e distribuzione di SageMaker.
3. Scegli la fase del lavoro di formazione e sul Registri scheda, scegli il collegamento ai log di CloudWatch per accedere ai log di SageMaker.
   Lo screenshot seguente mostra i log di CloudWatch per ciascuna delle due istanze ml.p3.2xlarge.
4. Scegli uno dei gruppi per vedere i log.
5. Cattura l'endpoint SageMaker scegliendo il file Sagemaker – Modello di distribuzione passo e copiando il file endpoint_name valore dell'artefatto di output.

Richiama un endpoint SageMaker

Il notebook STEP1.1_invoke_sagemaker_endpoint.ipynb richiama l'endpoint di inferenza SageMaker creato nel passaggio precedente. Assicurati di aggiornare il nome dell'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])

ripulire

Per ripulire le tue risorse, completa i seguenti passaggi:

1. Esegui i seguenti comandi in AWS Cloud9 per eliminare le risorse AWS:

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

2. Elimina ruolo IAM "sagemakerrole” utilizzando il seguente comando 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. Elimina l'endpoint SageMaker utilizzando il seguente comando AWS CLI:

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

Sommario

In questo post, abbiamo evidenziato il valore che Kubeflow su AWS 1.6.1 fornisce attraverso integrazioni di servizi gestiti da AWS nativi per soddisfare le esigenze di casi d'uso di AI e ML a livello aziendale. Puoi scegliere tra diverse opzioni di distribuzione per installare Kubeflow su AWS con varie integrazioni di servizi utilizzando Terraform, Kustomize o Helm. Il caso d'uso in questo post ha dimostrato un'integrazione Kubeflow con SageMaker che utilizza un cluster di addestramento gestito da SageMaker per eseguire l'addestramento distribuito per un modello di classificazione delle immagini e un endpoint SageMaker per la distribuzione del modello.

Abbiamo anche messo a disposizione un esempio di pipeline di esempio che utilizza i componenti SageMaker più recenti; puoi eseguirlo direttamente dalla dashboard di Kubeflow. Questa pipeline richiede il Dati Amazon S3 ed Ruolo IAM di esecuzione di SageMaker come input richiesti.

Per iniziare con Kubeflow su AWS, fai riferimento alle opzioni di distribuzione integrate in AWS disponibili in Kubeflow su AWS. Puoi seguire il Repository di AWS Labs per tenere traccia di tutti i contributi AWS a Kubeflow. Ci puoi trovare anche sul Canale Kubeflow #AWS Slack; il tuo feedback ci aiuterà a stabilire la priorità delle funzionalità successive per contribuire al progetto Kubeflow.

Circa gli autori

Kanwaljit Khurmi è Senior Solutions Architect presso Amazon Web Services. Collabora con i clienti AWS per fornire guida e assistenza tecnica aiutandoli a migliorare il valore delle loro soluzioni quando utilizzano AWS. Kanwaljit è specializzato nell'aiutare i clienti con applicazioni containerizzate e di apprendimento automatico.

Kartik Kalamadi è un Software Development Engineer presso Amazon AI. Attualmente focalizzato su progetti open source di Machine Learning Kubernetes come Kubeflow e AWS SageMaker Controller per k8s. Nel mio tempo libero mi piace giocare ai giochi per PC e giocherellare con la realtà virtuale usando il motore Unity.

Raul Kharse è un Software Development Engineer presso Amazon Web Services. Il suo lavoro si concentra sull'integrazione dei servizi AWS con piattaforme ML Ops containerizzate open source per migliorarne la scalabilità, l'affidabilità e la sicurezza. Oltre a concentrarsi sulle richieste di funzionalità dei clienti, a Rahul piace anche sperimentare gli ultimi sviluppi tecnologici nel campo.