Ehitage paindlikud ja skaleeritavad hajutatud koolitusarhitektuurid Kubeflow abil AWS-is ja Amazon SageMakeris

Selles postituses näitame, kuidas Kubeflow AWS-is (Kubeflow AWS-spetsiifiline jaotus), mida kasutatakse koos AWS-i süvaõppekonteinerid ja Amazon elastne failisüsteem (Amazon EFS) lihtsustab koostööd ja pakub paindlikkust sügavate õppimismudelite väljaõppel mõlemal tasandil Amazoni elastse Kubernetese teenus (Amazon EKS) ja Amazon SageMaker kasutades hübriidarhitektuuri lähenemisviisi.

Masinõppe (ML) arendamine tugineb keerulistele ja pidevalt arenevatele avatud lähtekoodiga raamistikele ja tööriistakomplektidele, aga ka keerukatele ja pidevalt arenevatele riistvaraökosüsteemidele. See kujutab endast väljakutset ML-i arenduse skaleerimisel klastrisse. Konteinerid pakuvad lahendust, sest nad suudavad täielikult kapseldada mitte ainult koolituskoodi, vaid kogu sõltuvuste virna kuni riistvarateekideni. See tagab järjepideva ja kaasaskantava ML-keskkonna ning hõlbustab koolituskeskkonna reprodutseeritavust koolitusklastri igas üksikus sõlmes.

Kubernetes on laialdaselt kasutusele võetud süsteem infrastruktuuri juurutamise, ressursside skaleerimise ja nende konteinerrakenduste haldamise automatiseerimiseks. Kubernetes ei ehitatud aga ML-i silmas pidades, mistõttu võib see andmeteadlastele tunduda vastuoluline, kuna tugineb suuresti YAML-i spetsifikatsioonifailidele. Jupyteri kogemus puudub ja ML-spetsiifilisi võimalusi, nagu töövoohaldus ja torujuhtmed ning muud võimalused, mida ML-i eksperdid eeldavad, nagu hüperparameetrite häälestamine, mudelihostimine ja muud, pole palju. Selliseid võimalusi saab luua, kuid Kubernetes ei olnud selle peamise eesmärgina loodud.

Avatud lähtekoodiga kogukond märkas ja arendas Kubernetese peale kihi nimega Kubeflow. Kubeflow eesmärk on muuta Kubernetes'i täielike ML-töövoogude juurutamine lihtsaks, kaasaskantavaks ja skaleeritavaks. Saate kasutada Kubeflow'i parimate avatud lähtekoodiga süsteemide juurutamiseks ML-i jaoks erinevatesse infrastruktuuridesse.

Kubeflow ja Kubernetes pakuvad andmeteadlaste meeskondadele paindlikkust ja kontrolli. Siiski on mastaapselt töötavate koolitusklastrite kõrge kasutuse tagamine väiksemate üldkuludega endiselt keeruline.

See postitus näitab, kuidas kliendid, kellel on kohapealsed piirangud või olemasolevad Kubernetese investeeringud, saavad selle väljakutsega toime tulla, kasutades Amazon EKS-i ja Kubeflow'i AWS-is, et juurutada ML-i torujuhe hajutatud koolituse jaoks, mis põhineb isehallatud lähenemisviisil, ja kasutada täielikult hallatud SageMakerit. kulude optimeeritud, täielikult hallatud ja tootmismahus koolitusinfrastruktuur. See hõlmab hübriidse hajutatud koolitusarhitektuuri samm-sammult juurutamist, mis võimaldab teil käitusajal valida kahe lähenemisviisi vahel, pakkudes maksimaalset kontrolli ja paindlikkust koos teie juurutamise rangete vajadustega. Näete, kuidas saate jätkata avatud lähtekoodiga teekide kasutamist oma süvaõppe koolitusskriptis ja muuta see siiski ühilduvaks nii Kubernetes kui ka SageMakeriga platvormi agnostilisel viisil.

Kuidas Kubeflow AWS-is ja SageMakeris aitab?

Neuraalvõrgu mudelid, mis on ehitatud süvaõpperaamistikega, nagu TensorFlow, PyTorch, MXNet ja teised, pakuvad palju suuremat täpsust, kasutades oluliselt suuremaid koolitusandmekogumeid, eriti arvutinägemise ja loomuliku keele töötlemise kasutusjuhtudel. Kuid suurte koolitusandmekogumite korral võtab süvaõppe mudelite koolitamine kauem aega, mis lõppkokkuvõttes aeglustab turule jõudmise aega. Kui suudaksime klastrit laiendada ja mudeli koolituse aega nädalatelt päevadele või tundidele lühendada, võib sellel olla tohutu mõju tootlikkusele ja äritegevuse kiirusele.

Amazon EKS aitab varustada hallatud Kubernetese juhttasandit. Saate kasutada Amazon EKS-i CPU ja GPU eksemplaridega suuremahuliste koolitusklastrite loomiseks ning Kubeflow tööriistakomplekti abil, et pakkuda ML-sõbralikke avatud lähtekoodiga tööriistu ning rakendada ML-i töövooge, mis on kaasaskantavad ja skaleeritavad, kasutades Kubeflow Pipelinesit, et parandada oma meeskonna tootlikkust ja vähendada turule jõudmise aega.

Selle lähenemisviisiga võib aga tekkida paar väljakutset:

• Andmeteaduse meeskondade vahel klastri maksimaalse kasutamise tagamine. Näiteks peaksite pakkuma GPU eksemplare nõudmisel ja tagama selle suure kasutuse nõudlike tootmismastaabiülesannete jaoks (nt süvaõppe koolitus) ning kasutama CPU eksemplare vähem nõudlike ülesannete jaoks, nagu andmete eeltöötlus.
• Kubernetese klastri töötaja sõlmes juurutatud raskekaaluliste Kubeflow infrastruktuuri komponentide, sealhulgas andmebaasi, salvestusruumi ja autentimise kõrge kättesaadavuse tagamine. Näiteks Kubeflow juhttasand genereerib artefakte (nt MySQL-i eksemplarid, pod-logid või MinIO-mälu), mis aja jooksul kasvavad ja vajavad pideva jälgimisvõimalusega muudetavat salvestusmahtu.
• Koolitusandmestiku, koodi ja arvutuskeskkondade jagamine arendajate, koolitusklastrite ja projektide vahel on keeruline. Näiteks kui töötate oma teekide komplekti kallal ja nendel raamatukogudel on tugev vastastikune sõltuvus, on väga raske sama koodiosa jagada ja käitada sama meeskonna andmeteadlaste vahel. Samuti tuleb iga treeningjooksu jaoks alla laadida treeninguandmed ja koostada treeningpilt uute koodimuudatustega.

Kubeflow AWS-is aitab neid väljakutseid lahendada ja pakub ettevõtte tasemel poolhallatavat Kubeflow toodet. AWS-i Kubeflow abil saate asendada mõned Kubeflow juhtimistasandi teenused, nagu andmebaas, salvestus, jälgimine ja kasutajahaldus, AWS-i hallatavate teenustega, nagu Amazoni relatsioonide andmebaasiteenus (Amazon RDS), Amazoni lihtne salvestusteenus (Amazon S3), Amazon elastne failisüsteem (Amazon EFS), Amazon FSx, Amazon CloudWatchja Amazon Cognito.

Nende Kubeflow komponentide asendamine lahutab Kubeflow juhttasandi kriitilised osad Kubernetesist, pakkudes turvalise, skaleeritava, vastupidava ja kulutõhusa disaini. See lähenemisviis vabastab ka salvestus- ja arvutusressursse EKS-i andmetasandilt, mida võivad vajada sellised rakendused nagu hajutatud mudelikoolitus või kasutaja sülearvuti serverid. Kubeflow AWS-is pakub ka Jupyteri sülearvutite natiivset integreerimist Deep Learning Container (DLC) piltidega, mis on eelpakendatud ja eelkonfigureeritud AWS-i optimeeritud süvaõppe raamistikega, nagu PyTorch ja TensorFlow, mis võimaldavad teil alustada koolituskoodi kirjutamist kohe ilma asjata. sõltuvuslahenduste ja raamistiku optimeerimisega. Samuti võimaldab Amazon EFS-i integreerimine koolitusklastrite ja arenduskeskkonnaga jagada oma koodi ja töödeldud koolitusandmestikku, mis väldib konteineri kujutise loomist ja tohutute andmekogumite laadimist pärast iga koodivahetust. Need integratsioonid Kubeflow'ga AWS-is aitavad teil kiirendada mudeli koostamist ja koolituse aega ning võimaldavad paremat koostööd hõlpsama andmete ja koodide jagamisega.

Kubeflow AWS-is aitab luua väga kättesaadava ja tugeva ML-platvormi. See platvorm pakub paindlikkust süvaõppemudelite koostamiseks ja koolitamiseks ning pakub juurdepääsu paljudele avatud lähtekoodiga tööriistakomplektidele, logide ülevaate ja interaktiivse silumise katsetamiseks. Infrastruktuuri ressursside maksimaalne ärakasutamine sadadel GPU-del süvaõppemudelite koolitamise ajal hõlmab siiski palju töökulusid. Seda saab lahendada SageMakeri abil, mis on täielikult hallatav teenus, mis on loodud ja optimeeritud toimivate ja kulutõhusate koolitusklastrite haldamiseks, mida pakutakse ainult nõudmisel, skaleeritakse vastavalt vajadusele ja suletakse automaatselt, kui tööd on lõpetatud, pakkudes seega peaaegu 100 % ressursikasutus. Saate integreerida SageMakeri Kubeflow Pipelinesiga, kasutades hallatud SageMakeri komponente. See võimaldab teil kasutada ML-i töövooge Kubeflow torujuhtmete osana, kus saate kasutada Kubernetesi kohalikuks koolituseks ja SageMakerit hübriidarhitektuuri tootemahuliseks koolituseks.

Lahenduse ülevaade

Järgmine arhitektuur kirjeldab, kuidas me kasutame Kubeflow torujuhtmeid, et luua ja juurutada kaasaskantavaid ja skaleeritavaid otsast lõpuni ML-i töövooge, et Kubernetesis tinglikult käitada hajutatud koolitust, kasutades käitusaja parameetril põhinevat Kubeflow koolitust või SageMakerit.

Kubeflow koolitus on Kubernetese operaatorite rühm, mis lisab Kubeflow'le ML-mudelite hajutatud koolituse toe, kasutades erinevaid raamistikke, nagu TensorFlow, PyTorch ja teised. pytorch-operator on Kubernetese Kubeflow rakendus kohandatud ressurss (PyTorchJob), et juhtida Kubernetesis hajutatud PyTorchi koolitustöid.

Kasutame PyTorchJob Launcheri komponenti Kubeflow torujuhtme osana PyTorchi hajutatud koolituse käivitamiseks katsefaasis, kui vajame interaktiivseks silumiseks ja analüüsiks paindlikkust ja juurdepääsu kõikidele alusressurssidele.

Samuti kasutame Kubeflow Pipelinesi jaoks SageMakeri komponente, et korraldada oma mudelikoolitust tootmismastaabis. See võimaldab meil kasutada võimsaid SageMakeri funktsioone, nagu täielikult hallatavad teenused, hajutatud koolitustööd maksimaalse GPU-kasutusega ja kuluefektiivne koolitus läbi Amazon Elastic Compute Cloud (Amazon EC2) Punktjuhtumid.

Töövoo loomise protsessi osana teete selle konveieri loomiseks järgmised sammud (nagu on näidatud eelmisel diagrammil).

1. Kasutage Kubeflow manifesti faili, et luua Kubeflow armatuurlaud ja pääseda juurde Jupyteri sülearvutitele Kubeflow keskselt armatuurlaualt.
2. Kasutage Pythoni koodi abil Kubeflow torujuhtmete loomiseks ja kompileerimiseks Kubeflow konveieri SDK-d. Pipeline'i kompileerimine teisendab Pythoni funktsiooni töövoo ressursiks, mis on Argoga ühilduv YAML-vorming.
3. Kasutage Kubeflow Pipelines SDK klienti, et kutsuda konveierteenuse lõpp-punkti konveieri käitamiseks.
4. Konveier hindab tingimuslikke käitusaja muutujaid ja otsustab, kas sihtkäivituskeskkonnaks on SageMaker või Kubernetes.
5. Kasutage Kubeflow PyTorch Launcheri komponenti, et korraldada hajutatud koolitust Kubernetese algkeskkonnas või kasutada SageMakeri komponenti koolituse esitamiseks SageMakeri hallatud platvormil.

Järgmisel joonisel on kujutatud arhitektuuriga seotud Kubeflow Pipelinesi komponendid, mis annavad meile paindlikkuse valida Kubernetese või SageMakeri hajutatud keskkondade vahel.

Kasutage juhtumi töövoogu

Kasutame Amazon EKS-i ja SageMakeri kaudu AWS-is Kubeflow'i kasutades hajutatud koolituse installimiseks ja käitamiseks järgmist samm-sammult lähenemist.

Eeldused

Selle ülevaate jaoks peaksid teil olema järgmised eeltingimused.

• An AWS-i konto.
• Masin koos Dockeri ja AWS-i käsurea liides (AWS CLI) installitud.
• Valikuliselt saate kasutada AWSi pilv, pilvepõhine integreeritud arenduskeskkond (IDE), mis võimaldab teha kogu töö teie veebibrauserist. Seadistusjuhiste saamiseks vaadake Seadistage Cloud9 IDE. Valige oma Cloud9 keskkonnast plussmärk ja avage uus terminal.
• Loo roll koos nimega sagemakerrole. Lisage hallatud eeskirjad AmazonSageMakerFullAccess ja AmazonS3FullAccess et anda SageMakerile juurdepääs S3 ämbritele. Seda rolli kasutab Kubeflow Pipelinesi sammu osana esitatud SageMakeri töö.
• Veenduge, et teie kontol on SageMaker Trainingi ressursitüübi limiit ml.p3.2xlarge suurendati 2-ni kasutades Teenuskvootide konsool

1. Installige AWS-i Amazon EKS ja Kubeflow

Kubernetese klastri koostamiseks ja Kubeflow juurutamiseks saate kasutada mitut erinevat lähenemisviisi. Selles postituses keskendume lähenemisviisile, mis meie arvates muudab protsessi lihtsamaks. Esiteks loome EKS-i klastri, seejärel juurutame sellele Kubeflow versioonis AWS v1.5. Kõigi nende ülesannete jaoks kasutame vastavat avatud lähtekoodiga projekti, mis järgib selle põhimõtteid Tehke raamistik. Selle asemel, et installida iga ülesande jaoks eeltingimuste komplekti, ehitame Dockeri konteinerid, millel on kõik vajalikud tööriistad ja mis täidame ülesandeid konteinerite seest.

Selles postituses kasutame Do Frameworki, mis automatiseerib Kubeflow juurutamise Amazon EFS-iga lisandmoodulina. Tootmisjuurutuste ametlike Kubeflow on AWS juurutusvõimaluste kohta vt Deployment.

Seadistage praegune töökataloog ja AWS-i CLI

Konfigureerime töökataloogi, et saaksime sellele viidata järgmiste sammude lähtepunktina:

export working_dir=$PWD

Samuti konfigureerime AWS CLI profiili. Selleks vajate pääsuvõtme ID-d ja salajast juurdepääsuvõtit AWS-i identiteedi- ja juurdepääsuhaldus (AMI) kasutaja konto administraatoriõigustega (lisage olemasolev hallatud poliitika) ja programmiline juurdepääs. Vaadake järgmist 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 EKS-i klastri loomine

Kui teil on juba EKS-klaster saadaval, võite liikuda järgmise jaotise juurde. Selle postituse jaoks kasutame aws-do-eks projekt meie klastri loomiseks.

1. Esmalt kloonige projekt oma töökataloogi

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

2. Seejärel ehitage ja käivitage aws-do-eks konteiner:

   ./build.sh
   ./run.sh

   . build.sh skript loob Dockeri konteineri kujutise, millel on kõik vajalikud tööriistad ja skriptid EKS-i klastrite loomiseks ja kasutamiseks. The run.sh skript käivitab loodud Dockeri kujutist kasutades konteineri ja hoiab seda üleval, et saaksime seda kasutada oma EKS-i halduskeskkonnana. Oma oleku vaatamiseks aws-do-eks konteiner, võite joosta ./status.sh. Kui konteiner on olekus Väljunud, saate kasutada ./start.sh skripti konteineri kuvamiseks või konteineri taaskäivitamiseks võite käivitada ./stop.sh järgnevad ./run.sh.

3. Avage jooksev kest aws-do-eks konteiner:
4. Meie KubeFlow juurutamise EKS-i klastri konfiguratsiooni ülevaatamiseks käivitage järgmine käsk:

   vi ./eks-kubeflow.yaml

   Vaikimisi loob see konfiguratsioon klastri nimega eks-kubeflow aasta us-west-2 Kuue m5.xsuure sõlmega piirkond. Samuti ei ole EBS-i köidete krüptimine vaikimisi lubatud. Saate selle lubada lisades "volumeEncrypted: true" sõlmerühma ja see krüpteerib vaikevõtmega. Vajadusel muutke teisi konfiguratsiooni sätteid.

5. Klastri loomiseks käivitage järgmine käsk:

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

   Klastri ettevalmistamise protsess võib kesta kuni 30 minutit.

6. Klastri eduka loomise kontrollimiseks käivitage järgmine käsk:

   kubectl get nodes

   Eelmise käsu väljund edukalt loodud klastri jaoks näeb välja järgmine kood:

   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

Looge SageMakeri koolitustöö jaoks EFS-köide

Sellisel juhul kiirendate SageMakeri koolitustööd, koolitades sügavaid õppimismudeleid Amazon EFS-is juba salvestatud andmete põhjal. Selle valiku eeliseks on see, et teie koolitustööd käivitatakse otse Amazon EFS-i andmetest ilma andmete liigutamist vajamata, mille tulemuseks on kiirem treeningu algusaeg.

Loome EFS-i köite ja juurutame EFS-i konteineri salvestusliidese (CSI) draiveri. See saavutatakse juurutusskriptiga, mis asub asukohas /eks/deployment/csi/efs jooksul aws-do-eks konteiner.

See skript eeldab, et teie kontol on üks EKS-klaster. Määra CLUSTER_NAME= kui teil on rohkem kui üks EKS-klaster.

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

See skript loob EFS-i köite ja loob klastri VPC alamvõrkude ühendamise sihtmärgid. Seejärel juurutab see EFS CSI draiveri ja loob efs-sc ladustamisklass ja efs-pv püsiv maht EKS-klastris.

Pärast skripti edukat lõpetamist peaksite nägema järgmist väljundit:

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

Looge Amazon S3 VPC lõpp-punkt

Kasutate privaatset VPC-d, millele teie SageMakeri koolitustööl ja EFS-failisüsteemil on juurdepääs. Et anda SageMakeri koolitusklastrile juurdepääs oma privaatsest VPC-st S3 ämbritele, loote VPC lõpp-punkti:

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

Nüüd saate väljuda aws-do-eks konteineri kest ja jätkake järgmise jaotisega:

exit

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

1.2 Kubeflow juurutamine Amazon EKS-is AWS-is

Kubeflow juurutamiseks Amazon EKS-is kasutame aws-do-kubeflow projekt.

1. Kloonige hoidla järgmiste käskude abil:

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

2. Seejärel konfigureerige projekt:

   ./config.sh

   See skript avab tekstiredaktoris projekti konfiguratsioonifaili. See on oluline AWS_REGION määrata piirkonnale, kus teie klaster asub, samuti AWS_CLUSTER_NAME et see vastaks varem loodud klastri nimele. Vaikimisi on teie konfiguratsioon juba õigesti seadistatud, nii et kui te ei pea muudatusi tegema, sulgege redaktor.

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

   . build.sh skript loob Dockeri konteineri kujutise, millel on kõik tööriistad, mis on vajalikud Kubeflow juurutamiseks ja haldamiseks olemasolevas Kubernetese klastris. The run.sh skript käivitab konteineri, kasutades Dockeri kujutist, ja skript exec.sh avab konteinerisse käsukesta, mida saame kasutada oma Kubeflow halduskeskkonnana. Võite kasutada ./status.sh skript, et näha, kas aws-do-kubeflow konteiner on töökorras ja ./stop.sh ja ./run.sh skripte, et see vastavalt vajadusele taaskäivitada.

3. Kui olete kesta avanud aws-do-eks konteiner, saate kontrollida, kas konfigureeritud klastri kontekst on ootuspärane:

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

4. Kubeflow juurutamiseks EKS-klastris käivitage deploy.sh skript:

   ./kubeflow-deploy.sh

   Juurutamine on edukas, kui kõik kubeflow nimeruumis olevad kaustad lähevad olekusse Töötab. Tüüpiline väljund näeb välja järgmine kood:

   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. KubeFlow kaustade oleku jälgimiseks saate eraldi aknas kasutada järgmist käsku:

   watch kubectl -n kubeflow get pods

6. press Ctrl + C kui kõik kaustad töötavad, avage Kubeflow armatuurlaud väljaspool klastrit, käivitades järgmise käsu:

   ./kubeflow-expose.sh

Peaksite nägema väljundit, mis näeb välja nagu järgmine kood:

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

See käsuport suunab Istio sissepääsu lüüsi teenuse teie klastrist teie kohalikku porti 8080. Kubeflow armatuurlauale pääsemiseks külastage http://localhost:8080 ja logige sisse, kasutades vaikimisi kasutaja mandaate (kasutaja@example.com/12341234). Kui juhite aws-do-kubeflow konteineris AWS Cloud9, siis saate valida Eelvaade, siis vali Töötava rakenduse eelvaade. Kui kasutate Docker Desktopi, peate võib-olla käivitama selle ./kubeflow-expose.sh skript väljaspool aws-do-kubeflow konteiner.

2. Seadistage AWS-i keskkonnas Kubeflow

Kubeflow seadistamiseks AWS-i keskkonnas loome EFS-köite ja Jupyteri märkmiku.

2.1 Looge EFS-köide

EFS-köite loomiseks toimige järgmiselt.

• Valige Kubeflow armatuurlaual Mahud navigeerimispaanil.
• Valis Uus köide.
• eest Nimi, sisenema efs-sc-claim.
• eest Helitugevuse suurus, sisenema 10.
• eest Ladustamisklass, vali efs-sc.
• eest Juurdepääsurežiim, vali ReadWriteOnce.
• Vali Looma.

2.2 Jupyteri märkmiku loomine

Uue märkmiku loomiseks toimige järgmiselt.

• Valige Kubeflow armatuurlaual Sülearvutid navigeerimispaanil.
• Vali Uus märkmik.
• eest Nimi, sisenema aws-hybrid-nb.
• eest Jupyter Docketi pilt, valige pilt c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (uusim saadaolev jupyter-pytorchi DLC-pilt).
• eest Protsessor, sisenema 1.
• eest Mälu, sisenema 5.
• eest GPU, jäta nagu mitte ükski.
• Ärge tehke muudatusi Tööruumi maht sektsiooni.
• aasta Andmemahud Valige jaotises Kinnitage olemasolev köide ja laiendage Olemasoleva helitugevuse jaotist
• eest Nimi, vali efs-sc-claim.
• eest Kinnitusrada, sisenema /home/jovyan/efs-sc-claim.
  See ühendab EFS-i köite teie Jupyteri sülearvuti hoidikusse ja näete kausta efs-sc-claim oma Jupyteri labori liideses. Salvestate treeningu andmestiku ja treeningkoodi sellesse kausta, et koolitusklastrid pääseksid sellele juurde, ilma et oleks vaja konteineri kujutisi testimiseks uuesti ehitada.
• valima Lubage juurdepääs Kubeflow torujuhtmetele jaotises Konfiguratsioon.
• Vali Algatama.
  Veenduge, et teie märkmik on edukalt loodud (see võib võtta paar minutit).
• Kohta Sülearvutid lehel, valige Võta meiega ühendust JupyterLabi keskkonda sisse logimiseks.
• Kohta Git menüüst valige Kloonige hoidla.
• eest Kloonige repo, sisenema https://github.com/aws-samples/aws-do-kubeflow.
  

3. Käivitage hajutatud treening

Pärast Jupyteri sülearvuti seadistamist saate käivitada kogu demo, kasutades kaustast järgmisi kõrgetasemelisi samme aws-do-kubeflow/workshop kloonitud hoidlas:

• PyTorchi hajutatud andmete paralleelse (DDP) koolitusskript: Vaadake PyTorchi DDP koolitusskripti cifar10-distributed-gpu-final.py, mis sisaldab näidiskonvolutsioonilist närvivõrku ja loogikat koolituse levitamiseks mitme sõlmega protsessori ja graafikaprotsessori klastris. (Vt üksikasju 3.1)
• Installige teegid: Käivitage märkmik 0_initialize_dependencies.ipynb kõigi sõltuvuste lähtestamiseks. (Vt üksikasju 3.2)
• Käivitage Kubernetesis hajutatud PyTorchi töökoolitus: Käivitage märkmik 1_submit_pytorchdist_k8s.ipynb luua ja esitada hajutatud koolitust ühes primaarses ja kahes töötaja konteineris, kasutades Python koodi abil kohandatud ressursi PyTorchJob YAML-faili Kubernetes. (Vt üksikasju 3.3)
• Looge hübriidne Kubeflow torujuhe: Käivitage märkmik 2_create_pipeline_k8s_sagemaker.ipynb luua hübriidne Kubeflow torujuhe, mis juhib käitusaja muutujat kasutades hajutatud koolitust kas SageMakeris või Amazon EKSis training_runtime. (Vt üksikasju 3.4)

Veenduge, et kasutasite märkmikku 1_submit_pytorchdist_k8s.ipynb enne märkmiku käivitamist 2_create_pipeline_k8s_sagemaker.ipynb.

Järgmistes osades käsitleme kõiki neid samme üksikasjalikult.

3.1 PyTorchi DDP (Distributed Data Parallel) treeningskript

Jaotatud koolituse raames koolitame klassifikatsioonimudelit, mis on loodud lihtsa konvolutsioonilise närvivõrgu abil, mis töötab CIFAR10 andmestikul. Treeningu skript cifar10-distributed-gpu-final.py sisaldab ainult avatud lähtekoodiga teeke ja ühildub nii Kubernetese kui ka SageMakeri koolitusklastrites töötamiseks kas GPU seadmetes või CPU eksemplarides. Enne märkmiku näidete käivitamist vaatame koolitusskripti mõnda olulist aspekti.

Me kasutame torch.distributed moodul, mis sisaldab PyTorchi tuge ja sideprimitiive mitme protsessi paralleelsuse tagamiseks klastri sõlmede vahel:

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

Loome lihtsa kujutise klassifitseerimismudeli, kasutades kombinatsiooni konvolutsiooni-, max pooling- ja lineaarsetest kihtidest, millele rakendatakse mudelikoolituse edasises käigus relu aktiveerimise funktsioon:

# 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

Kasutame taskulampi DataLoader, mis ühendab andmestiku ja DistributedSampler (laadib andmete alamhulga hajutatud viisil, kasutades torch.nn.parallel.DistributedDataParallel) ja pakub andmetele ühe- või mitmeprotsessilist iteraatorit:

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

Kui treeningklastril on GPU-d, käivitab skript koolituse CUDA-seadmetes ja seadme muutuja sisaldab CUDA vaikeseadet:

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

Enne PyTorchi abil hajutatud koolituse läbiviimist DistributedDataParallel hajutatud töötlemise käivitamiseks mitmes sõlmes peate hajutatud keskkonna lähtestama helistamise teel init_process_group. See lähtestatakse igas koolitusklastri masinas.

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

Me loome klassifikaatori mudeli ja kopeerime mudeli sihtseadmesse. Kui hajutatud treening on lubatud mitmel sõlmel, siis DistributedDataParallel klassi kasutatakse ümbrisobjektina mudelobjekti ümber, mis võimaldab sünkroonset hajutatud koolitust mitme masina vahel. Sisendandmed jagatakse partii mõõtmete järgi ja mudeli koopia paigutatakse igasse masinasse ja igasse seadmesse.

model = Net().to(device)

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

...

3.2 Teekide installimine

Installite PyTorchi hajutatud koolitusnäite käitamiseks kõik vajalikud teegid. See hõlmab Kubeflow Pipelines SDK, Training Operator Python SDK, Python klient Kubernetes ja 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 Käivitage Kubernetesis hajutatud PyTorchi töökoolitus

Märkmik 1_submit_pytorchdist_k8s.ipynb loob Kubernetese kohandatud ressursi PyTorchJob YAML-faili Kubeflow koolituse ja Kubernetese kliendi Python SDK abil. Järgnevalt mõned olulised väljavõtted sellest märkmikust.

Loome PyTorchJob YAML-i esmase ja töötaja konteineriga, nagu on näidatud järgmises koodis:

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

See esitatakse Kubernetese juhttasandile kasutades PyTorchJobClient:

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

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Vaadake Kubernetese treeningloge

Treeningloge saate vaadata kas samast Jupyteri sülearvutist Pythoni koodi abil või Kubernetese kliendi kestast.

3.4 Looge hübriidne Kubeflow torujuhe

Märkmik 2_create_pipeline_k8s_sagemaker.ipynb loob hübriidse Kubeflow torujuhtme, mis põhineb tingimuslikul käitusaja muutujal training_runtime, nagu on näidatud järgmises koodis. Märkmik kasutab Kubeflow Pipelines SDK ja see pakub Pythoni pakettide komplekti ML-i töövoo torujuhtmete määramiseks ja käitamiseks. Selle SDK osana kasutame järgmisi pakette:

• Domeenipõhise keele (DSL) paketi kaunistaja dsl.pipeline, mis kaunistab Pythoni funktsioone torujuhtme tagastamiseks
• . dsl.Condition pakett, mis esindab operatsioonide rühma, mida käivitatakse ainult siis, kui teatud tingimus on täidetud, näiteks kontrollitakse training_runtime väärtus as sagemaker or kubernetes

Vaadake järgmist 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)

Konfigureerime SageMakeri hajutatud koolituse kasutades kahte ml.p3.2xlarge eksemplari.

Pärast torujuhtme defineerimist saate selle Kubeflow Pipelines SDK abil kompileerida Argo YAML-i spetsifikatsioonile kfp.compiler pakett. Saate seda konveieri käitada, kasutades Kubeflow Pipeline SDK klienti, mis kutsub Pipelines teenuse lõpp-punkti ja edastab asjakohased autentimispäised otse sülearvutist. Vaadake järgmist 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.

Kui saate a sagemaker import vea, käivitage !pip install sagemaker ja taaskäivitage kernel ( Kernel menüüst valige Taaskäivitage kernel).

Vali Käivitamise üksikasjad link viimase lahtri all, et vaadata Kubeflow torujuhet.

Korrake torujuhtme loomise etappi koos training_runtime='kubernetes' torujuhtme testimiseks Kubernetese keskkonnas. The training_runtime muutuja saab tootmisstsenaariumis edastada ka teie CI/CD konveierisse.

Vaadake komponendi SageMaker Kubeflow torujuhtme käitamise logisid

Järgmine ekraanipilt näitab meie SageMakeri komponendi torujuhtme üksikasju.

Valige koolitustöö samm ja Logid SageMakeri logidele juurdepääsuks valige link CloudWatchi logid.

Järgmisel ekraanipildil on CloudWatchi logid mõlema ml.p3.2xlarge eksemplari kohta.

Logide vaatamiseks valige mõni rühm.

Vaadake Kubeflow PyTorchJob Launcheri komponendi Kubeflow torujuhtme käitamise logisid

Järgmine ekraanipilt näitab meie Kubeflow komponendi torujuhtme üksikasju.

Käivitage järgmised käsud kasutades Kubectl Kubernetese klastriga ühendatud Kubernetese kliendi kestas, et näha logisid (asendage oma nimeruumi ja kaustade nimed):

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

4.1 Puhastage

Kõigi kontol loodud ressursside puhastamiseks peame need eemaldama vastupidises järjekorras.

1. Kustutage Kubeflow installi käivitamisega ./kubeflow-remove.sh aasta aws-do-kubeflow konteiner. Esimene käskude komplekt on valikuline ja neid saab kasutada juhuks, kui teil pole veel käsukestat aws-do-kubeflow konteiner avatud.

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

2. Alates aws-do-eks konteineri kaust, eemaldage EFS-i köide. Esimene käskude komplekt on valikuline ja seda saab kasutada juhul, kui teil pole veel käsukestat aws-do-eks konteiner avatud.

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

   Amazon EFS-i kustutamine on vajalik meie klastri jaoks loodud VPC-ga seotud võrguliidese vabastamiseks. Pange tähele, et EFS-köite kustutamine hävitab kõik sellele salvestatud andmed.

3. Alates aws-do-eks konteiner, käivitage eks-delete.sh skript klastri ja muude sellega seotud ressursside, sealhulgas VPC, kustutamiseks:

   cd /eks
   ./eks-delete.sh

kokkuvõte

Selles postituses arutasime mõningaid hajutatud mudelikoolituse ja ML-i töövoogude tüüpilisi väljakutseid. Andsime ülevaate Kubeflow'st AWS-i levitamisel ja jagasime kahte avatud lähtekoodiga projekti (aws-do-eks ja aws-do-kubeflow), mis lihtsustavad infrastruktuuri loomist ja Kubeflow juurutamist sellel. Lõpuks kirjeldasime ja demonstreerisime hübriidarhitektuuri, mis võimaldab töökoormustel sujuvalt üle minna isehallatava Kubernetese ja täielikult hallatava SageMakeri infrastruktuuri vahel. Soovitame teil kasutada seda hübriid-arhitektuuri enda jaoks.

Saate jälgida AWS Labsi hoidla et jälgida kõiki Kubeflow'i AWS-i kaastöid. Samuti leiate meid aadressilt Kubeflow #AWS Slack Channel; teie tagasiside aitab meil seada prioriteediks järgmised funktsioonid, mis aitavad Kubeflow projekti kaasa aidata.

Eriline tänu Sree Arasanagattale (tarkvaraarenduse juht AWS ML) ja Suraj Kotale (tarkvaraarendaja insener) selle postituse käivitamise toetamise eest.

Autoritest

Kanwaljit Khurmi on AI/ML spetsialistilahenduste arhitekt ettevõttes Amazon Web Services. Ta teeb koostööd AWS-i toote, inseneride ja klientidega, et pakkuda juhiseid ja tehnilist abi, mis aitab neil AWS-i kasutamisel oma hübriid-ML-lahenduste väärtust tõsta. Kanwaljit on spetsialiseerunud klientide abistamisele konteiner- ja masinõpperakendustega.

Gautam Kumar on AWS AI süvaõppega tarkvarainsener. Ta on välja töötanud AWS Deep Learning Containers ja AWS Deep Learning AMI. Ta on kirglik tehisintellekti jaoks tööriistade ja süsteemide loomise vastu. Vabal ajal meeldib talle rattaga sõita ja raamatuid lugeda.

Alex Iankoulski on täielik tarkvara- ja infrastruktuuriarhitekt, kellele meeldib teha põhjalikku ja praktilist tööd. Praegu on ta AWS-i isehallatava masinõppe pealahenduste arhitekt. Oma rollis keskendub ta klientide abistamisele konteineritel töötavate AWS-teenuste ML ja AI töökoormuse konteineriseerimisel ja orkestreerimisel. Ta on ka avatud lähtekoodi autor Tehke raamistik ja Dockeri kapten, kes armastab konteinertehnoloogiate rakendamist, et kiirendada innovatsioonitempot, lahendades samal ajal maailma suurimaid väljakutseid. Viimase 10 aasta jooksul on Alex töötanud kliimamuutuste vastu võitlemise, tehisintellekti ja ML demokratiseerimise, reisimise turvalisemaks, tervishoiu paremaks ja energiatarvikuks muutmise nimel.