Rakenna joustavia ja skaalautuvia hajautettuja koulutusarkkitehtuureja Kubeflown avulla AWS:ssä ja Amazon SageMakerissa

Tässä viestissä osoitamme miten Kubeflow AWS:ssä (Kubeflow:n AWS-spesifinen jakelu), jota käytetään kanssa AWS Deep Learning Containers ja Amazonin elastinen tiedostojärjestelmä (Amazon EFS) yksinkertaistaa yhteistyötä ja tarjoaa joustavuutta syvän oppimismallien koulutuksessa laajassa mittakaavassa molemmissa Amazonin elastisten kuberneettien palvelu (Amazon EKS) ja Amazon Sage Maker hyödyntäen hybridiarkkitehtuuria.

Koneoppimisen (ML) kehitys perustuu monimutkaisiin ja jatkuvasti kehittyviin avoimen lähdekoodin kehyksiin ja työkalupakkeihin sekä monimutkaisiin ja jatkuvasti kehittyviin laitteistoekosysteemeihin. Tämä on haaste, kun ML-kehitys skaalataan klusteriin. Säiliöt tarjoavat ratkaisun, koska ne voivat kapseloida koulutuskoodin lisäksi koko riippuvuuspinon laitteistokirjastoihin asti. Tämä varmistaa johdonmukaisen ja kannettavan ML-ympäristön ja helpottaa koulutusympäristön toistettavuutta koulutusklusterin jokaisessa yksittäisessä solmussa.

Kubernetes on laajalti käytetty järjestelmä näiden konttisovellusten infrastruktuurin käyttöönoton, resurssien skaalauksen ja hallinnan automatisointiin. Kubernetesia ei kuitenkaan luotu ML:ää ajatellen, joten se voi tuntua tietotutkijoille ristiriitaiselta, koska se on voimakkaasti riippuvainen YAML-määritystiedostoista. Ei ole olemassa Jupyter-kokemusta, eikä monia ML-kohtaisia ​​ominaisuuksia, kuten työnkulun hallintaa ja putkia, ja muita ominaisuuksia, joita ML-asiantuntijat odottavat, kuten hyperparametrien viritys, mallin isännöinti ja muut. Tällaisia ​​ominaisuuksia voidaan rakentaa, mutta Kubernetes ei ollut suunniteltu tekemään tätä ensisijaisena tavoitteenaan.

Avoimen lähdekoodin yhteisö huomasi ja kehitti Kubernetesin päälle kerroksen nimeltä Kubeflow. Kubeflow pyrkii tekemään päästä-päähän ML-työnkulkujen käyttöönotosta Kubernetesissa yksinkertaista, kannettavaa ja skaalautuvaa. Voit käyttää Kubeflowa luokkansa parhaiden avoimen lähdekoodin järjestelmien käyttöönottoon ML:ssä erilaisissa infrastruktuureissa.

Kubeflow ja Kubernetes tarjoavat joustavuutta ja hallintaa datatutkijaryhmille. Suuressa mittakaavassa toimivien koulutusklustereiden korkean käyttöasteen varmistaminen pienemmillä käyttökustannuksilla on kuitenkin edelleen haastavaa.

Tämä viesti osoittaa, kuinka asiakkaat, joilla on paikallisia rajoituksia tai olemassa olevia Kubernetes-investointeja, voivat vastata tähän haasteeseen käyttämällä Amazon EKS:ää ja Kubeflowa AWS:ssä ottamaan käyttöön ML-putkilinjan hajautettuun koulutukseen, joka perustuu itsehallittuun lähestymistapaan, ja käyttämällä täysin hallittua SageMakeria kustannusoptimoitu, täysin hallittu ja tuotantolaajuinen koulutusinfrastruktuuri. Tämä sisältää hajautetun hybridi-koulutusarkkitehtuurin vaiheittaisen toteutuksen, jonka avulla voit valita kahdesta lähestymistavasta ajon aikana, mikä tarjoaa maksimaalisen hallinnan ja joustavuuden tiukoilla käyttöönottotarpeilla. Näet, kuinka voit jatkaa avoimen lähdekoodin kirjastojen käyttöä syväoppimisskriptissäsi ja tehdä siitä silti yhteensopivan käytettäväksi sekä Kubernetesissa että SageMakerissa alustan agnostisella tavalla.

Miten Kubeflow AWS:ssä ja SageMakerissa auttaa?

Neuroverkkomallit, jotka on rakennettu syväoppimiskehyksillä, kuten TensorFlow, PyTorch, MXNet ja muut, tarjoavat paljon paremman tarkkuuden käyttämällä huomattavasti suurempia koulutustietojoukkoja, erityisesti tietokonenäön ja luonnollisen kielen käsittelyn käyttötapauksissa. Suurilla koulutustietojoukoilla syväoppimismallien kouluttaminen kestää kuitenkin kauemmin, mikä lopulta hidastaa markkinoille tuloa. Jos voisimme skaalata klusteria ja lyhentää mallin koulutusaikaa viikoista päiviin tai tunteihin, sillä voisi olla valtava vaikutus tuottavuuteen ja liiketoiminnan nopeuteen.

Amazon EKS auttaa järjestämään hallitun Kubernetes-ohjaustason. Amazon EKS:n avulla voit luoda suuria koulutusklustereita CPU- ja GPU-esiintymillä ja käyttää Kubeflow-työkalupakkia tarjotaksesi ML-ystävällisiä, avoimen lähdekoodin työkaluja ja operoitavaksesi ML-työnkulkuja, jotka ovat kannettavia ja skaalautuvia Kubeflow Pipelinesin avulla tiimisi tuottavuuden parantamiseksi ja lyhentää markkinoille tuloaikaa.

Tällä lähestymistavalla voi kuitenkin olla pari haastetta:

• Varmistetaan klusterin maksimaalinen käyttö datatieteiden ryhmien välillä. Sinun tulisi esimerkiksi tarjota GPU-esiintymiä pyynnöstä ja varmistaa niiden korkea käyttöaste vaativiin tuotantolaajuisiin tehtäviin, kuten syväoppimiskoulutukseen, ja käyttää CPU-esiintymiä vähemmän vaativiin tehtäviin, kuten tietojen esikäsittelyyn.
• Kubernetes-klusterin työntekijäsolmussa käyttöönotettujen raskaiden Kubeflow-infrastruktuurikomponenttien korkean käytettävyyden varmistaminen, mukaan lukien tietokanta, tallennustila ja todennus. Esimerkiksi Kubeflow-ohjaustaso luo artefakteja (kuten MySQL-ilmentymiä, pod-lokeja tai MinIO-tallennustilaa), jotka kasvavat ajan myötä ja tarvitsevat muutettavaa tallennustilaa jatkuvalla valvontatoiminnolla.
• Koulutustietojoukon, koodin ja laskentaympäristöjen jakaminen kehittäjien, koulutusklustereiden ja projektien välillä on haastavaa. Jos esimerkiksi työskentelet oman kirjastosi parissa ja näillä kirjastoilla on vahvat keskinäiset riippuvuudet, on todella vaikeaa jakaa ja ajaa samaa koodinpätkää saman tiimin datatieteilijöiden välillä. Lisäksi jokainen harjoitusajo edellyttää harjoitustietojoukon lataamista ja harjoituskuvan rakentamista uusilla koodimuutoksilla.

Kubeflow on AWS auttaa vastaamaan näihin haasteisiin ja tarjoaa yritystason puolihallitun Kubeflow-tuotteen. AWS:n Kubeflown avulla voit korvata jotkin Kubeflow-ohjaustason palvelut, kuten tietokanta, tallennus, valvonta ja käyttäjien hallinta AWS-hallituilla palveluilla, kuten Amazon Relational Database -palvelu (Amazon RDS), Amazonin yksinkertainen tallennuspalvelu (Amazon S3), Amazonin elastinen tiedostojärjestelmä (Amazon EFS), Amazon FSx, amazonin pilvikelloja Amazon Cognito.

Näiden Kubeflow-komponenttien vaihtaminen erottaa Kubeflow-ohjaustason kriittiset osat Kubernetesista ja tarjoaa turvallisen, skaalautuvan, joustavan ja kustannusoptimoidun suunnittelun. Tämä lähestymistapa vapauttaa myös tallennus- ja laskentaresursseja EKS-tietotasosta, joita voivat tarvita sovellukset, kuten hajautettu mallikoulutus tai käyttäjän muistikirjapalvelimet. AWS:n Kubeflow tarjoaa myös alkuperäisen Jupyter-kannettavien Deep Learning Container (DLC) -kuvien integroinnin, jotka on valmiiksi pakattu ja esikonfiguroitu AWS-optimoiduilla syväoppimiskehyksillä, kuten PyTorch ja TensorFlow, joiden avulla voit aloittaa harjoituskoodin kirjoittamisen heti ilman käsittelyä. riippuvuusratkaisuilla ja kehysoptimoinneilla. Lisäksi Amazon EFS -integraatio koulutusklusterien ja kehitysympäristön kanssa mahdollistaa koodin ja käsitellyn harjoitustietojoukon jakamisen, jolloin vältytään säiliökuvan rakentamisesta ja valtavien tietojoukkojen lataamisesta jokaisen koodinvaihdon jälkeen. Nämä integraatiot Kubeflow on AWS:n kanssa auttavat sinua nopeuttamaan mallin rakentamista ja harjoittelua ja mahdollistavat paremman yhteistyön helpomman tiedon ja koodin jakamisen ansiosta.

Kubeflow AWS:ssä auttaa rakentamaan erittäin saatavilla olevan ja vankan ML-alustan. Tämä alusta tarjoaa joustavuutta syväoppimismallien rakentamiseen ja kouluttamiseen ja tarjoaa pääsyn moniin avoimen lähdekoodin työkalupakkeihin, oivalluksia lokeihin ja interaktiivista virheenkorjausta kokeilua varten. Infrastruktuuriresurssien maksimaalisen käytön saavuttaminen samalla kun koulutetaan syvällisiä oppimismalleja sadoilla GPU:illa, vaatii silti paljon käyttökustannuksia. Tämä voidaan ratkaista käyttämällä SageMakeria, joka on täysin hallittu palvelu, joka on suunniteltu ja optimoitu käsittelemään tehokkaita ja kustannusoptimoituja koulutusklustereita, jotka tarjotaan vain pyydettäessä, skaalataan tarpeen mukaan ja suljetaan automaattisesti töiden valmistuttua, mikä tarjoaa lähes 100 % resurssien käyttöaste. Voit integroida SageMakerin Kubeflow Pipelinesiin käyttämällä hallittuja SageMaker-komponentteja. Tämän avulla voit käyttää ML-työnkulkuja osana Kubeflow-putkistoja, joissa voit käyttää Kubernetesia paikalliseen koulutukseen ja SageMakeria tuotelaajuiseen koulutukseen hybridiarkkitehtuurissa.

Ratkaisun yleiskatsaus

Seuraavassa arkkitehtuurissa kuvataan, kuinka käytämme Kubeflow-putkia kannettavien ja skaalautuvien päästä-päähän ML-työnkulkujen luomiseen ja ottamiseen käyttöön ehdollisesti hajautetun koulutuksen suorittamiseksi Kubernetesissa Kubeflow-koulutuksen tai SageMakerin avulla ajonaikaisen parametrin perusteella.

Kubeflow-koulutus on ryhmä Kubernetes-operaattoreita, jotka lisäävät Kubeflow:hon tuen ML-mallien hajautettuun koulutukseen käyttämällä erilaisia ​​kehyksiä, kuten TensorFlow, PyTorch ja muut. pytorch-operator on Kubernetesin Kubeflow-toteutus mukautettu resurssi (PyTorchJob) suorittaakseen hajautettuja PyTorch-koulutustöitä Kubernetesissa.

Käytämme PyTorchJob Launcher -komponenttia osana Kubeflow-putkilinjaa PyTorchin hajautetun koulutuksen suorittamiseen kokeiluvaiheen aikana, kun tarvitsemme joustavuutta ja pääsyä kaikkiin taustalla oleviin resursseihin interaktiivista virheenkorjausta ja analysointia varten.

Käytämme myös SageMaker-komponentteja Kubeflow Pipelinesille mallikoulutuksen suorittamiseen tuotantomittakaavassa. Tämän ansiosta voimme hyödyntää tehokkaita SageMaker-ominaisuuksia, kuten täysin hallittuja palveluita, hajautettuja koulutustöitä maksimaalisella GPU-käytöllä ja kustannustehokasta koulutusta Amazonin elastinen laskentapilvi (Amazon EC2).

Osana työnkulun luontiprosessia suoritat seuraavat vaiheet (edellisessä kaaviossa esitetyllä tavalla) luodaksesi tämän liukuhihnan:

1. Käytä Kubeflow-luettelotiedostoa Kubeflow-hallintapaneelin luomiseen ja Jupyter-muistikirjojen käyttämiseen Kubeflow-keskuksen hallintapaneelista.
2. Käytä Kubeflow-liukuhihna SDK:ta Kubeflow-putkilinjojen luomiseen ja kääntämiseen Python-koodilla. Pipeline-käännös muuntaa Python-funktion työnkulkuresurssiksi, joka on Argo-yhteensopiva YAML-muoto.
3. Käytä Kubeflow Pipelines SDK -asiakasta kutsuaksesi liukuhihnapalvelun päätepisteen suorittamaan liukuhihnan.
4. Liukuhihna arvioi ehdolliset ajonaikaiset muuttujat ja valitsee SageMakerin tai Kubernetesin kohdeajoympäristöksi.
5. Käytä Kubeflow PyTorch Launcher -komponenttia suorittaaksesi hajautettua koulutusta alkuperäisessä Kubernetes-ympäristössä tai käytä SageMaker-komponenttia koulutuksen lähettämiseen SageMaker-hallitulla alustalla.

Seuraavassa kuvassa näkyvät arkkitehtuuriin liittyvät Kubeflow Pipelines -komponentit, jotka antavat meille joustavuuden valita hajautetun Kubernetes- tai SageMaker-ympäristön välillä.

Käytä Case-työnkulkua

Käytämme seuraavaa vaiheittaista lähestymistapaa asentaaksemme ja suorittaaksemme hajautetun koulutuksen käyttötapauksen Amazon EKS:n ja SageMakerin avulla Kubeflowa AWS:ssä.

Edellytykset

Tätä kävelyä varten sinulla tulisi olla seuraavat edellytykset:

• An AWS-tili.
• Kone, jossa on Docker ja AWS-komentoriviliitäntä (AWS CLI) asennettuna.
• Vaihtoehtoisesti voit käyttää AWS-pilvi9, pilvipohjainen integroitu kehitysympäristö (IDE), joka mahdollistaa kaiken työn suorittamisen verkkoselaimella. Katso asennusohjeet kohdasta Asenna Cloud9 IDE. Valitse Cloud9-ympäristöstäsi plusmerkki ja avaa uusi pääte.
• Luo rooli nimi sagemakerrole. Lisää hallinnoidut käytännöt AmazonSageMakerFullAccess ja AmazonS3FullAccess antaa SageMakerille pääsyn S3-ämpäriin. Tätä roolia käyttää osana Kubeflow Pipelines -vaihetta lähetetty SageMaker-työ.
• Varmista, että tililläsi on SageMaker Training -resurssityyppirajoitus ml.p3.2xlarge nostettiin 2 käytettäviksi Palvelukiintiöiden konsoli

1. Asenna Amazon EKS ja Kubeflow AWS:ään

Voit käyttää useita erilaisia ​​lähestymistapoja Kubernetes-klusterin rakentamiseen ja Kubeflow:n käyttöönottoon. Tässä viestissä keskitymme lähestymistapaan, jonka uskomme tuovan prosessiin yksinkertaisuutta. Ensin luomme EKS-klusterin, jonka jälkeen otamme käyttöön Kubeflown AWS v1.5:ssä. Jokaisessa näistä tehtävistä käytämme vastaavaa avoimen lähdekoodin projektia, joka noudattaa periaatteita Tee Framework. Sen sijaan, että asentaisimme joukon edellytyksiä kullekin tehtävälle, rakennamme Docker-säiliöitä, joissa on kaikki tarvittavat työkalut ja jotka suorittavat tehtävät säilöistä käsin.

Käytämme tässä viestissä Do Frameworkia, joka automatisoi Kubeflow-asennuksen Amazon EFS:n lisäosana. Katso viralliset Kubeflow on AWS -käyttöönottovaihtoehdot tuotantokäyttöönottoa varten käyttöönoton.

Määritä nykyinen työhakemisto ja AWS CLI

Määritämme työhakemiston, jotta voimme viitata siihen seuraavien vaiheiden lähtökohtana:

export working_dir=$PWD

Määritämme myös AWS CLI -profiilin. Tätä varten tarvitset pääsyavaimen tunnuksen ja salaisen pääsyavaimen AWS-henkilöllisyyden ja käyttöoikeuksien hallinta (MINÄ OLEN) lähettämä tili, jolla on järjestelmänvalvojan oikeudet (liitä olemassa oleva hallinnoitu käytäntö) ja ohjelmallinen käyttöoikeus. Katso seuraava koodi:

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 Luo EKS-klusteri

Jos sinulla on jo EKS-klusteri saatavilla, voit siirtyä seuraavaan osioon. Tässä viestissä käytämme aws-do-eks -projekti luodaksemme klusterin.

1. Kloonaa projekti ensin työhakemistoosi

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

2. Rakenna ja käytä sitten aws-do-eks kontti:

   ./build.sh
   ./run.sh

   - build.sh script luo Docker-säilökuvan, jossa on kaikki tarvittavat työkalut ja komentosarjat EKS-klusterien hallintaan ja toimintaan. The run.sh komentosarja käynnistää säilön käyttämällä luotua Docker-kuvaa ja pitää sen yllä, jotta voimme käyttää sitä EKS-hallintaympäristönä. Nähdäksesi tilan aws-do-eks kontti, voit juosta ./status.sh. Jos säilö on Exited-tilassa, voit käyttää ./start.sh komentosarja, joka tuo säilön esiin tai käynnistä säilön uudelleen, voit suorittaa ./stop.sh jälkeen ./run.sh.

3. Avaa kuori käynnissä aws-do-eks kontti:
4. Tarkistaaksesi KubeFlow-asennuksen EKS-klusterin kokoonpanon, suorita seuraava komento:

   vi ./eks-kubeflow.yaml

   Oletuksena tämä kokoonpano luo klusterin nimeltä eks-kubeflow vuonna us-west-2 Alue kuudella m5.xlarge solmulla. Myöskään EBS-taltioiden salaus ei ole oletusarvoisesti käytössä. Voit ottaa sen käyttöön lisäämällä "volumeEncrypted: true" solmuryhmään ja se salaa oletusavaimella. Muokkaa muita kokoonpanoasetuksia tarvittaessa.

5. Luo klusteri suorittamalla seuraava komento:

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

   Klusterin valmisteluprosessi voi kestää jopa 30 minuuttia.

6. Varmista, että klusterin luominen onnistui, suorittamalla seuraava komento:

   kubectl get nodes

   Edellisen komennon tulos onnistuneesti luodulle klusterille näyttää seuraavalta koodilta:

   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

Luo EFS-osio SageMaker-koulutustyötä varten

Tässä käyttötapauksessa nopeutat SageMaker-harjoitustyötä kouluttamalla syväoppimismalleja Amazon EFS:ään jo tallennetuista tiedoista. Tämän valinnan etuna on se, että harjoitustyösi käynnistetään suoraan Amazon EFS:n tiedoista ilman tiedonsiirtoa, mikä nopeuttaa harjoittelun aloitusaikoja.

Luomme EFS-taltion ja otamme käyttöön EFS Container Storage Interface (CSI) -ohjaimen. Tämä suoritetaan käyttöönoton komentosarjalla, joka sijaitsee paikassa /eks/deployment/csi/efs puitteissa aws-do-eks astiaan.

Tämä komentosarja olettaa, että tililläsi on yksi EKS-klusteri. Aseta CLUSTER_NAME= jos sinulla on useampi kuin yksi EKS-klusteri.

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

Tämä komentosarja muodostaa EFS-taltion ja luo asennuskohteita klusterin VPC:n aliverkoille. Sen jälkeen se ottaa käyttöön EFS CSI -ohjaimen ja luo efs-sc varastointiluokka ja efs-pv jatkuva volyymi EKS-klusterissa.

Kun komentosarja on suoritettu onnistuneesti, sinun pitäisi nähdä seuraavanlainen tuloste:

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

Luo Amazon S3 VPC -päätepiste

Käytät yksityistä VPC:tä, johon SageMaker-koulutustyölläsi ja EFS-tiedostojärjestelmälläsi on pääsy. Voit antaa SageMaker-koulutusklusterille pääsyn yksityisen VPC:n S3-ämpäriin luomalla VPC-päätepisteen:

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

Voit nyt poistua aws-do-eks säiliön kuori ja siirry seuraavaan osaan:

exit

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

1.2 Ota Kubeflow käyttöön AWS:ssä Amazon EKS:ssä

Käytämme Kubeflow:n käyttöönottoa Amazon EKS:ssä aws-do-kubeflow-projekti.

1. Kloonaa arkisto seuraavilla komennoilla:

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

2. Määritä sitten projekti:

   ./config.sh

   Tämä komentosarja avaa projektin määritystiedoston tekstieditorissa. Se on tärkeää AWS_REGION asetetaan alueelle, jossa klusterisi on, sekä AWS_CLUSTER_NAME vastaamaan aiemmin luomasi klusterin nimeä. Oletuksena kokoonpanosi on jo asetettu oikein, joten jos sinun ei tarvitse tehdä muutoksia, sulje editori.

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

   - build.sh komentosarja luo Docker-säilökuvan, jossa on kaikki työkalut, joita tarvitaan Kubeflown käyttöönottoon ja hallintaan olemassa olevassa Kubernetes-klusterissa. The run.sh script käynnistää säilön käyttämällä Docker-kuvaa ja exec.sh-skripti avaa komentotulkin säilöön, jota voimme käyttää Kubeflow-hallintaympäristönä. Voit käyttää ./status.sh skripti nähdäksesi, onko aws-do-kubeflow kontti on käynnissä ja ./stop.sh ja ./run.sh komentosarjat käynnistääksesi sen tarvittaessa uudelleen.

3. Kun olet avannut kuoren aws-do-eks säilössä, voit varmistaa, että määritetty klusterin konteksti on odotetusti:

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

4. Ota Kubeflow käyttöön EKS-klusterissa suorittamalla deploy.sh käsikirjoitus:

   ./kubeflow-deploy.sh

   Käyttöönotto onnistuu, kun kaikki kubeflow-nimiavaruuden podit siirtyvät Running-tilaan. Tyypillinen tuloste näyttää seuraavalta koodilta:

   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. Voit seurata KubeFlow-palojen tilaa erillisessä ikkunassa käyttämällä seuraavaa komentoa:

   watch kubectl -n kubeflow get pods

6. lehdistö Ctrl + C Kun kaikki podit ovat käynnissä, paljasta Kubeflow-koontinäyttö klusterin ulkopuolelle suorittamalla seuraava komento:

   ./kubeflow-expose.sh

Sinun pitäisi nähdä tulos, joka näyttää seuraavalta koodilta:

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

Tämä komentoportti välittää Istio-sisääntuloyhdyskäytäväpalvelun klusteristasi paikalliseen porttiin 8080. Voit käyttää Kubeflow-hallintapaneelia osoitteessa http://localhost:8080 ja kirjaudu sisään oletusarvoisilla käyttäjätunnuksilla (user@example.com/12341234). Jos käytät aws-do-kubeflow kontti AWS Cloud9:ssä, voit valita preview, valitse sitten Esikatsele käynnissä olevaa sovellusta. Jos käytät Docker Desktopia, saatat joutua suorittamaan ./kubeflow-expose.sh käsikirjoitus ulkopuolella aws-do-kubeflow astiaan.

2. Määritä Kubeflow on AWS -ympäristö

Luomme EFS-taltion ja Jupyter-muistikirjan Kubeflow on AWS -ympäristön määrittämiseksi.

2.1 Luo EFS-taltio

Voit luoda EFS-taltion suorittamalla seuraavat vaiheet:

• Valitse Kubeflow-hallintapaneelista Volyymit navigointipaneelissa.
• valitsin Uusi volyymi.
• varten Nimi, tulla sisään efs-sc-claim.
• varten Äänenvoimakkuuden koko, tulla sisään 10.
• varten Varastointiluokka, valitse efs-sc.
• varten Pääsytila, valitse ReadWriteOnce.
• Valita luoda.

2.2 Luo Jupyter-muistikirja

Luo uusi muistikirja suorittamalla seuraavat vaiheet:

• Valitse Kubeflow-hallintapaneelista Kannettavat navigointipaneelissa.
• Valita Uusi muistikirja.
• varten Nimi, tulla sisään aws-hybrid-nb.
• varten Jupyter Docket -kuva, valitse kuva c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (viimeisin saatavilla oleva jupyter-pytorch DLC -kuva).
• varten prosessori, tulla sisään 1.
• varten Muisti, tulla sisään 5.
• varten GPU, jätä nimellä Ei eristetty.
• Älä tee mitään muutoksia Työtilan tilavuus osiossa.
• In Tietomäärät osiossa, valitse Liitä olemassa oleva taltio ja laajenna Olemassa oleva määrä -osio
• varten Nimi, valitse efs-sc-claim.
• varten Kiinnityspolku, tulla sisään /home/jovyan/efs-sc-claim.
  Tämä kiinnittää EFS-taltion Jupyter-muistikirjakoteloosi ja näet kansion efs-sc-claim Jupyter Lab -käyttöliittymässä. Tallennat harjoitustietojoukon ja harjoituskoodin tähän kansioon, jotta harjoitusklusterit voivat käyttää niitä ilman, että sinun tarvitsee rakentaa säilön kuvia uudelleen testausta varten.
• valita Salli pääsy Kubeflow-putkiin Konfigurointi-osiossa.
• Valita Käynnistää.
  Varmista, että muistikirjasi on luotu onnistuneesti (se voi kestää muutaman minuutin).
• On Kannettavat sivu, valitse kytkeä kirjautuaksesi JupyterLab-ympäristöön.
• On mennä valikosta, valitse Kloonaa arkisto.
• varten Kloonaa repo, tulla sisään https://github.com/aws-samples/aws-do-kubeflow.
  

3. Suorita hajautettu koulutus

Kun olet määrittänyt Jupyter-muistikirjan, voit suorittaa koko esittelyn seuraavien korkean tason vaiheiden avulla kansiosta aws-do-kubeflow/workshop kloonatussa arkistossa:

• PyTorch Distributed Data Parallel (DDP) -koulutusskripti: Katso PyTorch DDP -koulutusskripti cifar10-distributed-gpu-final.py, joka sisältää mallikonvoluutiohermoverkon ja logiikan koulutuksen jakamiseksi monisolmuisessa CPU- ja GPU-klusterissa. (Katso lisätietoja kohdasta 3.1)
• Asenna kirjastot: Suorita muistikirja 0_initialize_dependencies.ipynb alustaaksesi kaikki riippuvuudet. (Katso lisätietoja kohdasta 3.2)
• Suorita hajautettu PyTorch-työkoulutus Kubernetesissa: Suorita muistikirja 1_submit_pytorchdist_k8s.ipynb luoda ja lähettää hajautettua koulutusta yhdelle ensisijaiselle ja kahdelle työntekijäsäilölle käyttämällä Kubernetes mukautettua resurssia PyTorchJob YAML-tiedostoa käyttäen Python-koodia. (Katso lisätietoja kohdasta 3.3)
• Luo hybridi Kubeflow-putki: Suorita muistikirja 2_create_pipeline_k8s_sagemaker.ipynb luoda hybridi Kubeflow-putki, joka suorittaa hajautettua koulutusta joko SageMakerissa tai Amazon EKS:ssä ajonaikaisen muuttujan avulla training_runtime. (Katso lisätietoja kohdasta 3.4)

Varmista, että käytät muistikirjaa 1_submit_pytorchdist_k8s.ipynb ennen kuin aloitat muistikirjan 2_create_pipeline_k8s_sagemaker.ipynb.

Seuraavissa osioissa käsittelemme jokaista näistä vaiheista yksityiskohtaisesti.

3.1 PyTorch Distributed Data Parallel (DDP) -harjoitusskripti

Osana hajautettua koulutusta koulutamme luokittelumallin, jonka luo yksinkertainen konvoluutiohermoverkko, joka toimii CIFAR10-aineistolla. Harjoittelun käsikirjoitus cifar10-distributed-gpu-final.py sisältää vain avoimen lähdekoodin kirjastot ja on yhteensopiva sekä Kubernetes- että SageMaker-koulutusklustereissa joko GPU-laitteissa tai CPU-esiintymissä. Katsotaanpa muutamia tärkeitä koulutusohjelman näkökohtia ennen kuin suoritamme muistikirjaesimerkkejä.

Käytämme torch.distributed moduuli, joka sisältää PyTorch-tuen ja tietoliikenneprimitiivit usean prosessin rinnakkaisuudelle klusterin solmujen välillä:

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

Luomme yksinkertaisen kuvien luokittelumallin käyttämällä konvoluutio-, max pooling- ja lineaaristen kerrosten yhdistelmää, joihin sovelletaan relu-aktivointifunktiota mallikoulutuksen eteenpäin siirtymisessä:

# 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

Käytämme taskulamppua DataLoader, joka yhdistää tietojoukon ja DistributedSampler (lataa datan osajoukon hajautetusti käyttämällä torch.nn.parallel.DistributedDataParallel) ja tarjoaa yhden tai useamman prosessin iteraattorin tiedoille:

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

Jos koulutusklusterissa on GPU:ita, komentosarja suorittaa harjoituksen CUDA-laitteissa ja laitemuuttuja sisältää oletusarvoisen CUDA-laitteen:

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

Ennen kuin suoritat hajautetun harjoittelun PyTorchin avulla DistributedDataParallel Jos haluat suorittaa hajautetun käsittelyn useissa solmuissa, sinun on alustettava hajautettu ympäristö kutsumalla init_process_group. Tämä alustetaan jokaisessa koulutusklusterin koneessa.

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

Instantoimme luokitinmallin ja kopioimme mallin kohdelaitteeseen. Jos hajautettu koulutus on otettu käyttöön useissa solmuissa, DistributedDataParallel luokkaa käytetään wrapper-objektina malliobjektin ympärillä, mikä mahdollistaa synkronisen hajautetun koulutuksen useille koneille. Syöttötiedot jaetaan erämitan mukaan ja mallin kopio asetetaan jokaiseen koneeseen ja jokaiseen laitteeseen.

model = Net().to(device)

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

...

3.2 Asenna kirjastot

Asennat kaikki tarvittavat kirjastot PyTorchin hajautetun harjoitusesimerkin suorittamiseksi. Tämä sisältää Kubeflow Pipelines SDK:n, Training Operator Python SDK:n, Python-asiakkaan Kubernetesille ja Amazon SageMaker Python SDK:n.

#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 Suorita hajautettu PyTorch-työkoulutus Kubernetesissa

Muistikirja 1_submit_pytorchdist_k8s.ipynb luo mukautetun Kubernetes-resurssin PyTorchJob YAML-tiedoston Kubeflow-koulutuksen ja Kubernetes-asiakasohjelman Python SDK:n avulla. Seuraavassa on muutamia tärkeitä katkelmia tästä muistikirjasta.

Luomme PyTorchJob YAML:n ensisijaisella ja työntekijäsäiliöllä seuraavan koodin mukaisesti:

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

Tämä lähetetään Kubernetes-ohjaustasolle käyttämällä PyTorchJobClient:

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

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Tarkastele Kubernetes-harjoituslokeja

Voit tarkastella harjoituslokeja joko samasta Jupyter-muistikirjasta Python-koodilla tai Kubernetes-asiakaskuoresta.

3.4 Luo hybridi Kubeflow-putki

Muistikirja 2_create_pipeline_k8s_sagemaker.ipynb luo hybridi Kubeflow-putkilinjan, joka perustuu ehdolliseen ajonaikamuuttujaan training_runtime, kuten seuraavassa koodissa näkyy. Muistikirja käyttää Kubeflow Pipelines SDK ja se sisältää joukon Python-paketteja ML-työnkulkuputkien määrittämiseksi ja suorittamiseksi. Osana tätä SDK:ta käytämme seuraavia paketteja:

• Verkkotunnuskohtainen kieli (DSL) -pakettien koristelu dsl.pipeline, joka koristaa Python-funktiot palauttamaan liukuhihnan
• - dsl.Condition paketti, joka edustaa ryhmää toimintoja, jotka suoritetaan vain, kun tietty ehto täyttyy, kuten tarkistetaan training_runtime arvo as sagemaker or kubernetes

Katso seuraava koodi:

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

Konfiguroimme SageMaker-hajautetun koulutuksen käyttämällä kahta ml.p3.2xlarge-instanssia.

Kun liukuhihna on määritetty, voit kääntää putkilinjan Argo YAML -määritykseen käyttämällä Kubeflow Pipelines SDK:ta kfp.compiler paketti. Voit suorittaa tämän liukuhihnan käyttämällä Kubeflow Pipeline SDK -asiakasohjelmaa, joka kutsuu Pipelines-palvelun päätepisteen ja välittää asianmukaiset todennusotsikot suoraan muistikirjasta. Katso seuraava koodi:

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

Jos saat sagemaker import virhe, suorita !pip install sagemaker ja käynnistä ydin uudelleen ( Ydin valikosta, valitse Käynnistä ydin uudelleen).

Valitse Ajon tiedot linkki viimeisen solun alla nähdäksesi Kubeflow-putkilinjan.

Toista putkilinjan luontivaihe training_runtime='kubernetes' testata putkilinjaa Kubernetes-ympäristössä. The training_runtime muuttuja voidaan välittää myös CI/CD-liukuhihnassa tuotantoskenaariossa.

Tarkastele SageMaker-komponentin Kubeflow-putkilinjan ajolokeja

Seuraavassa kuvakaappauksessa näkyy SageMaker-komponentin putkistomme tiedot.

Valitse koulutustyön vaihe ja Lokit -välilehti, valitse CloudWatch-lokit -linkki päästäksesi SageMaker-lokeihin.

Seuraava kuvakaappaus näyttää CloudWatch-lokit kummallekin ml.p3.2xlarge-esiintymälle.

Valitse mikä tahansa ryhmä nähdäksesi lokit.

Tarkastele Kubeflow PyTorchJob Launcher -komponentin Kubeflow-putkilinjan ajolokeja

Seuraava kuvakaappaus näyttää Kubeflow-komponenttimme putkilinjan tiedot.

Suorita seuraavat komennot käyttämällä Kubectl Kubernetes-klusteriin yhdistetyssä Kubernetes-asiakaskuoressa nähdäksesi lokit (korvaa nimiavaruutesi ja pod-nimesi):

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

4.1 Puhdista

Jotta voimme puhdistaa kaikki tilille luomamme resurssit, meidän on poistettava ne käänteisessä järjestyksessä.

1. Poista Kubeflow-asennus suorittamalla ./kubeflow-remove.sh vuonna aws-do-kubeflow kontti. Ensimmäiset komennot ovat valinnaisia ​​ja niitä voidaan käyttää, jos sinulla ei vielä ole komentokuljetta aws-do-kubeflow kontti auki.

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

2. Vuodesta aws-do-eks konttikansio, poista EFS-taltio. Ensimmäinen komentosarja on valinnainen ja sitä voidaan käyttää, jos sinulla ei vielä ole komentokuljetta aws-do-eks kontti auki.

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

   Amazon EFS:n poistaminen on välttämätöntä klusteriimme luomaan VPC:hen liittyvän verkkoliittymän vapauttamiseksi. Huomaa, että EFS-taltion poistaminen tuhoaa kaikki siihen tallennetut tiedot.

3. Vuodesta aws-do-eks kontti, suorita eks-delete.sh komentosarja klusterin ja muiden siihen liittyvien resurssien poistamiseksi, mukaan lukien VPC:

   cd /eks
   ./eks-delete.sh

Yhteenveto

Tässä viestissä keskustelimme joistakin hajautetun mallikoulutuksen ja ML-työnkulkujen tyypillisistä haasteista. Annoimme yleiskatsauksen Kubeflowsta AWS-jakelussa ja jaoimme kaksi avoimen lähdekoodin projektia (aws-do-eks ja aws-do-kubeflow), jotka yksinkertaistavat infrastruktuurin käyttöönottoa ja Kubeflown käyttöönottoa siinä. Lopuksi kuvailimme ja esittelimme hybridiarkkitehtuurin, joka mahdollistaa työkuormien siirtymisen saumattomasti itsehallitun Kubernetes- ja täysin hallitun SageMaker-infrastruktuurin välillä. Suosittelemme käyttämään tätä hybridiarkkitehtuuria omiin käyttötarkoituksiin.

Voit seurata AWS Labs -arkisto seurataksesi kaikkia AWS-panoksia Kubeflowiin. Löydät meidät myös osoitteesta Kubeflow #AWS Slack Channel; antamasi palautteesi auttaa meitä priorisoimaan seuraavat Kubeflow-projektin ominaisuudet.

Erityiset kiitokset Sree Arasanagattalle (ohjelmistokehityspäällikkö AWS ML) ja Suraj Kotalle (ohjelmistokehittäjä) tuesta tämän viestin käynnistämisessä.

Tietoja kirjoittajista

Kanwaljit Khurmi on AI/ML Specialist Solutions -arkkitehti Amazon Web Servicesissä. Hän työskentelee AWS-tuotteen, suunnittelun ja asiakkaiden kanssa tarjotakseen ohjausta ja teknistä apua, joka auttaa heitä parantamaan hybridi-ML-ratkaisujen arvoa AWS:n käytössä. Kanwaljit on erikoistunut auttamaan asiakkaita kontti- ja koneoppimissovelluksissa.

Gautam Kumar on ohjelmistosuunnittelija, jolla on AWS AI Deep Learning. Hän on kehittänyt AWS Deep Learning Containers ja AWS Deep Learning AMI. Hän on intohimoinen tekoälyn työkalujen ja järjestelmien rakentamiseen. Vapaa-ajallaan hän harrastaa pyöräilyä ja kirjojen lukemista.

Alex Iankoulski on täyspinon ohjelmisto- ja infrastruktuuriarkkitehti, joka haluaa tehdä syvällistä, käytännönläheistä työtä. Hän on tällä hetkellä AWS:n itsehallitun koneoppimisen pääratkaisuarkkitehti. Roolissaan hän keskittyy auttamaan asiakkaita ML- ja AI-työkuormien konteinnissa ja organisoinnissa konttikäyttöisissä AWS-palveluissa. Hän on myös avoimen lähdekoodin kirjoittaja Tee puitteet ja Docker-kapteeni, joka rakastaa konttitekniikoiden soveltamista innovaation vauhdittamiseksi ja samalla maailman suurimpien haasteiden ratkaisemiseksi. Viimeisten 10 vuoden aikana Alex on työskennellyt ilmastonmuutoksen torjumiseksi, tekoälyn ja ML:n demokratisoimiseksi, matkustamisen turvallisuuden parantamiseksi, terveydenhuollon parantamiseksi ja energian fiksummaksi.