Creați arhitecturi de instruire distribuite flexibile și scalabile folosind Kubeflow pe AWS și Amazon SageMaker

În această postare, demonstrăm cum Kubeflow pe AWS (o distribuție specifică AWS a lui Kubeflow) folosită cu Containere de învățare profundă AWS și Sistem de fișiere elastice Amazon (Amazon EFS) simplifică colaborarea și oferă flexibilitate în formarea modelelor de învățare profundă la scară pe ambele Serviciul Amazon Elastic Kubernetes (Amazon EKS) și Amazon SageMaker folosind o abordare a arhitecturii hibride.

Dezvoltarea învățării automate (ML) se bazează pe cadre și seturi de instrumente open-source complexe și în continuă evoluție, precum și pe ecosisteme hardware complexe și în continuă evoluție. Acest lucru reprezintă o provocare atunci când extindeți dezvoltarea ML la un cluster. Containerele oferă o soluție, deoarece pot încapsula pe deplin nu doar codul de antrenament, ci și întreaga dependență până la bibliotecile hardware. Acest lucru asigură un mediu ML care este consistent și portabil și facilitează reproductibilitatea mediului de antrenament pe fiecare nod individual al clusterului de antrenament.

Kubernetes este un sistem adoptat pe scară largă pentru automatizarea implementării infrastructurii, scalarea resurselor și gestionarea acestor aplicații containerizate. Cu toate acestea, Kubernetes nu a fost creat având în vedere ML, așa că poate părea contraintuitiv pentru oamenii de știință din date, datorită dependenței sale puternice de fișierele de specificații YAML. Nu există o experiență Jupyter și nu există multe capacități specifice ML, cum ar fi gestionarea fluxului de lucru și pipeline și alte capabilități la care se așteaptă experții ML, cum ar fi reglarea hiperparametrilor, găzduirea modelului și altele. Astfel de capabilități pot fi construite, dar Kubernetes nu a fost conceput pentru a face acest lucru ca obiectiv principal.

Comunitatea open-source a remarcat și a dezvoltat un strat deasupra Kubernetes numit Kubeflow. Kubeflow își propune să facă implementarea fluxurilor de lucru ML end-to-end pe Kubernetes simplă, portabilă și scalabilă. Puteți folosi Kubeflow pentru a implementa cele mai bune sisteme open-source pentru ML în diverse infrastructuri.

Kubeflow și Kubernetes oferă flexibilitate și control echipelor de date. Cu toate acestea, asigurarea unei utilizări ridicate a clusterelor de formare care rulează la scară cu cheltuieli operaționale reduse este încă o provocare.

Această postare demonstrează modul în care clienții care au restricții locale sau investiții Kubernetes existente pot aborda această provocare utilizând Amazon EKS și Kubeflow pe AWS pentru a implementa o conductă ML pentru instruire distribuită bazată pe o abordare autogestionată și pentru a utiliza SageMaker complet gestionat pentru un infrastructură de instruire optimizată din punct de vedere al costurilor, gestionată complet și la scară de producție. Aceasta include implementarea pas cu pas a unei arhitecturi de instruire distribuite hibride care vă permite să alegeți între cele două abordări în timpul execuției, conferind control maxim și flexibilitate cu nevoi stricte pentru implementările dvs. Veți vedea cum puteți continua să utilizați biblioteci open-source în scriptul dvs. de antrenament de deep learning și să îl faceți în continuare compatibil să ruleze atât pe Kubernetes, cât și pe SageMaker într-un mod independent de platformă.

Cum ajută Kubeflow pe AWS și SageMaker?

Modelele de rețele neuronale construite cu cadre de învățare profundă, cum ar fi TensorFlow, PyTorch, MXNet și altele, oferă o precizie mult mai mare prin utilizarea unor seturi de date de antrenament semnificativ mai mari, în special în cazurile de utilizare a viziunii computerizate și a procesării limbajului natural. Cu toate acestea, cu seturi mari de date de instruire, este nevoie de mai mult pentru a antrena modelele de învățare profundă, ceea ce în cele din urmă încetinește timpul de lansare pe piață. Dacă am putea extinde un cluster și am reduce timpul de pregătire a modelului de la săptămâni la zile sau ore, ar putea avea un impact enorm asupra productivității și vitezei afacerii.

Amazon EKS ajută la furnizarea planului de control Kubernetes gestionat. Puteți folosi Amazon EKS pentru a crea clustere de antrenament la scară largă cu instanțele CPU și GPU și puteți utiliza setul de instrumente Kubeflow pentru a oferi instrumente open-source prietenoase cu ML și pentru a opera fluxuri de lucru ML care sunt portabile și scalabile folosind Kubeflow Pipelines pentru a îmbunătăți productivitatea echipei dvs. reduce timpul de intrare pe piață.

Cu toate acestea, ar putea exista câteva provocări cu această abordare:

• Asigurarea utilizării maxime a unui cluster între echipele de știință a datelor. De exemplu, ar trebui să furnizați instanțe GPU la cerere și să asigurați utilizarea lor ridicată pentru sarcini solicitante la scară de producție, cum ar fi antrenamentul de deep learning, și să utilizați instanțele CPU pentru sarcinile mai puțin solicitante, cum ar fi preprocesarea datelor
• Asigurarea disponibilității ridicate a componentelor de infrastructură Kubeflow cu greutate mare, inclusiv baza de date, stocarea și autentificarea, care sunt implementate în nodul de lucru al clusterului Kubernetes. De exemplu, planul de control Kubeflow generează artefacte (cum ar fi instanțe MySQL, jurnalele pod sau stocarea MinIO) care cresc în timp și au nevoie de volume de stocare redimensionabile cu capabilități de monitorizare continuă.
• Partajarea setului de date de antrenament, a codului și a mediilor de calcul între dezvoltatori, grupuri de antrenament și proiecte este o provocare. De exemplu, dacă lucrați la propriul set de biblioteci și acele biblioteci au interdependențe puternice, devine foarte greu să partajați și să rulați aceeași bucată de cod între oamenii de știință ai datelor din aceeași echipă. De asemenea, fiecare cursă de antrenament necesită să descărcați setul de date de antrenament și să construiți imaginea de antrenament cu noile modificări de cod.

Kubeflow pe AWS ajută la abordarea acestor provocări și oferă un produs Kubeflow semi-gestionat de nivel enterprise. Cu Kubeflow pe AWS, puteți înlocui unele servicii din planul de control Kubeflow, cum ar fi bazele de date, stocarea, monitorizarea și gestionarea utilizatorilor cu servicii gestionate AWS, cum ar fi Serviciul de baze de date relaționale Amazon (Amazon RDS), Serviciul Amazon de stocare simplă (Amazon S3), Sistem de fișiere elastice Amazon (Amazon EFS), Amazon FSx, Amazon CloudWatch, și Amazon Cognito.

Înlocuirea acestor componente Kubeflow decuplează 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. Această abordare eliberează, de asemenea, resursele de stocare și de calcul din planul de date EKS, care pot fi necesare aplicațiilor, cum ar fi instruirea modelelor distribuite sau serverele de notebook ale utilizatorilor. Kubeflow pe AWS oferă, de asemenea, integrarea nativă a notebook-urilor Jupyter cu imagini Deep Learning Container (DLC), care sunt pre-ambalate și preconfigurate cu cadre de deep learning optimizate AWS, cum ar fi PyTorch și TensorFlow, care vă permit să începeți să scrieți codul de antrenament imediat, fără a avea de-a face. cu rezoluții de dependență și optimizări ale cadrului. De asemenea, integrarea Amazon EFS cu clusterele de antrenament și mediul de dezvoltare vă permite să vă partajați codul și setul de date de antrenament procesat, ceea ce evită construirea imaginii containerului și încărcarea seturi de date uriașe după fiecare modificare a codului. Aceste integrări cu Kubeflow pe AWS vă ajută să accelerați construirea modelului și timpul de instruire și să permită o colaborare mai bună cu partajarea mai ușoară a datelor și a codului.

Kubeflow pe AWS ajută la construirea unei platforme ML foarte disponibile și robustă. Această platformă oferă flexibilitate pentru a construi și antrena modele de învățare profundă și oferă acces la multe seturi de instrumente open-source, informații despre jurnale și depanare interactivă pentru experimentare. Cu toate acestea, atingerea utilizării maxime a resurselor de infrastructură în timp ce antrenați modele de deep learning pe sute de GPU-uri implică încă o mulțime de cheltuieli operaționale. Acest lucru ar putea fi rezolvat prin utilizarea SageMaker, care este un serviciu complet gestionat, conceput și optimizat pentru a gestiona clustere de instruire performante și optimizate din punct de vedere al costurilor, care sunt furnizate numai atunci când sunt solicitate, scalate după cum este necesar și oprite automat la finalizarea lucrărilor, oferind astfel aproape 100. % utilizarea resurselor. Puteți integra SageMaker cu Kubeflow Pipelines folosind componente gestionate SageMaker. Acest lucru vă permite să operaționalizați fluxurile de lucru ML ca parte a conductelor Kubeflow, unde puteți utiliza Kubernetes pentru instruire locală și SageMaker pentru instruire la scară de produs într-o arhitectură hibridă.

Prezentare generală a soluțiilor

Următoarea arhitectură descrie modul în care folosim Kubeflow Pipelines pentru a construi și a implementa fluxuri de lucru ML portabile și scalabile de la capăt la capăt pentru a rula în mod condiționat instruirea distribuită pe Kubernetes folosind antrenament Kubeflow sau SageMaker pe baza parametrului de rulare.

Antrenamentul Kubeflow este un grup de operatori Kubernetes care adaugă la Kubeflow suportul pentru instruirea distribuită a modelelor ML folosind diferite cadre precum TensorFlow, PyTorch și altele. pytorch-operator este implementarea Kubeflow a Kubernetes resursă personalizată (PyTorchJob) pentru a rula joburi de instruire PyTorch distribuite pe Kubernetes.

Folosim componenta PyTorchJob Launcher ca parte a conductei Kubeflow pentru a rula instruirea distribuită PyTorch în timpul fazei de experimentare, când avem nevoie de flexibilitate și acces la toate resursele de bază pentru depanare și analiză interactivă.

De asemenea, folosim componente SageMaker pentru Kubeflow Pipelines pentru a ne desfășura formarea modelului la scară de producție. Acest lucru ne permite să profităm de funcțiile puternice SageMaker, cum ar fi servicii complet gestionate, joburi de instruire distribuite cu utilizare maximă a GPU-ului și instruire rentabilă prin Cloud Elastic de calcul Amazon (Amazon EC2) Instanțe spot.

Ca parte a procesului de creare a fluxului de lucru, parcurgeți următorii pași (așa cum se arată în diagrama precedentă) pentru a crea această conductă:

1. Utilizați fișierul manifest Kubeflow pentru a crea un tablou de bord Kubeflow și pentru a accesa blocnotesurile Jupyter din tabloul de bord central Kubeflow.
2. Utilizați SDK-ul Kubeflow pipeline pentru a crea și compila conducte Kubeflow folosind codul Python. Compilarea pipeline convertește funcția Python într-o resursă de flux de lucru, care este un format YAML compatibil cu Argo.
3. Utilizați clientul SDK Kubeflow Pipelines pentru a apela punctul final al serviciului pipeline pentru a rula pipeline.
4. Conducta evaluează variabilele condiționale de rulare și decide între SageMaker sau Kubernetes ca mediu de rulare țintă.
5. Utilizați componenta Kubeflow PyTorch Launcher pentru a rula instruire distribuită în mediul nativ Kubernetes sau utilizați componenta SageMaker pentru a trimite instruirea pe platforma gestionată SageMaker.

Următoarea figură prezintă componentele Kubeflow Pipelines implicate în arhitectură care ne oferă flexibilitatea de a alege între mediile distribuite Kubernetes sau SageMaker.

Folosește fluxul de lucru pentru caz

Folosim următoarea abordare pas cu pas pentru a instala și rula cazul de utilizare pentru instruirea distribuită folosind Amazon EKS și SageMaker folosind Kubeflow pe AWS.

Cerințe preliminare

Pentru această prezentare generală, ar trebui să aveți următoarele condiții prealabile:

• An Cont AWS.
• O mașină cu Docker și Interfața liniei de comandă AWS (AWS CLI) instalat.
• 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. Din mediul dvs. Cloud9, alegeți semnul plus și deschideți un nou terminal.
• Creați un rol cu denumirea sagemakerrole. Adăugați politici gestionate AmazonSageMakerFullAccess și AmazonS3FullAccess pentru a oferi SageMaker acces la compartimentele S3. Acest rol este utilizat de jobul SageMaker trimis ca parte a pasului Kubeflow Pipelines.
• Asigurați-vă că contul dvs. are limită pentru tipul de resurse SageMaker Training ml.p3.2xlarge crescut la 2 folosind Consola de cote de servicii

1. Instalați Amazon EKS și Kubeflow pe AWS

Puteți folosi mai multe abordări diferite pentru a construi un cluster Kubernetes și a implementa Kubeflow. În această postare, ne concentrăm pe o abordare care credem că aduce simplitate procesului. Mai întâi, creăm un cluster EKS, apoi implementăm Kubeflow pe AWS v1.5 pe acesta. Pentru fiecare dintre aceste sarcini, folosim un proiect open-source corespunzător care urmează principiile Faceți Cadrul. În loc să instalăm un set de cerințe preliminare pentru fiecare sarcină, construim containere Docker care au toate instrumentele necesare și executăm sarcinile din interiorul containerelor.

Folosim Do Framework în această postare, care automatizează implementarea Kubeflow cu Amazon EFS ca supliment. Pentru opțiunile oficiale de implementare Kubeflow on AWS pentru implementările de producție, consultați Implementare.

Configurați directorul de lucru curent și AWS CLI

Configuram un director de lucru astfel încât să ne putem referi la el ca punct de plecare pentru pașii care urmează:

export working_dir=$PWD

Configuram, de asemenea, un 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

1.1 Creați un cluster EKS

Dacă aveți deja un cluster EKS disponibil, puteți sări la secțiunea următoare. Pentru această postare, folosim proiectul aws-do-eks pentru a ne crea clusterul.

1. Mai întâi clonează proiectul în directorul tău de lucru

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-eks
   cd aws-do-eks/

2. Apoi construiți și rulați aws-do-eks container:

   ./build.sh
   ./run.sh

   build.sh script-ul creează o imagine de container Docker care are toate instrumentele și scripturile necesare pentru furnizarea și funcționarea clusterelor EKS. The run.sh scriptul pornește un container folosind imaginea Docker creată și o menține, astfel încât să-l putem folosi ca mediu de management EKS. Pentru a vedea starea dvs aws-do-eks container, puteți rula ./status.sh. Dacă containerul este în starea Ieșit, puteți utiliza ./start.sh scriptul pentru a deschide containerul sau pentru a reporni containerul, puteți rula ./stop.sh urmată de ./run.sh.

3. Deschide o coajă în alergare aws-do-eks container:
4. Pentru a revizui configurația clusterului EKS pentru implementarea KubeFlow, rulați următoarea comandă:

   vi ./eks-kubeflow.yaml

   În mod implicit, această configurație creează un cluster numit eks-kubeflow în us-west-2 Regiunea cu șase noduri m5.xlarge. De asemenea, criptarea volumelor EBS nu este activată implicit. Îl puteți activa adăugând "volumeEncrypted: true" la grupul de noduri și va cripta folosind cheia implicită. Modificați alte setări de configurare dacă este necesar.

5. Pentru a crea clusterul, executați următoarea comandă:

   export AWS_PROFILE=kubeflow
   eksctl create cluster -f ./eks-kubeflow.yaml

   Procesul de furnizare a clusterului poate dura până la 30 de minute.

6. Pentru a verifica dacă clusterul a fost creat cu succes, rulați următoarea comandă:

   kubectl get nodes

   Ieșirea de la comanda anterioară pentru un cluster care a fost creat cu succes arată ca următorul cod:

   root@cdf4ecbebf62:/eks# kubectl get nodes
   NAME                                           STATUS   ROLES    AGE   VERSION
   ip-192-168-0-166.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-13-28.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-45-240.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-63-84.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-75-56.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-85-226.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326

Creați un volum EFS pentru jobul de instruire SageMaker

În acest caz de utilizare, accelerați munca de instruire SageMaker prin antrenarea modelelor de deep learning din datele deja stocate în Amazon EFS. Această alegere are avantajul lansării directe a joburilor de antrenament din datele din Amazon EFS, fără a fi necesară mișcarea datelor, rezultând timpi mai rapidi de începere a antrenamentului.

Creăm un volum EFS și implementăm driverul EFS Container Storage Interface (CSI). Acest lucru este realizat printr-un script de implementare situat în /eks/deployment/csi/efs în cadrul aws-do-eks recipient.

Acest script presupune că aveți un cluster EKS în contul dvs. A stabilit CLUSTER_NAME= în cazul în care aveți mai mult de un cluster EKS.

cd /eks/deployment/csi/efs
./deploy.sh

Acest script furnizează un volum EFS și creează ținte de montare pentru subrețelele VPC-ului cluster. Apoi implementează driverul EFS CSI și creează efs-sc clasa de depozitare şi efs-pv volum persistent în clusterul EKS.

După finalizarea cu succes a scriptului, ar trebui să vedeți rezultate ca următoarea:

Generating efs-sc.yaml ...

Applying efs-sc.yaml ...
storageclass.storage.k8s.io/efs-sc created
NAME            PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
efs-sc          efs.csi.aws.com         Delete          Immediate              false                  1s
gp2 (default)   kubernetes.io/aws-ebs   Delete          WaitForFirstConsumer   false                  36m

Generating efs-pv.yaml ...
Applying efs-pv.yaml ...
persistentvolume/efs-pv created
NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
efs-pv   5Gi        RWX            Retain           Available           efs-sc                  10s

Done ...

Creați un punct final VPC Amazon S3

Utilizați un VPC privat la care au acces jobul de antrenament SageMaker și sistemul de fișiere EFS. Pentru a oferi clusterului de antrenament SageMaker acces la compartimentele S3 din VPC-ul dvs. privat, creați un punct final VPC:

cd /eks/vpc 
export CLUSTER_NAME= 
export REGION= 
./vpc-endpoint-create.sh

Acum puteți ieși din aws-do-eks carcasa containerului și treceți la următoarea secțiune:

exit

root@cdf4ecbebf62:/eks/deployment/csi/efs# exit
exit
TeamRole:~/environment/aws-do-eks (main) $

1.2 Implementați Kubeflow pe AWS pe Amazon EKS

Pentru a implementa Kubeflow pe Amazon EKS, folosim proiectul aws-do-kubeflow.

1. Clonează depozitul utilizând următoarele comenzi:

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-kubeflow
   cd aws-do-kubeflow

2. Apoi configurați proiectul:

   ./config.sh

   Acest script deschide fișierul de configurare a proiectului într-un editor de text. Este important pentru AWS_REGION să fie setat la Regiunea în care se află clusterul dvs., precum și AWS_CLUSTER_NAME pentru a se potrivi cu numele clusterului pe care l-ați creat mai devreme. În mod implicit, configurația dvs. este deja setată corect, așa că, dacă nu trebuie să faceți nicio modificare, închideți editorul.

   ./build.sh
   ./run.sh
   ./exec.sh

   build.sh scriptul creează o imagine de container Docker care are toate instrumentele necesare pentru a implementa și gestiona Kubeflow pe un cluster Kubernetes existent. The run.sh scriptul pornește un container, folosind imaginea Docker, iar scriptul exec.sh deschide un shell de comandă în container, pe care îl putem folosi ca mediu de management Kubeflow. Puteți folosi ./status.sh script pentru a vedea dacă aws-do-kubeflow containerul este în funcțiune și ./stop.sh și ./run.sh scripturi pentru a-l reporni după cum este necesar.

3. După ce ai o carcasă deschisă în aws-do-eks container, puteți verifica dacă contextul clusterului configurat este așa cum era de așteptat:

   root@ip-172-31-43-155:/kubeflow# kubectx
   kubeflow@eks-kubeflow.us-west-2.eksctl.io

4. Pentru a implementa Kubeflow pe clusterul EKS, rulați deploy.sh scenariu:

   ./kubeflow-deploy.sh

   Implementarea are succes atunci când toate podurile din spațiul de nume kubeflow intră în starea de rulare. O ieșire tipică arată ca următorul cod:

   Waiting for all Kubeflow pods to start Running ...
   
   Waiting for all Kubeflow pods to start Running ...
   
   Restarting central dashboard ...
   pod "centraldashboard-79f489b55-vr6lp" deleted
   /kubeflow/deploy/distro/aws/kubeflow-manifests /kubeflow/deploy/distro/aws
   /kubeflow/deploy/distro/aws
   
   Kubeflow deployment succeeded
   Granting cluster access to kubeflow profile user ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   clusterrolebinding.rbac.authorization.k8s.io/kubeflow-user-example-com-cluster-admin-binding created
   Setting up access to Kubeflow Pipelines ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   
   Creating pod-default for namespace kubeflow-user-example-com ...
   poddefault.kubeflow.org/access-ml-pipeline created

5. Pentru a monitoriza starea podurilor KubeFlow, într-o fereastră separată, puteți utiliza următoarea comandă:

   watch kubectl -n kubeflow get pods

6. Anunturi Ctrl + C când toate podurile rulează, apoi expuneți tabloul de bord Kubeflow în afara clusterului, rulând următoarea comandă:

   ./kubeflow-expose.sh

Ar trebui să vedeți o ieșire care arată ca următorul cod:

root@ip-172-31-43-155:/kubeflow# ./kubeflow-expose.sh
root@ip-172-31-43-155:/kubeflow# Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Această comandă redirecționează serviciul gateway de intrare Istio de la cluster la portul local 8080. Pentru a accesa tabloul de bord Kubeflow, vizitați http://localhost:8080 și conectați-vă folosind acreditările implicite de utilizator (utilizator@exemplu.com/12341234). Dacă rulezi aws-do-kubeflow container în AWS Cloud9, atunci puteți alege Anunţ, Apoi alegeți Previzualizați aplicația care rulează. Dacă rulați pe Docker Desktop, poate fi necesar să rulați ./kubeflow-expose.sh script în afara aws-do-kubeflow recipient.

2. Configurați mediul Kubeflow pe AWS

Pentru a vă configura mediul Kubeflow pe AWS, creăm un volum EFS și un notebook Jupyter.

2.1 Creați un volum EFS

Pentru a crea un volum EFS, parcurgeți următorii pași:

• Pe tabloul de bord Kubeflow, alegeți volumele în panoul de navigare.
• Chose Volum nou.
• Pentru Nume si Prenume, introduce efs-sc-claim.
• Pentru Dimensiunea volumului, introduce 10.
• Pentru Clasa de depozitare, alege efs-sc.
• Pentru Mod de acces, alege ReadWriteOnce.
• Alege Crea.

2.2 Creați un caiet Jupyter

Pentru a crea un blocnotes nou, parcurgeți următorii pași:

• Pe tabloul de bord Kubeflow, alegeți notebook-uri în panoul de navigare.
• Alege Notebook nou.
• Pentru Nume si Prenume, introduce aws-hybrid-nb.
• Pentru Jupyter Docket Image, alege imaginea c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (cea mai recentă imagine DLC jupyter-pytorch disponibilă).
• Pentru Procesor, introduce 1.
• Pentru Memorie, introduce 5.
• Pentru unități de procesare grafică, lasa ca Nici unul.
• Nu faceți nicio modificare la Volumul spațiului de lucru secţiune.
• În Volume de date secțiune, pentru a alege Atașați volumul existent și extindeți secțiunea de volum existent
• Pentru Nume si Prenume, alege efs-sc-claim.
• Pentru Calea de montare, introduce /home/jovyan/efs-sc-claim.
  Acest lucru montează volumul EFS pe podul notebook-ului Jupyter și puteți vedea folderul efs-sc-claim în interfața de laborator Jupyter. Salvați setul de date de antrenament și codul de antrenament în acest folder, astfel încât grupurile de antrenament să le poată accesa fără a fi nevoie să reconstruiți imaginile containerului pentru testare.
• Selectați Permiteți accesul la Kubeflow Pipelines în secțiunea Configurare.
• Alege Lansa.
  Verificați dacă blocnotesul este creat cu succes (poate dura câteva minute).
• Pe notebook-uri pagina, alege Conectați pentru a vă conecta la mediul JupyterLab.
• Pe merge meniu, alegeți Clonează un depozit.
• Pentru Clonează un repo, introduce https://github.com/aws-samples/aws-do-kubeflow.
  

3. Rulați 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 aws-do-kubeflow/workshop în depozitul clonat:

• Script de antrenament PyTorch Distributed Data Parallel (DDP): Consultați scriptul de antrenament 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. (Consultați 3.1 pentru detalii)
• Instalați biblioteci: Rulați caietul 0_initialize_dependencies.ipynb pentru a inițializa toate dependențele. (Consultați 3.2 pentru detalii)
• Rulați instruire de lucru distribuită PyTorch pe Kubernetes: Rulați caietul 1_submit_pytorchdist_k8s.ipynb pentru a crea și a trimite instruire distribuită pe un container principal și două containere de lucru folosind fișierul YAML PyTorchJob cu resurse personalizate Kubernetes folosind codul Python. (Consultați 3.3 pentru detalii)
• Creați o conductă hibridă Kubeflow: Rulați caietul 2_create_pipeline_k8s_sagemaker.ipynb pentru a crea conducta hibridă Kubeflow care rulează instruire distribuită fie pe SageMaker, fie pe Amazon EKS utilizând variabila runtime training_runtime. (Consultați 3.4 pentru detalii)

Asigurați-vă că ați rulat caietul 1_submit_pytorchdist_k8s.ipynb înainte de a începe caietul 2_create_pipeline_k8s_sagemaker.ipynb.

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

3.1 Script de instruire PyTorch Distributed Data Parallel (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 cărora li se aplică o funcție de activare relu î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

Folosim lanterna DataLoader care combină setul de date și DistributedSampler (încarcă un subset de date într-o manieră distribuită folosind torch.nn.parallel.DistributedDataParallel) și oferă un iterator cu un singur proces sau cu mai multe procese peste date:

# Define data loader for training dataset
def _get_train_data_loader(batch_size, training_dir, is_distributed):
logger.info("Get train data loader")

train_set = torchvision.datasets.CIFAR10(root=training_dir,
train=True,
download=False,
transform=_get_transforms())

train_sampler = (
torch.utils.data.distributed.DistributedSampler(train_set) if is_distributed else None
)

return torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=train_sampler is None,
sampler=train_sampler)
...

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.

model = Net().to(device)

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

...

3.2 Instalați biblioteci

Veți instala toate bibliotecile necesare pentru a rula exemplul de instruire distribuită PyTorch. Aceasta include Kubeflow Pipelines SDK, Training Operator Python SDK, client Python pentru Kubernetes și Amazon SageMaker Python SDK.

#Please run the below commands to install necessary libraries

!pip install kfp==1.8.4

!pip install kubeflow-training

!pip install kubernetes

!pip install sagemaker

3.3 Desfășurați instruire distribuită pentru joburi PyTorch pe Kubernetes

Caietul 1_submit_pytorchdist_k8s.ipynb creează fișierul YAML cu resurse personalizate Kubernetes PyTorchJob utilizând antrenamentul Kubeflow și SDK-ul Python al clientului Kubernetes. Următoarele sunt câteva fragmente importante din acest caiet.

Creăm PyTorchJob YAML cu containerele primare și de lucru, așa cum se arată în următorul cod:

# Define PyTorchJob custom resource manifest
pytorchjob = V1PyTorchJob(
api_version="kubeflow.org/v1",
kind="PyTorchJob",
metadata=V1ObjectMeta(name=pytorch_distributed_jobname,namespace=user_namespace),
spec=V1PyTorchJobSpec(
run_policy=V1RunPolicy(clean_pod_policy="None"),
pytorch_replica_specs={"Master": master,
"Worker": worker}
)
)

Acesta este transmis în planul de control Kubernetes folosind PyTorchJobClient:

# Creates and Submits PyTorchJob custom resource file to Kubernetes
pytorchjob_client = PyTorchJobClient()

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Vizualizați jurnalele de antrenament Kubernetes

Puteți vizualiza jurnalele de antrenament fie din același blocnotes Jupyter folosind codul Python, fie din shell-ul clientului Kubernetes.

3.4 Creați o conductă hibridă Kubeflow

Caietul 2_create_pipeline_k8s_sagemaker.ipynb creează o conductă hibridă Kubeflow bazată pe o variabilă de rulare condiționată training_runtime, așa cum se arată în codul următor. Notebook-ul folosește Kubeflow Pipelines SDK și este furnizat un set de pachete Python pentru a specifica și rula conductele fluxului de lucru ML. Ca parte a acestui SDK, folosim următoarele pachete:

• Decoratorul de pachete pentru limbajul specific domeniului (DSL). dsl.pipeline, care decorează funcțiile Python pentru a returna o conductă
• dsl.Condition pachet, care reprezintă un grup de operațiuni care sunt executate numai atunci când este îndeplinită o anumită condiție, cum ar fi verificarea training_runtime valoare ca sagemaker or kubernetes

Consultați următorul cod:

# Define your training runtime value with either 'sagemaker' or 'kubernetes'
training_runtime='sagemaker'

# Create Hybrid Pipeline using Kubeflow PyTorch Training Operators and Amazon SageMaker Service
@dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
def pytorch_cnn_pipeline():

# Pipeline Step 1: to evaluate the condition. You can enter any logic here. For demonstration we are checking if GPU is needed for training
condition_result = check_condition_op(training_runtime)

# Pipeline Step 2: to run training on Kuberentes using PyTorch Training Operators. This will be executed if gpus are not needed
with dsl.Condition(condition_result.output == 'kubernetes', name="PyTorch_Comp"):
train_task = pytorch_job_op(
name=training_job_name,
namespace=user_namespace,
master_spec=json.dumps(master_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_master_spec.yml
worker_spec=json.dumps(worker_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_worker_spec.yml
delete_after_done=False
).after(condition_result)

# Pipeline Step 3: to run training on SageMaker using SageMaker Components for Pipeline. This will be executed if gpus are needed
with dsl.Condition(condition_result.output == 'sagemaker', name="SageMaker_Comp"):
training = sagemaker_train_op(
region=region,
image=train_image,
job_name=training_job_name,
training_input_mode=training_input_mode,
hyperparameters='{ 
"backend": "'+str(pytorch_backend)+'", 
"batch-size": "64", 
"epochs": "3", 
"lr": "'+str(learning_rate)+'", 
"model-type": "custom", 
"sagemaker_container_log_level": "20", 
"sagemaker_program": "cifar10-distributed-gpu-final.py", 
"sagemaker_region": "us-west-2", 
"sagemaker_submit_directory": "'+source_s3+'" 
}',
channels=channels,
instance_type=instance_type,
instance_count=instance_count,
volume_size=volume_size,
max_run_time=max_run_time,
model_artifact_path=f's3://{bucket_name}/jobs',
network_isolation=network_isolation,
traffic_encryption=traffic_encryption,
role=role,
vpc_subnets=subnet_id,
vpc_security_group_ids=security_group_id
).after(condition_result)

Configuram antrenamentul distribuit SageMaker folosind două instanțe ml.p3.2xlarge.

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 Pipeline 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="kubeflow")

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

Dacă primești un sagemaker import eroare, rulați !pip install sagemaker și reporniți nucleul (pe Nucleu meniu, alegeți Reporniți Kernel-ul).

Alege Run detalii link sub ultima celulă pentru a vizualiza conducta Kubeflow.

Repetați pasul de creare a conductei cu training_runtime='kubernetes' pentru a testa rularea conductei într-un mediu Kubernetes. The training_runtime variabila poate fi, de asemenea, transmisă în conducta CI/CD într-un scenariu de producție.

Vizualizați jurnalele de rulare a conductei Kubeflow pentru componenta SageMaker

Următoarea captură de ecran arată detaliile conductei noastre pentru componenta SageMaker.

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.

Alegeți oricare dintre grupuri pentru a vedea jurnalele.

Vizualizați jurnalele de rulare a conductei Kubeflow pentru componenta Kubeflow PyTorchJob Launcher

Următoarea captură de ecran arată detaliile conductei pentru componenta noastră Kubeflow.

Rulați următoarele comenzi folosind Kubectl pe shell-ul clientului Kubernetes conectat la cluster-ul Kubernetes pentru a vedea jurnalele (înlocuiți numele spațiului de nume și al podului):

kubectl get pods -n kubeflow-user-example-com
kubectl logs  -n kubeflow-user-example-com -f

4.1 Curățare

Pentru a curăța toate resursele pe care le-am creat în cont, trebuie să le eliminăm în ordine inversă.

1. Ștergeți instalarea Kubeflow rulând ./kubeflow-remove.sh în aws-do-kubeflow recipient. Primul set de comenzi este opțional și poate fi folosit în cazul în care nu aveți deja un shell de comandă în dvs aws-do-kubeflow recipientul deschis.

   cd aws-do-kubeflow
   ./status.sh
   ./start.sh
   ./exec.sh
   
   ./kubeflow-remove.sh

2. De la aws-do-eks folderul container, eliminați volumul EFS. Primul set de comenzi este opțional și poate fi folosit în cazul în care nu aveți deja un shell de comandă în dvs aws-do-eks recipientul deschis.

   cd aws-do-eks
   ./status.sh
   ./start.sh
   ./exec.sh
   
   cd /eks/deployment/csi/efs
   ./delete.sh
   ./efs-delete.sh

   Ștergerea Amazon EFS este necesară pentru a elibera interfața de rețea asociată cu VPC-ul creat pentru clusterul nostru. Rețineți că ștergerea volumului EFS distruge toate datele stocate pe acesta.

3. De la aws-do-eks container, rulați eks-delete.sh script pentru a șterge clusterul și orice alte resurse asociate acestuia, inclusiv VPC-ul:

   cd /eks
   ./eks-delete.sh

Rezumat

În această postare, am discutat câteva dintre provocările tipice ale antrenării modelelor distribuite și ale fluxurilor de lucru ML. Am oferit o prezentare generală a distribuției Kubeflow pe AWS și am partajat două proiecte open-source (aws-do-eks și aws-do-kubeflow) care simplifică furnizarea infrastructurii și implementarea Kubeflow pe aceasta. În cele din urmă, am descris și demonstrat o arhitectură hibridă care permite încărcăturilor de lucru să treacă fără probleme între rularea pe un Kubernetes autogestionat și infrastructura SageMaker gestionată complet. Vă încurajăm să utilizați această arhitectură hibridă pentru propriile cazuri de utilizare.

Puteți urma 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.

Mulțumiri speciale lui Sree Arasanagatta (Software Development Manager AWS ML) și Suraj Kota (Software Dev Engineer) pentru sprijinul acordat la lansarea acestei postări.

Despre autori

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

Gautam Kumar este inginer software cu AWS AI Deep Learning. El a dezvoltat AWS Deep Learning Containers și AWS Deep Learning AMI. Este pasionat de construirea de instrumente și sisteme pentru AI. În timpul liber, îi place să meargă cu bicicleta și să citească cărți.

Alex Iankoulski este un arhitect de software și infrastructură complet căruia îi place să facă o muncă profundă și practică. În prezent, este arhitect principal de soluții pentru învățarea automată autogestionată la AWS. În rolul său, el se concentrează pe a ajuta clienții cu containerizarea și orchestrarea sarcinilor de lucru ML și AI pe servicii AWS alimentate de containere. El este, de asemenea, autorul open source Faceți cadru și un căpitan Docker căruia îi place să aplice tehnologii de containere pentru a accelera ritmul inovației, rezolvând în același timp cele mai mari provocări ale lumii. În ultimii 10 ani, Alex a lucrat la combaterea schimbărilor climatice, la democratizarea inteligenței artificiale și a ML, făcând călătoriile mai sigure, îngrijirea sănătății mai bună și energia mai inteligentă.