Activarea fluxurilor de lucru hibride ML pe Amazon EKS și Amazon SageMaker cu un singur clic Kubeflow pe implementarea AWS

Astăzi, mulți clienți AWS construiesc platforme de învățare automată (ML) pregătite pentru întreprindere Serviciul Amazon Elastic Kubernetes (Amazon EKS) folosind Kubeflow pe AWS (o distribuție specifică AWS a Kubeflow) în multe cazuri de utilizare, inclusiv viziunea computerizată, înțelegerea limbajului natural, traducerea vorbirii și modelarea financiară.

Cu cea mai recentă versiune a open-source Kubeflow v1.6.1, comunitatea Kubeflow continuă să sprijine această adoptare pe scară largă a Kubeflow pentru cazurile de utilizare ale întreprinderilor. Cea mai recentă versiune include multe funcții noi interesante, cum ar fi suportul pentru Kubernetes v1.22, SDK-ul Python combinat pentru PyTorch, MXNet, MPI, XGBoost în Operatorul de instruire distribuit al Kubeflow, noile CRD ClusterServingRuntime și ServingRuntime pentru serviciul de model și multe altele.

Contribuțiile AWS la Kubeflow odată cu lansarea recentă a Kubeflow pe AWS 1.6.1 acceptă toate funcțiile Kubeflow cu sursă deschisă din amonte și includ multe noi integrări cu serviciile AWS foarte optimizate, native pentru cloud și pregătite pentru întreprindere, care vă vor ajuta să construiți o fiabilitate ridicată. sisteme ML sigure, portabile și scalabile.

În această postare, discutăm despre noile funcții Kubeflow pe AWS v1.6.1 și evidențiem trei integrări importante care au fost grupate pe o singură platformă pentru a vă oferi::

• Soluție cu un singur clic Infrastructure as Code (IaaC) care automatizează instalarea de la capăt la cap a Kubeflow, inclusiv crearea clusterului EKS
• Sprijin pentru instruire distribuită pe Amazon SageMaker folosind Operatori Amazon SageMaker pentru Kubernetes (ACK) și Componente SageMaker pentru conductele Kubeflow și local pe Kubernetes folosind Operatori de formare Kubeflow. Mulți clienți folosesc această capacitate pentru a construi arhitecturi hibride de învățare automată în care folosesc atât calculul Kubernetes pentru faza de experimentare, cât și SageMaker pentru a rula sarcini de lucru la scară de producție.
• Monitorizare și observabilitate îmbunătățite pentru sarcinile de lucru ML, inclusiv Amazon EKS, metrici Kubeflow și jurnalele de aplicații folosind Prometheus, Grafana și Amazon CloudWatch integrările

Cazul de utilizare din acest blog se va concentra în mod special pe integrarea SageMaker cu Kubeflow pe AWS, care ar putea fi adăugată fluxurilor de lucru Kubernetes existente, permițându-vă să construiți arhitecturi hibride de învățare automată.

Kubeflow pe AWS

Kubeflow pe AWS 1.6.1 oferă o cale clară de utilizare a Kubeflow, cu adăugarea următoarelor servicii AWS pe lângă capabilitățile existente:

• Integrarea SageMaker cu Kubeflow pentru a rula fluxuri de lucru hibride ML folosind SageMaker Operators for Kubernetes (ACK) și SageMaker Components for Kubeflow Pipelines.
• Opțiunile de implementare automată au fost îmbunătățite și simplificate folosind scripturile Kustomize și diagramele Helm.
• S-a adăugat suport pentru implementarea cu un singur clic Infrastructure as Code (IaC) pentru Kubeflow pe AWS folosind Terraform pentru toate cele disponibile opțiuni de implementare. Acest script automatizează crearea următoarelor resurse AWS:
• Suport pentru AWS PrivateLink pentru Amazon S3, permițând utilizatorilor din regiune necomercială să se conecteze la punctele finale S3 respective.
• Integrare adăugată cu Serviciul gestionat Amazon pentru Prometheus (AMP) și Grafana gestionată de Amazon pentru a monitoriza valorile cu Kubeflow pe AWS.
• Containere de server de notebook-uri Kubeflow actualizate cu cele mai recente imagini de containere de deep learning bazate pe TensorFlow 2.10.0 și PyTorch 1.12.1.
• Integrare cu DLC-uri AWS pentru a rula distribuit pregătire și deducție sarcinile de lucru.

Următoarea diagramă de arhitectură este un instantaneu rapid al tuturor integrărilor de servicii (inclusiv cele menționate deja) care sunt disponibile pentru componentele de control Kubeflow și planul de date în Kubeflow pe AWS. Planul de control Kubeflow este instalat deasupra Amazon EKS, care este un serviciu container gestionat folosit pentru a rula și a scala aplicațiile Kubernetes în cloud. Aceste integrări de servicii AWS vă permit să decuplați părțile critice ale planului de control Kubeflow de Kubernetes, oferind un design sigur, scalabil, rezistent și optimizat din punct de vedere al costurilor. Pentru mai multe detalii despre valoarea pe care aceste integrări de servicii o adaugă față de Kubeflow cu sursă deschisă, consultați Construiți și implementați un sistem scalabil de învățare automată pe Kubernetes cu Kubeflow pe AWS.

Să discutăm mai detaliat despre modul în care caracteristicile cheie Kubeflow pe AWS 1.6.1 ar putea fi utile organizației dvs.

Detaliile caracteristicii Kubeflow pe AWS

Odată cu versiunea Kubeflow 1.6.1, am încercat să oferim instrumente mai bune pentru diferite tipuri de clienți, care facilitează începerea utilizării Kubeflow, indiferent de opțiunile pe care le alegeți. Aceste instrumente oferă un bun punct de plecare și pot fi modificate pentru a se potrivi exact nevoilor dumneavoastră.

Opțiuni de implementare

Oferim diferite opțiuni de implementare pentru diferite cazuri de utilizare ale clienților. Aici puteți alege cu ce servicii AWS doriți să integrați implementarea Kubeflow. Dacă decideți să modificați opțiunile de implementare mai târziu, vă recomandăm să faceți o nouă instalare pentru noua implementare. Sunt disponibile următoarele opțiuni de implementare:

Dacă doriți să implementați Kubeflow cu modificări minime, luați în considerare vanilie opțiunea de implementare. Toate opțiunile de implementare disponibile pot fi instalate folosind Kustomize, Helm sau Terraform.

Avem, de asemenea, diferite implementări de suplimente care pot fi instalate peste oricare dintre aceste opțiuni de implementare:

Opțiuni de instalare

După ce ați decis ce opțiune de implementare se potrivește cel mai bine nevoilor dvs., puteți alege cum doriți să instalați aceste implementări. În efortul de a servi experților și noilor veniți deopotrivă, avem diferite niveluri de automatizare și configurare.

Opțiunea 1: Terraform (IaC)

Aceasta creează un cluster EKS și toate resursele de infrastructură AWS aferente, apoi implementează Kubeflow într-o singură comandă folosind Terraform. Pe plan intern, aceasta utilizează planuri EKS și diagrame Helm.

Această opțiune are următoarele avantaje:

• Oferă flexibilitate întreprinderilor pentru a implementa Amazon EKS și Kubeflow cu o singură comandă, fără a fi nevoiți să vă faceți griji cu privire la configurațiile specifice ale componentelor Kubeflow. Acest lucru va ajuta enorm la accelerarea evaluării tehnologiei, a prototipurilor și a ciclului de viață al dezvoltării produsului, oferind flexibilitate pentru a utiliza module terraform și a le modifica pentru a răspunde oricăror nevoi specifice proiectului.
• Multe organizații de astăzi, care au Terraform ca centru al strategiei lor în cloud, pot folosi acum soluția Kubeflow on AWS Terraform pentru a-și îndeplini obiectivele cloud.

Opțiunea 2: Personalizare sau Helm Charts:

Această opțiune vă permite să implementați Kubeflow într-un proces în doi pași:

1. Creați resurse AWS precum Amazon EKS, Amazon RDS, Amazon S3 și Amazon Cognito, fie prin intermediul scripturilor automate incluse în distribuția AWS, fie manual, urmând un pas-cu-pas ghid.
2. Instalați implementările Kubeflow fie folosind diagramele Helm, fie Kustomize.

Această opțiune are următoarele avantaje:

• Scopul principal al acestei opțiuni de instalare este de a oferi configurații Kubernetes legate de Kubeflow. Prin urmare, puteți alege să creați sau să introduceți clustere EKS existente sau oricare dintre resursele AWS aferente, cum ar fi Amazon RDS, Amazon S3 și Amazon Cognito, și să le configurați și să le gestionați pentru a funcționa cu Kubeflow pe AWS.
• Este mai ușor să treceți de la un manifest Kustomize Kubeflow cu sursă deschisă la distribuția AWS Kubeflow.

Următoarea diagramă ilustrează arhitecturile ambelor opțiuni.

Integrare cu SageMaker

SageMaker este un serviciu complet gestionat, conceput și optimizat special pentru gestionarea fluxurilor de lucru ML. Îndepărtează greutățile nediferențiate ale managementului infrastructurii și elimină nevoia de a investi în IT și DevOps pentru a gestiona clustere pentru construirea de modele ML, instruire și inferență.

Mulți clienți AWS care au cerințe de portabilitate sau restricții standard la nivel local folosesc Amazon EKS pentru a configura conducte ML repetabile care rulează sarcini de lucru de instruire și inferență. Cu toate acestea, acest lucru necesită ca dezvoltatorii să scrie cod personalizat pentru a optimiza infrastructura ML subiacentă, pentru a oferi disponibilitate și fiabilitate ridicate și pentru a respecta cerințele de securitate și de reglementare adecvate. Prin urmare, acești clienți doresc să utilizeze SageMaker pentru o infrastructură gestionată și optimizată din punct de vedere al costurilor pentru instruirea și implementarea modelelor și să continue să utilizeze Kubernetes pentru orchestrare și pipeline ML pentru a păstra standardizarea și portabilitatea.

Pentru a răspunde acestei necesități, AWS vă permite să instruiți, să reglați și să implementați modele în SageMaker de la Amazon EKS utilizând următoarele două opțiuni:

• Operatorii Amazon SageMaker ACK pentru Kubernetes, care se bazează pe Controlere AWS pentru Kubernetes (ACK) cadru. ACK este strategia AWS care aduce standardizare pentru construirea de controlere personalizate Kubernetes, care permit utilizatorilor Kubernetes să furnizeze resurse AWS, cum ar fi baze de date sau cozi de mesaje, pur și simplu utilizând API-ul Kubernetes. Operatorii SageMaker ACK facilitează pentru dezvoltatorii ML și oamenii de știință de date care folosesc Kubernetes ca plan de control să antreneze, să ajusteze și să implementeze modele ML în SageMaker fără a se conecta la consola SageMaker.
• Componente SageMaker pentru conducte Kubeflow, care vă permit să integrați SageMaker cu portabilitatea și orchestrarea Kubeflow Pipelines. Cu componentele SageMaker, fiecare job din fluxul de lucru se execută pe SageMaker în loc de cluster-ul Kubernetes local. Acest lucru vă permite să creați și să monitorizați joburi native de instruire, reglare, implementare a punctelor terminale și transformare în loturi SageMaker din Kubeflow Pipelines, permițându-vă, astfel, să mutați calculul complet, inclusiv procesarea datelor și joburile de formare din clusterul Kubernetes la serviciul gestionat optimizat pentru învățarea automată SageMaker.

Începând cu Kubeflow pe AWS v1.6.1, toate opțiunile de implementare Kubeflow disponibile reunesc ambele opțiuni de integrare Amazon SageMaker în mod implicit pe o singură platformă. Aceasta înseamnă că acum puteți trimite joburi SageMaker utilizând operatori SageMaker ACK de pe un server Kubeflow Notebook însuși, trimițând resursa SageMaker personalizată sau din pasul pipeline Kubeflow folosind componente SageMaker.

Există două versiuni de SageMaker Components – Boto3 (AWS SDK pentru AWS SDK pentru Python) componente bazate pe versiunea 1 și SageMaker Operator pentru K8s (ACK) componente bazate pe versiunea 2. Noile componente SageMaker versiunea 2 acceptă cele mai recente ap-uri de instruire SageMaker și vom continua să adăugăm mai multe funcții SageMaker la această versiune a componentei. Cu toate acestea, aveți flexibilitatea de a combina componentele Sagemaker versiunea 2 pentru instruire și versiunea 1 pentru alte caracteristici SageMaker, cum ar fi reglarea hiperparametrului, procesarea joburilor, găzduirea și multe altele.

Integrare cu Prometheus și Grafana

Prometheus este un instrument open-source de agregare a valorilor pe care îl puteți configura să ruleze pe clustere Kubernetes. Când rulează pe clustere Kubernetes, un server principal Prometheus răzuiește periodic punctele terminale pod.

Componentele Kubeflow, cum ar fi Kubeflow Pipelines (KFP) și Notebook, emit valori Prometheus pentru a permite monitorizarea resurselor componente, cum ar fi numărul de experimente care rulează sau numărul de notebook-uri.

Aceste valori pot fi agregate de un server Prometheus care rulează în cluster-ul Kubernetes și interogate folosind Prometheus Query Language (PromQL). Pentru mai multe detalii despre funcțiile pe care Prometheus le acceptă, consultați Documentația Prometheus.

Distribuția Kubeflow on AWS oferă suport pentru integrarea cu următoarele servicii gestionate AWS:

1. Amazon Managed Prometheus (AMP), adică a Prometeu-serviciu de monitorizare compatibil pentru infrastructura containerelor și metrica aplicației pentru containere, care facilitează monitorizarea în siguranță a mediilor containerelor la scară de către clienți. Folosind AMP, puteți vizualiza, analiza și alarma valorile, jurnalele și urmele colectate din mai multe surse de date din sistemul dvs. de observabilitate, inclusiv AWS, ISV terți și alte resurse din portofoliul dvs. IT.
2. Amazon Managed Grafana, un serviciu de vizualizare a datelor complet gestionat și securizat, bazat pe sursa deschisă grafana proiect, care permite clienților să interogheze, să coreleze și să vizualizeze instantaneu valorile operaționale, jurnalele și urmele pentru aplicațiile lor din mai multe surse de date. Amazon Managed Grafana descarcă gestionarea operațională a Grafana prin scalarea automată a infrastructurii de calcul și a bazelor de date pe măsură ce cerințele de utilizare cresc, cu actualizări automate ale versiunilor și corecții de securitate.

Distribuția Kubeflow on AWS oferă suport pentru integrarea Amazon Managed Service pentru Prometheus și Amazon Managed Grafana pentru a facilita ingerarea și vizualizarea în siguranță a valorilor Prometheus la scară.

Următoarele valori sunt ingerate și pot fi vizualizate:

• Valori emise de componentele Kubeflow, cum ar fi Kubeflow Pipelines și serverul Notebook
• KubeFlow metrica planului de control

Pentru a configura Amazon Managed Service pentru Prometheus și Amazon Managed Grafana pentru clusterul dvs. Kubeflow, consultați Utilizați Prometheus, Amazon Managed Service pentru Prometheus și Amazon Managed Grafana pentru a monitoriza valorile cu Kubeflow pe AWS.

Prezentare generală a soluțiilor

În acest caz de utilizare, folosim implementarea Kubeflow vanilla folosind opțiunea de instalare Terraform. Când instalarea este finalizată, ne conectăm la tabloul de bord Kubeflow. Din tabloul de bord, pornim un server de notebook Kubeflow Jupyter pentru a construi o conductă Kubeflow care utilizează SageMaker pentru a rula instruire distribuită pentru un model de clasificare a imaginilor și un punct final SageMaker pentru implementarea modelului.

Cerințe preliminare

Asigurați-vă că îndepliniți următoarele cerințe preliminare:

• Ai un Cont AWS.
• Asigurați-vă că sunteți în us-west-2 Regiune pentru a rula acest exemplu.
• Utilizați Google Chrome pentru a interacționa cu Consola de administrare AWS și Kubeflow.
• Asigurați-vă că contul dvs. are limita tipului de resurse SageMaker Training pentru ml.p3.2xlarge crescută la 2 utilizând consola Cote de servicii.
• Opțional, puteți utiliza AWS Cloud9, un mediu de dezvoltare integrat (IDE) bazat pe cloud, care permite finalizarea întregii lucrări din browserul dvs. web. Pentru instrucțiuni de configurare, consultați Configurați Cloud9 IDE. Selectați Ubuntu Server 18.04 ca platformă în setările AWS Cloud9.Apoi, din mediul dvs. AWS Cloud9, alegeți semnul plus și deschideți un nou terminal.

De asemenea, configurați un Interfața liniei de comandă AWS profil (AWS CLI). Pentru a face acest lucru, aveți nevoie de un ID cheie de acces și o cheie de acces secretă a unui Gestionarea identității și accesului AWS (EU SUNT) utilizator cont cu privilegii administrative (atașați politica gestionată existentă) și acces programatic. Vezi următorul cod:

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ți permisiunile pe care cloud9 le va folosi pentru a apela resursele AWS.

aws sts get-caller-identity

Verificați din rezultatul de mai jos că vedeți numele utilizatorului administrator pe care l-ați configurat în profilul AWS CLI. În acest exemplu este „kubeflow-user”

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

Instalați Amazon EKS și Kubeflow pe AWS

Pentru a instala Amazon EKS și Kubeflow pe AWS, parcurgeți următorii pași:

1. Configurați-vă mediul pentru implementarea Kubeflow pe 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. Implementați versiunea vanilie a Kubeflow pe AWS și resursele AWS aferente, cum ar fi EKS, folosind Terraform. Rețineți că volumele EBS utilizate în grupul de noduri EKS nu sunt criptate în mod implicit:

   #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

Configurați permisiunile Kubeflow

1. Adăugați permisiuni la podul Notebook și podul componentei Pipeline pentru a efectua apeluri API SageMaker, S3 și IAM folosind kubeflow_iam_permissions.sh script-ul.

   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ți rolul de execuție SageMaker pentru a permite jobului de instruire SageMaker să acceseze setul de date de instruire din serviciul S3 folosind sagemaker_role.sh script-ul.

   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

Accesați tabloul de bord Kubeflow

Pentru a accesa tabloul de bord Kubeflow, parcurgeți următorii pași:

1. Puteți rula tabloul de bord Kubeflow local în mediul Cloud9 fără a vă expune adresele URL la internetul public, rulând comenzile de mai jos.

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

2. Alege Previzualizați aplicația care rulează.
3. Alegeți pictograma din colțul tabloului de bord Kubeflow pentru a o deschide ca o filă separată în Chrome.
4. Introduceți acreditările implicite (user@example.com/12341234) pentru a vă conecta la tabloul de bord Kubeflow.

Configurați mediul Kubeflow pe AWS

După ce v-ați conectat la tabloul de bord Kubeflow, asigurați-vă că aveți spațiul de nume potrivit (kubeflow-user-example-com) ales. Parcurgeți următorii pași pentru a vă configura mediul Kubeflow pe AWS:

1. Pe tabloul de bord Kubeflow, alegeți notebook-uri în panoul de navigare.
2. Alege Caiet nou.
3. Pentru Nume si Prenume, introduce aws-nb.
4. Pentru Jupyter Docket Image, alege imaginea jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (cel mai recent disponibil jupyter-pytorch imagine DLC).
5. Pentru Procesor, introduce 1.
6. Pentru Memorie, introduce 5.
7. Pentru unități de procesare grafică, lasa ca Nici unul.
8. Nu faceți nicio modificare la Spațiu de lucru și Volume de date secțiuni.
9. Selectați Permiteți accesul la Kubeflow Pipelines în Configurații secțiunea și Alegeți Lansare.
10. Verificați dacă blocnotesul este creat cu succes (poate dura câteva minute).
11. Alege Conectați pentru a vă conecta la JupyterLab.
12. Clonează repo-ul introducând https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git în Clonează un repo camp.
13. Alege Clone.

Rulați un exemplu de instruire distribuită

După ce ați configurat notebook-ul Jupyter, puteți rula întreaga demonstrație utilizând următorii pași de nivel înalt din dosar eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training în depozitul clonat:

1. Rulați scriptul de instruire PyTorch Distributed Data Parallel (DDP). – Consultați scriptul de instruire PyTorch DDP cifar10-distributed-gpu-final.py, care include un exemplu de rețea neuronală convoluțională și logică pentru a distribui antrenamentul pe un CPU cu mai multe noduri și un cluster GPU.
2. Creați o conductă Kubeflow – Rulați caietul STEP1.0_create_pipeline_k8s_sagemaker.ipynb pentru a crea o conductă care rulează și implementează modele pe SageMaker. Asigurați-vă că instalați biblioteca SageMaker ca parte a primei celule de blocnotes și reporniți nucleul înainte de a rula restul celulelor de blocnotes.
3. Invocați un punct final SageMaker – Rulați caietul STEP1.1_invoke_sagemaker_endpoint.ipynb pentru a invoca și a testa punctul final de inferență al modelului SageMaker creat în blocnotesul anterior.

În secțiunile următoare, vom discuta în detaliu fiecare dintre acești pași.

Rulați scriptul de antrenament PyTorch DDP

Ca parte a instruirii distribuite, antrenăm un model de clasificare creat de o rețea neuronală convoluțională simplă care funcționează pe setul de date CIFAR10. Scenariul antrenamentului cifar10-distributed-gpu-final.py conține doar biblioteci open-source și este compatibil să ruleze atât pe clusterele de antrenament Kubernetes, cât și SageMaker, fie pe dispozitive GPU, fie pe instanțele CPU. Să ne uităm la câteva aspecte importante ale scriptului de antrenament înainte de a rula exemplele noastre de notebook.

Noi folosim torch.distributed modul, care conține suport PyTorch și primitive de comunicare pentru paralelismul multi-proceselor între nodurile din 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
...

Creăm un model simplu de clasificare a imaginilor folosind o combinație de straturi convoluționale, de grupare maximă și liniare la care un relu funcția de activare este aplicată în trecerea înainte a antrenamentului modelului:

# 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

Dacă clusterul de antrenament are GPU, scriptul rulează antrenamentul pe dispozitive CUDA, iar variabila dispozitiv deține dispozitivul CUDA implicit:

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

Înainte de a rula instruire distribuită folosind PyTorch DistributedDataParallel pentru a rula procesarea distribuită pe mai multe noduri, trebuie să inițializați mediul distribuit prin apelare init_process_group. Aceasta este inițializată pe fiecare mașină a clusterului de antrenament.

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

Instanțiăm modelul clasificatorului și copiem modelul pe dispozitivul țintă. Dacă instruirea distribuită este activată să ruleze pe mai multe noduri, programul DistributedDataParallel clasa este utilizată ca obiect de înveliș în jurul obiectului model, ceea ce permite antrenamentul distribuit sincron pe mai multe mașini. Datele de intrare sunt împărțite pe dimensiunea lotului și o replică a modelului este plasată pe fiecare mașină și pe fiecare dispozitiv. Vezi următorul cod:

model = Net().to(device)

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

...

Creați o conductă Kubeflow

Notebook-ul folosește Kubeflow Pipelines SDK și setul furnizat de pachete Python pentru a specifica și rula conductele fluxului de lucru ML. Ca parte a acestui SDK, folosim decoratorul de pachete DSL (Domain-specific Language). dsl.pipeline, care decorează funcțiile Python pentru a returna o conductă.

Conducta Kubeflow folosește componenta SageMaker V2 pentru a trimite instruire către SageMaker folosind operatorii ACK SageMaker. Crearea modelului SageMaker și implementarea modelului utilizează componenta SageMaker V1, care sunt componente SageMaker bazate pe Boto3. Folosim o combinație a ambelor componente în acest exemplu pentru a demonstra flexibilitatea pe care o ai în alegere.

1. Încărcați componentele SageMaker utilizând următorul cod:

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

   În următorul cod, creăm conducta Kubeflow în care rulăm instruire distribuită SageMaker folosind două ml.p3.2xlarge instanțe:

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

   După ce conducta este definită, puteți compila conducta la o specificație Argo YAML folosind SDK-ul Kubeflow Pipelines. kfp.compiler pachet. Puteți rula această conductă folosind clientul Kubeflow Pipelines SDK, care apelează punctul final al serviciului Pipelines și transmite anteturile de autentificare adecvate chiar din blocnotes. Vezi următorul cod:

   # 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. Alege Run detalii link sub ultima celulă pentru a vizualiza conducta Kubeflow. Următoarea captură de ecran arată detaliile canalului nostru pentru componenta de instruire și implementare SageMaker.
3. Alegeți pasul jobului de formare și pe Activitate fila, alegeți legătura cu jurnalele CloudWatch pentru a accesa jurnalele SageMaker.
   Următoarea captură de ecran arată jurnalele CloudWatch pentru fiecare dintre cele două instanțe ml.p3.2xlarge.
4. Alegeți oricare dintre grupuri pentru a vedea jurnalele.
5. Capturați punctul final SageMaker alegând Sagemaker – Model de implementare pas și copierea endpoint_name valoarea artefactului de ieșire.

Invocați un punct final SageMaker

Caietul STEP1.1_invoke_sagemaker_endpoint.ipynb invocă punctul final de inferență SageMaker creat la pasul anterior. Asigurați-vă că actualizați numele punctului final:

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

A curăța

Pentru a curăța resursele, parcurgeți următorii pași:

1. Rulați următoarele comenzi în AWS Cloud9 pentru a șterge resursele AWS:

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

2. Ștergeți rolul IAM „sagemakerrole” folosind următoarea comandă 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. Ștergeți punctul final SageMaker utilizând următoarea comandă AWS CLI:

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

Rezumat

În această postare, am evidențiat valoarea pe care Kubeflow pe AWS 1.6.1 o oferă prin integrările native de servicii gestionate de AWS pentru a răspunde nevoii de cazuri de utilizare AI și ML la nivel de întreprindere. Puteți alege dintre mai multe opțiuni de implementare pentru a instala Kubeflow pe AWS cu diverse integrări de servicii folosind Terraform, Kustomize sau Helm. Cazul de utilizare din această postare a demonstrat o integrare Kubeflow cu SageMaker care utilizează un cluster de instruire gestionat de SageMaker pentru a rula instruire distribuită pentru un model de clasificare a imaginilor și punct final SageMaker pentru implementarea modelului.

Am pus la dispoziție și un exemplu de conductă de probă care utilizează cele mai recente componente SageMaker; puteți rula acest lucru direct din tabloul de bord Kubeflow. Această conductă necesită Date Amazon S3 și Rolul IAM de execuție SageMaker ca intrări necesare.

Pentru a începe cu Kubeflow pe AWS, consultați opțiunile de implementare integrate în AWS disponibile în Kubeflow pe AWS. Puteți urmări Depozitul AWS Labs pentru a urmări toate contribuțiile AWS la Kubeflow. Ne puteți găsi și pe Canalul Kubeflow #AWS Slack; feedback-ul dvs. acolo ne va ajuta să stabilim prioritățile următoarelor funcții care să contribuie la proiectul Kubeflow.

Despre autori

Kanwaljit Khurmi este arhitect senior de soluții la Amazon Web Services. El lucrează cu clienții AWS pentru a oferi îndrumări și asistență tehnică, ajutându-i să-și îmbunătățească valoarea soluțiilor atunci când folosesc AWS. Kanwaljit este specializată în a ajuta clienții cu aplicații containerizate și de învățare automată.

Kartik Kalamadi este inginer de dezvoltare software la Amazon AI. În prezent, concentrat pe proiecte cu sursă deschisă Kubernetes de învățare automată, cum ar fi Kubeflow și AWS SageMaker Controller pentru k8s. În timpul meu liber îmi place să joc jocuri pentru PC și să mă joc cu VR folosind motorul Unity.

Rahul Kharse este inginer de dezvoltare software la Amazon Web Services. Munca sa se concentrează pe integrarea serviciilor AWS cu platforme open source containerizate ML Ops pentru a le îmbunătăți scalabilitatea, fiabilitatea și securitatea. Pe lângă faptul că se concentrează pe solicitările clienților pentru caracteristici, lui Rahul îi place și să experimenteze cu cele mai recente dezvoltări tehnologice în domeniu.