Zgradite prilagodljive in razširljive porazdeljene arhitekture usposabljanja z uporabo Kubeflow na AWS in Amazon SageMaker

V tej objavi prikazujemo, kako Kubeflow na AWS (distribucija Kubeflow, specifična za AWS), ki se uporablja z AWS posode za globoko učenje in Elastični datotečni sistem Amazon (Amazon EFS) poenostavlja sodelovanje in zagotavlja prilagodljivost pri usposabljanju modelov globokega učenja v obsegu na obeh Amazonski elastični kubernetes storitev (Amazon EKS) in Amazon SageMaker z uporabo pristopa hibridne arhitekture.

Razvoj strojnega učenja (ML) temelji na zapletenih in nenehno razvijajočih se odprtokodnih okvirih in kompletih orodij ter na kompleksnih in nenehno razvijajočih se ekosistemih strojne opreme. To predstavlja izziv pri prilagajanju razvoja ML na gručo. Vsebniki ponujajo rešitev, saj lahko v celoti enkapsulirajo ne samo učno kodo, ampak celoten sklad odvisnosti do knjižnic strojne opreme. To zagotavlja okolje ML, ki je dosledno in prenosljivo, ter olajša ponovljivost okolja za usposabljanje na vsakem posameznem vozlišču gruče za usposabljanje.

Kubernetes je splošno sprejet sistem za avtomatizacijo uvajanja infrastrukture, skaliranje virov in upravljanje teh kontejnerskih aplikacij. Vendar pa Kubernetes ni bil zgrajen z mislijo na ML, zato se podatkovnim znanstvenikom lahko zdi protisloven zaradi velike odvisnosti od datotek s specifikacijami YAML. Ni izkušnje z Jupyterjem in ni veliko zmogljivosti, specifičnih za ML, kot so upravljanje delovnih tokov in cevovodi, ter druge zmogljivosti, ki jih pričakujejo strokovnjaki za ML, kot je nastavitev hiperparametrov, gostovanje modela in druge. Takšne zmogljivosti je mogoče zgraditi, vendar Kubernetes ni bil zasnovan tako, da bi bil to glavni cilj.

Odprtokodna skupnost je opazila in razvila plast na vrhu Kubernetesa, imenovano Kubeflow. Cilj Kubeflowa je narediti uvajanje delovnih tokov ML od konca do konca v Kubernetes preprosto, prenosljivo in razširljivo. Kubeflow lahko uporabite za uvajanje najboljših odprtokodnih sistemov za ML v različne infrastrukture.

Kubeflow in Kubernetes zagotavljata prilagodljivost in nadzor skupinam podatkovnih znanstvenikov. Vendar je zagotavljanje visoke izkoriščenosti izobraževalnih grozdov, ki delujejo v velikem obsegu z zmanjšanimi operativnimi režijskimi stroški, še vedno izziv.

Ta objava prikazuje, kako lahko stranke, ki imajo lokalne omejitve ali obstoječe naložbe v Kubernetes, obravnavajo ta izziv z uporabo Amazon EKS in Kubeflow na AWS za implementacijo cevovoda ML za porazdeljeno usposabljanje, ki temelji na samoupravljanem pristopu, in uporabo popolnoma upravljanega SageMakerja za stroškovno optimizirano, v celoti upravljano in proizvodno izobraževalno infrastrukturo. To vključuje postopno implementacijo hibridne porazdeljene izobraževalne arhitekture, ki vam omogoča izbiro med obema pristopoma med izvajanjem, kar zagotavlja največji nadzor in prilagodljivost s strogimi potrebami za vaše uvedbe. Videli boste, kako lahko še naprej uporabljate odprtokodne knjižnice v svojem skriptu za usposabljanje za globoko učenje in ga še vedno naredite združljivega za izvajanje v Kubernetesu in SageMakerju na način, ki ni odvisen od platforme.

Kako pomaga Kubeflow na AWS in SageMaker?

Modeli nevronske mreže, zgrajeni z okviri globokega učenja, kot so TensorFlow, PyTorch, MXNet in drugi, zagotavljajo veliko večjo natančnost z uporabo bistveno večjih naborov podatkov za usposabljanje, zlasti v primerih uporabe računalniškega vida in obdelave naravnega jezika. Vendar pa pri velikih naborih podatkov za usposabljanje traja dlje, da se usposobijo modeli globokega učenja, kar na koncu upočasni čas do trženja. Če bi lahko razširili gručo in skrajšali čas usposabljanja modela s tednov na dneve ali ure, bi to lahko močno vplivalo na produktivnost in hitrost poslovanja.

Amazon EKS pomaga zagotoviti upravljano kontrolno ravnino Kubernetes. Amazon EKS lahko uporabite za ustvarjanje obsežnih vadbenih gruč z instancami CPU in GPE ter uporabite komplet orodij Kubeflow za zagotavljanje ML-ju prijaznih, odprtokodnih orodij in operacionalizacijo delovnih tokov ML, ki so prenosljivi in ​​razširljivi, z uporabo Kubeflow Pipelines za izboljšanje produktivnosti vaše ekipe in zmanjšati čas do trga.

Vendar bi lahko pri tem pristopu obstajalo nekaj izzivov:

• Zagotavljanje maksimalne izkoriščenosti grozda med skupinami podatkovne znanosti. Na primer, primerke GPE bi morali zagotoviti na zahtevo in zagotoviti njihovo visoko izkoriščenost za zahtevna opravila proizvodnega obsega, kot je usposabljanje za poglobljeno učenje, in uporabiti primerke CPE za manj zahtevne naloge, kot je predprocesiranje podatkov.
• Zagotavljanje visoke razpoložljivosti težkih infrastrukturnih komponent Kubeflow, vključno z bazo podatkov, shranjevanjem in avtentikacijo, ki so nameščene v delovnem vozlišču gruče Kubernetes. Nadzorna ravnina Kubeflow na primer ustvarja artefakte (kot so primerki MySQL, dnevniki podov ali shramba MinIO), ki sčasoma rastejo in potrebujejo prostornine za shranjevanje, ki jih je mogoče spreminjati, z zmožnostmi stalnega spremljanja.
• Deljenje nabora podatkov za usposabljanje, kode in računalniških okolij med razvijalci, grozdi za usposabljanje in projekti je zahtevno. Na primer, če delate na lastnem naboru knjižnic in so te knjižnice močno medsebojno odvisne, postane resnično težko deliti in izvajati isti del kode med podatkovnimi znanstveniki v isti ekipi. Prav tako morate za vsako izvedbo vadbe prenesti nabor podatkov o vadbi in zgraditi sliko vadbe z novimi spremembami kode.

Kubeflow na AWS pomaga pri reševanju teh izzivov in zagotavlja delno upravljan izdelek Kubeflow za podjetja. S Kubeflow na AWS lahko zamenjate nekatere storitve nadzorne ravnine Kubeflow, kot so baza podatkov, shranjevanje, spremljanje in upravljanje uporabnikov, s storitvami, ki jih upravlja AWS, kot je Služba za relacijske baze podatkov Amazon (Amazon RDS), Preprosta storitev shranjevanja Amazon (Amazon S3), Elastični datotečni sistem Amazon (Amazon EFS), Amazon FSx, amazoncloudwatchin Amazon Cognito.

Zamenjava teh komponent Kubeflow loči kritične dele nadzorne ravnine Kubeflow od Kubernetesa, kar zagotavlja varno, razširljivo, prožno in stroškovno optimizirano zasnovo. Ta pristop prav tako sprosti vire za shranjevanje in računanje iz podatkovne ravnine EKS, ki jih morda potrebujejo aplikacije, kot je usposabljanje porazdeljenih modelov ali strežniki za prenosne računalnike uporabnikov. Kubeflow na AWS zagotavlja tudi izvorno integracijo prenosnikov Jupyter s slikami vsebnika za globoko učenje (DLC), ki so vnaprej zapakirane in konfigurirane z ogrodji za globoko učenje, optimizirana za AWS, kot sta PyTorch in TensorFlow, ki vam omogočajo, da takoj začnete pisati kodo za usposabljanje, ne da bi se ukvarjali z razrešitvami odvisnosti in optimizacijami ogrodja. Poleg tega vam integracija Amazon EFS z vadbenimi gručami in razvojnim okoljem omogoča skupno rabo kode in obdelanega nabora vadbenih podatkov, s čimer se izognete ustvarjanju slike vsebnika in nalaganju ogromnih naborov podatkov po vsaki spremembi kode. Te integracije s Kubeflow na AWS vam pomagajo pospešiti gradnjo modela in čas usposabljanja ter omogočajo boljše sodelovanje z enostavnejšo skupno rabo podatkov in kode.

Kubeflow na AWS pomaga zgraditi zelo razpoložljivo in robustno platformo ML. Ta platforma zagotavlja prilagodljivost za gradnjo in usposabljanje modelov globokega učenja ter omogoča dostop do številnih odprtokodnih kompletov orodij, vpogled v dnevnike in interaktivno odpravljanje napak za eksperimentiranje. Vendar pa doseganje maksimalne izkoriščenosti infrastrukturnih virov med usposabljanjem modelov globokega učenja na stotinah grafičnih procesorjev še vedno vključuje veliko operativnih režijskih stroškov. To bi lahko odpravili z uporabo SageMakerja, ki je v celoti upravljana storitev, oblikovana in optimizirana za upravljanje zmogljivih in stroškovno optimiziranih vadbenih gruč, ki so omogočeni le, ko je zahtevano, prilagojeni po potrebi in se samodejno zaustavijo, ko so opravila končana, s čimer zagotavljajo skoraj 100 % izkoriščenosti virov. SageMaker lahko integrirate s Kubeflow Pipelines z uporabo upravljanih komponent SageMaker. To vam omogoča operacionalizacijo delovnih tokov ML kot del cevovodov Kubeflow, kjer lahko uporabite Kubernetes za lokalno usposabljanje in SageMaker za usposabljanje na ravni izdelkov v hibridni arhitekturi.

Pregled rešitev

Naslednja arhitektura opisuje, kako uporabljamo cevovode Kubeflow za gradnjo in uvajanje prenosljivih in razširljivih delovnih tokov ML od konca do konca za pogojno izvajanje porazdeljenega usposabljanja v Kubernetesu z uporabo usposabljanja Kubeflow ali SageMaker na podlagi parametra časa izvajanja.

Usposabljanje Kubeflow je skupina operaterjev Kubernetes, ki dodajo Kubeflowu podporo za porazdeljeno usposabljanje modelov ML z uporabo različnih ogrodij, kot so TensorFlow, PyTorch in drugi. pytorch-operator je Kubeflow izvedba Kubernetesa vir po meri (PyTorchJob) za izvajanje porazdeljenih izobraževalnih opravil PyTorch v Kubernetesu.

Komponento PyTorchJob Launcher uporabljamo kot del cevovoda Kubeflow za zagon porazdeljenega usposabljanja PyTorch med eksperimentalno fazo, ko potrebujemo prilagodljivost in dostop do vseh osnovnih virov za interaktivno odpravljanje napak in analizo.

Uporabljamo tudi komponente SageMaker za Kubeflow Pipelines za izvajanje našega usposabljanja modelov v proizvodnem obsegu. To nam omogoča, da izkoristimo zmogljive funkcije SageMaker, kot so popolnoma upravljane storitve, porazdeljena izobraževalna opravila z maksimalno uporabo GPE in stroškovno učinkovito usposabljanje prek Amazonski elastični računalniški oblak (Amazon EC2) Spot primeri.

Kot del postopka ustvarjanja poteka dela dokončate naslednje korake (kot je prikazano v prejšnjem diagramu), da ustvarite ta cevovod:

1. Uporabite datoteko manifesta Kubeflow, da ustvarite nadzorno ploščo Kubeflow in dostopate do zvezkov Jupyter z osrednje nadzorne plošče Kubeflow.
2. Uporabite Kubeflow pipeline SDK za ustvarjanje in prevajanje Kubeflow cevovodov s kodo Python. Cevovodno prevajanje pretvori funkcijo Python v vir poteka dela, ki je format YAML, združljiv z Argo.
3. Uporabite odjemalca Kubeflow Pipelines SDK, da pokličete končno točko storitve cevovoda za zagon cevovoda.
4. Cevovod ovrednoti pogojne spremenljivke časa izvajanja in se odloči med SageMakerjem ali Kubernetesom kot ciljnim okoljem izvajanja.
5. Uporabite komponento Kubeflow PyTorch Launcher za izvajanje porazdeljenega usposabljanja v izvornem okolju Kubernetes ali uporabite komponento SageMaker za oddajo usposabljanja na upravljani platformi SageMaker.

Naslednja slika prikazuje komponente Kubeflow Pipelines, vključene v arhitekturo, ki nam dajejo prilagodljivost pri izbiri med porazdeljenimi okolji Kubernetes ali SageMaker.

Potek dela primera uporabe

Uporabljamo naslednji pristop po korakih za namestitev in izvajanje primera uporabe za porazdeljeno usposabljanje z uporabo Amazon EKS in SageMaker z uporabo Kubeflow na AWS.

Predpogoji

Za ta korak morate imeti naslednje predpogoje:

• An AWS račun.
• Stroj z Dockerjem in Vmesnik ukazne vrstice AWS (AWS CLI).
• Po želji lahko uporabite AWS Cloud9, integrirano razvojno okolje (IDE) v oblaku, ki omogoča dokončanje celotnega dela iz vašega spletnega brskalnika. Za navodila za nastavitev glejte Nastavite Cloud9 IDE. V okolju Cloud9 izberite znak plus in odprite nov terminal.
• Ustvari vlogo z imenom sagemakerrole. Dodajte upravljane pravilnike AmazonSageMakerFullAccess in AmazonS3FullAccess da SageMakerju omogočite dostop do veder S3. To vlogo uporablja opravilo SageMaker, predloženo kot del koraka Kubeflow Pipelines.
• Prepričajte se, da ima vaš račun omejitev vrste vira SageMaker Training za ml.p3.2xlarge povečana na 2 uporabi Konzola storitvenih kvot

1. Namestite Amazon EKS in Kubeflow na AWS

Za izdelavo gruče Kubernetes in uvajanje Kubeflowa lahko uporabite več različnih pristopov. V tem prispevku se osredotočamo na pristop, za katerega menimo, da prinaša preprostost v postopek. Najprej ustvarimo gručo EKS, nato pa na njej razmestimo Kubeflow na AWS v1.5. Za vsako od teh nalog uporabljamo ustrezen odprtokodni projekt, ki sledi načelom Naredi okvir. Namesto namestitve nabora predpogojev za vsako nalogo, gradimo vsebnike Docker, ki imajo vsa potrebna orodja in izvajajo naloge znotraj vsebnikov.

V tej objavi uporabljamo Do Framework, ki avtomatizira uvajanje Kubeflow z Amazon EFS kot dodatkom. Za uradne možnosti uvedbe Kubeflow na AWS za uvedbe v proizvodnji glejte Deployment.

Konfigurirajte trenutni delovni imenik in AWS CLI

Konfiguriramo delovni imenik, tako da se lahko nanj sklicujemo kot na izhodišče za naslednje korake:

export working_dir=$PWD

Konfiguriramo tudi profil AWS CLI. Če želite to narediti, potrebujete ID ključa za dostop in skrivni ključ za dostop AWS upravljanje identitete in dostopa (JAZ SEM) uporabnik račun s skrbniškimi pravicami (priložite obstoječi upravljani pravilnik) in programskim dostopom. Oglejte si naslednjo kodo:

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 Ustvarite gručo EKS

Če že imate na voljo gručo EKS, lahko preskočite na naslednji razdelek. Za to objavo uporabljamo projekt aws-do-eks ustvariti naš grozd.

1. Najprej klonirajte projekt v vaš delovni imenik

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

2. Nato zgradite in zaženite aws-do-eks posoda:

   ./build.sh
   ./run.sh

   O build.sh skript ustvari sliko vsebnika Docker, ki ima vsa potrebna orodja in skripte za zagotavljanje in delovanje gruč EKS. The run.sh skript zažene vsebnik z uporabo ustvarjene slike Docker in ga vzdržuje, tako da ga lahko uporabljamo kot okolje za upravljanje EKS. Če želite videti stanje svojega aws-do-eks posodo, lahko tečete ./status.sh. Če je vsebnik v stanju Exited, lahko uporabite ./start.sh skript, da prikažete vsebnik ali znova zaženete vsebnik, lahko zaženete ./stop.sh čemur sledi ./run.sh.

3. Odprite lupino v teku aws-do-eks posoda:
4. Če želite pregledati konfiguracijo gruče EKS za našo uvedbo KubeFlow, zaženite naslednji ukaz:

   vi ./eks-kubeflow.yaml

   Privzeto ta konfiguracija ustvari gručo z imenom eks-kubeflow v us-west-2 Regija s šestimi vozlišči m5.xlarge. Prav tako šifriranje nosilcev EBS ni privzeto omogočeno. Omogočite ga lahko z dodajanjem "volumeEncrypted: true" v skupino vozlišč in bo šifrirala s privzetim ključem. Po potrebi spremenite druge nastavitve konfiguracije.

5. Če želite ustvariti gručo, zaženite naslednji ukaz:

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

   Postopek zagotavljanja gruče lahko traja do 30 minut.

6. Če želite preveriti, ali je bila gruča uspešno ustvarjena, zaženite naslednji ukaz:

   kubectl get nodes

   Rezultat prejšnjega ukaza za gručo, ki je bila uspešno ustvarjena, izgleda kot naslednja koda:

   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

Ustvarite nosilec EFS za učno opravilo SageMaker

V tem primeru uporabe pospešite usposabljanje SageMaker z usposabljanjem modelov globokega učenja iz podatkov, ki so že shranjeni v Amazon EFS. Prednost te izbire je neposredno zagon vaših izobraževalnih nalog iz podatkov v Amazon EFS brez premikanja podatkov, kar ima za posledico hitrejše začetne čase usposabljanja.

Ustvarimo nosilec EFS in uvedemo gonilnik EFS Container Storage Interface (CSI). To se doseže s skriptom za uvajanje, ki se nahaja v /eks/deployment/csi/efs znotraj aws-do-eks zabojnik.

Ta skript predvideva, da imate v svojem računu eno gručo EKS. Set CLUSTER_NAME= v primeru, da imate več kot eno gručo EKS.

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

Ta skript zagotovi nosilec EFS in ustvari cilje vpetja za podomrežja gruče VPC. Nato uvede gonilnik EFS CSI in ustvari efs-sc razred shranjevanja in efs-pv trajna glasnost v gruči EKS.

Po uspešnem zaključku skripta bi morali videti izhod, kot je ta:

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

Ustvarite končno točko Amazon S3 VPC

Uporabljate zasebni VPC, do katerega imata dostop vaše delovno mesto za usposabljanje SageMaker in datotečni sistem EFS. Če želite vadbeni gruči SageMaker omogočiti dostop do veder S3 iz vašega zasebnega VPC, ustvarite končno točko VPC:

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

Zdaj lahko zapustite aws-do-eks lupino vsebnika in nadaljujte z naslednjim razdelkom:

exit

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

1.2 Namestite Kubeflow na AWS na Amazon EKS

Za uvedbo Kubeflow na Amazon EKS uporabljamo projekt aws-do-kubeflow.

1. Klonirajte repozitorij z naslednjimi ukazi:

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

2. Nato konfigurirajte projekt:

   ./config.sh

   Ta skript odpre konfiguracijsko datoteko projekta v urejevalniku besedil. Pomembno je za AWS_REGION nastavljen na regijo, v kateri je vaša gruča, kot tudi AWS_CLUSTER_NAME da se ujema z imenom gruče, ki ste jo ustvarili prej. Privzeto je vaša konfiguracija že pravilno nastavljena, tako da, če vam ni treba narediti nobenih sprememb, samo zaprite urejevalnik.

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

   O build.sh skript ustvari sliko vsebnika Docker, ki ima vsa potrebna orodja za uvajanje in upravljanje Kubeflowa v obstoječi gruči Kubernetes. The run.sh skript zažene vsebnik z uporabo slike Docker, skript exec.sh pa odpre ukazno lupino v vsebnik, ki ga lahko uporabimo kot okolje za upravljanje Kubeflow. Lahko uporabite ./status.sh skript, da preverite, ali je aws-do-kubeflow vsebnik deluje in deluje ./stop.sh in ./run.sh skripte za ponovni zagon po potrebi.

3. Ko imate odprto lupino v aws-do-eks vsebnika, lahko preverite, ali je konfiguriran kontekst gruče po pričakovanjih:

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

4. Če želite uvesti Kubeflow v gručo EKS, zaženite deploy.sh skript:

   ./kubeflow-deploy.sh

   Razmestitev je uspešna, ko vsi podi v imenskem prostoru kubeflow preidejo v stanje izvajanja. Tipičen izhod je videti kot naslednja koda:

   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. Če želite spremljati stanje podov KubeFlow, lahko v ločenem oknu uporabite naslednji ukaz:

   watch kubectl -n kubeflow get pods

6. Pritisnite Ctrl + C ko se vsi sklopi izvajajo, izpostavite nadzorno ploščo Kubeflow zunaj gruče, tako da zaženete naslednji ukaz:

   ./kubeflow-expose.sh

Videti bi morali izpis, ki je videti kot naslednja koda:

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

Ta ukaz posreduje storitev vhodnega prehoda Istio iz vaše gruče v vaša lokalna vrata 8080. Za dostop do nadzorne plošče Kubeflow obiščite http://localhost:8080 in se prijavite s privzetimi uporabniškimi poverilnicami (uporabnik@example.com/12341234). Če izvajate aws-do-kubeflow vsebnik v AWS Cloud9, potem lahko izberete predogled, nato izberite Predogled zagnane aplikacije. Če uporabljate Docker Desktop, boste morda morali zagnati ./kubeflow-expose.sh scenarij zunaj aws-do-kubeflow zabojnik.

2. Nastavite Kubeflow v okolju AWS

Za nastavitev vašega Kubeflow v okolju AWS ustvarimo nosilec EFS in prenosnik Jupyter.

2.1 Ustvarite nosilec EFS

Če želite ustvariti nosilec EFS, izvedite naslednje korake:

• Na nadzorni plošči Kubeflow izberite Količine v podoknu za krmarjenje.
• Izbrala Nov zvezek.
• za Ime, vnesite efs-sc-claim.
• za Velikost prostornine, vnesite 10.
• za Razred shranjevanja, izberite efs-sc.
• za Način dostopa, izberite ReadWriteOnce.
• Izberite ustvarjanje.

2.2 Ustvarite Jupyterjev zvezek

Če želite ustvariti nov zvezek, izvedite naslednje korake:

• Na nadzorni plošči Kubeflow izberite Prenosniki v podoknu za krmarjenje.
• Izberite Nov zvezek.
• za Ime, vnesite aws-hybrid-nb.
• za Slika Jupyter Docket, izberite sliko c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (najnovejša razpoložljiva slika DLC jupyter-pytorch).
• za CPU, vnesite 1.
• za Spomin, vnesite 5.
• za Grafične kartice, pusti kot Noben.
• Ne delajte nobenih sprememb v Glasnost delovnega prostora oddelek.
• v Podatkovne količine oddelek, izberite Priložite obstoječi nosilec in razširite razdelek Obstoječi nosilec
• za Ime, izberite efs-sc-claim.
• za Montažna pot, vnesite /home/jovyan/efs-sc-claim.
  S tem se nosilec EFS priklopi na blok vašega prenosnega računalnika Jupyter in vidite mapo efs-sc-claim v vašem vmesniku laboratorija Jupyter. Nabor podatkov o usposabljanju in kodo za usposabljanje shranite v to mapo, tako da lahko gruče za usposabljanje dostopajo do njih, ne da bi morali znova zgraditi slike vsebnika za testiranje.
• Izberite Dovolite dostop do cevovodov Kubeflow v razdelku Konfiguracija.
• Izberite Zagon.
  Preverite, ali je vaš zvezek uspešno ustvarjen (lahko traja nekaj minut).
• o Prenosniki stran, izberite Connect za prijavo v okolje JupyterLab.
• o git izberite meni Klonirajte repozitorij.
• za Klonirajte repo, vnesite https://github.com/aws-samples/aws-do-kubeflow.
  

3. Zaženite porazdeljeno usposabljanje

Ko nastavite prenosni računalnik Jupyter, lahko zaženete celotno predstavitev z uporabo naslednjih korakov na visoki ravni iz mape aws-do-kubeflow/workshop v kloniranem repozitoriju:

• Skript za usposabljanje PyTorch Distributed Data Parallel (DDP): Glejte skript za usposabljanje PyTorch DDP cifar10-distributed-gpu-final.py, ki vključuje vzorec konvolucijske nevronske mreže in logiko za distribucijo usposabljanja v gruči CPE in GPE z več vozlišči. (Za podrobnosti glejte 3.1)
• Namesti knjižnice: Zaženite zvezek 0_initialize_dependencies.ipynb za inicializacijo vseh odvisnosti. (Za podrobnosti glejte 3.2)
• Zaženite distribuirano delovno usposabljanje PyTorch na Kubernetesu: Zaženite zvezek 1_submit_pytorchdist_k8s.ipynb za ustvarjanje in oddajo porazdeljenega usposabljanja na enem primarnem in dveh delovnih vsebnikih z uporabo datoteke YAML PyTorchJob po meri Kubernetes s kodo Python. (Za podrobnosti glejte 3.3)
• Ustvarite hibridni cevovod Kubeflow: Zaženite zvezek 2_create_pipeline_k8s_sagemaker.ipynb za ustvarjanje hibridnega cevovoda Kubeflow, ki izvaja porazdeljeno usposabljanje na SageMaker ali Amazon EKS z uporabo spremenljivke izvajalnega časa training_runtime. (Za podrobnosti glejte 3.4)

Prepričajte se, da ste zagnali zvezek 1_submit_pytorchdist_k8s.ipynb preden začnete z beležnico 2_create_pipeline_k8s_sagemaker.ipynb.

V naslednjih razdelkih podrobno razpravljamo o vsakem od teh korakov.

3.1 Skript za usposabljanje PyTorch Distributed Data Parallel (DDP).

V okviru porazdeljenega usposabljanja usposabljamo klasifikacijski model, ki ga ustvari preprosta konvolucijska nevronska mreža, ki deluje na podatkovnem nizu CIFAR10. Scenarij treninga cifar10-distributed-gpu-final.py vsebuje samo odprtokodne knjižnice in je združljiv za izvajanje tako v vadbenih gručah Kubernetes kot SageMaker na napravah GPE ali instancah CPE. Oglejmo si nekaj pomembnih vidikov skripta za usposabljanje, preden zaženemo naše primere zvezkov.

Mi uporabljamo torch.distributed modul, ki vsebuje podporo PyTorch in komunikacijske primitive za večprocesni paralelizem med vozlišči v gruči:

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

Ustvarjamo preprost model klasifikacije slik z uporabo kombinacije konvolucijskih, maksimalnih združevanja in linearnih plasti, za katere je uporabljena funkcija aktivacije relu v naprednem prehodu usposabljanja modela:

# 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

Uporabljamo torch DataLoader, ki združuje nabor podatkov in DistributedSampler (naloži podnabor podatkov na porazdeljen način z uporabo torch.nn.parallel.DistributedDataParallel) in zagotavlja enoprocesni ali večprocesni iterator nad podatki:

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

Če ima vadbena gruča GPU-je, skript izvaja usposabljanje na napravah CUDA in spremenljivka naprave vsebuje privzeto napravo CUDA:

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

Preden zaženete porazdeljeno usposabljanje z uporabo PyTorcha DistributedDataParallel če želite zagnati porazdeljeno obdelavo na več vozliščih, morate inicializirati porazdeljeno okolje s klicem init_process_group. To se inicializira na vsakem računalniku učne gruče.

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

Instanciramo model klasifikatorja in kopiramo model v ciljno napravo. Če je porazdeljeno usposabljanje omogočeno za izvajanje na več vozliščih, je DistributedDataParallel razred se uporablja kot ovojni objekt okoli modela modela, ki omogoča sinhrono porazdeljeno usposabljanje na več strojih. Vhodni podatki so razdeljeni na serijsko dimenzijo in na vsak stroj in vsako napravo je nameščena replika modela.

model = Net().to(device)

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

...

3.2 Namestitev knjižnic

Namestili boste vse potrebne knjižnice za izvajanje primera distribuiranega usposabljanja PyTorch. To vključuje Kubeflow Pipelines SDK, Training Operator Python SDK, odjemalec Python za Kubernetes in 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 Zaženite distribuirano delovno usposabljanje PyTorch na Kubernetesu

Zvezek 1_submit_pytorchdist_k8s.ipynb ustvari datoteko YAML vira po meri Kubernetes PyTorchJob z uporabo usposabljanja Kubeflow in odjemalca Kubernetes Python SDK. Sledi nekaj pomembnih izrezkov iz tega zvezka.

Ustvarimo PyTorchJob YAML s primarnim in delovnim vsebnikom, kot je prikazano v naslednji kodi:

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

To je predloženo nadzorni ravnini Kubernetes z uporabo PyTorchJobClient:

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

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Oglejte si dnevnike usposabljanja Kubernetes

Dnevnike usposabljanja si lahko ogledate iz istega prenosnika Jupyter z uporabo kode Python ali iz odjemalske lupine Kubernetes.

3.4 Ustvarite hibridni cevovod Kubeflow

Zvezek 2_create_pipeline_k8s_sagemaker.ipynb ustvari hibridni cevovod Kubeflow, ki temelji na pogojni izvajalni spremenljivki training_runtime, kot je prikazano v naslednji kodi. Beležnica uporablja SDK za cevovode Kubeflow in je zagotovil nabor paketov Python za določanje in zagon cevovodov poteka dela ML. Kot del tega SDK-ja uporabljamo naslednje pakete:

• Okraševalec paketov domensko specifičnih jezikov (DSL). dsl.pipeline, ki okrasi funkcije Python za vrnitev cevovoda
• O dsl.Condition paket, ki predstavlja skupino operacij, ki se izvajajo samo, ko je izpolnjen določen pogoj, kot je preverjanje training_runtime vrednost kot sagemaker or kubernetes

Glej naslednjo kodo:

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

Porazdeljeno usposabljanje SageMaker konfiguriramo z uporabo dveh primerkov ml.p3.2xlarge.

Ko je cevovod definiran, ga lahko prevedete v specifikacijo Argo YAML z uporabo kompleta za razvoj programske opreme Kubeflow Pipelines kfp.compiler paket. Ta cevovod lahko zaženete z odjemalcem Kubeflow Pipeline SDK, ki pokliče končno točko storitve Pipelines in posreduje ustrezne glave za preverjanje pristnosti neposredno iz prenosnega računalnika. Oglejte si naslednjo kodo:

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

Če dobite sagemaker import napaka, zaženite !pip namestite sagemaker in znova zaženite jedro (na Kernel izberite meni Ponovno zaženite jedro).

Izberite Podrobnosti o teku povezavo pod zadnjo celico za ogled cevovoda Kubeflow.

Ponovite korak ustvarjanja cevovoda z training_runtime='kubernetes' za testiranje delovanja cevovoda v okolju Kubernetes. The training_runtime spremenljivko lahko posredujete tudi v vašem cevovodu CI/CD v proizvodnem scenariju.

Oglejte si dnevnike izvajanja cevovoda Kubeflow za komponento SageMaker

Naslednji posnetek zaslona prikazuje podrobnosti našega cevovoda za komponento SageMaker.

Izberite korak usposabljanja in na Dnevniki izberite povezavo CloudWatch logs za dostop do dnevnikov SageMaker.

Naslednji posnetek zaslona prikazuje dnevnike CloudWatch za vsakega od dveh primerkov ml.p3.2xlarge.

Za ogled dnevnikov izberite katero koli od skupin.

Oglejte si dnevnike izvajanja cevovoda Kubeflow za komponento Kubeflow PyTorchJob Launcher

Naslednji posnetek zaslona prikazuje podrobnosti cevovoda za našo komponento Kubeflow.

Zaženite naslednje ukaze z uporabo Kubectl na vaši odjemalski lupini Kubernetes, povezani z gručo Kubernetes, da vidite dnevnike (nadomestite svoj imenski prostor in imena podov):

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

4.1 Čiščenje

Če želite počistiti vse vire, ki smo jih ustvarili v računu, jih moramo odstraniti v obratnem vrstnem redu.

1. Z zagonom izbrišite namestitev Kubeflow ./kubeflow-remove.sh v aws-do-kubeflow posoda. Prvi nabor ukazov je neobvezen in ga lahko uporabite, če še nimate ukazne lupine v svojem aws-do-kubeflow posoda odprta.

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

2. Iz aws-do-eks vsebnik, odstranite nosilec EFS. Prvi niz ukazov je neobvezen in ga lahko uporabite, če še nimate ukazne lupine v svojem aws-do-eks posoda odprta.

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

   Brisanje Amazon EFS je potrebno za sprostitev omrežnega vmesnika, povezanega z VPC, ki smo ga ustvarili za našo gručo. Upoštevajte, da brisanje nosilca EFS uniči vse podatke, ki so na njem shranjeni.

3. Iz aws-do-eks posodo, zaženite eks-delete.sh skript za brisanje gruče in vseh drugih virov, povezanih z njo, vključno z VPC:

   cd /eks
   ./eks-delete.sh

Povzetek

V tej objavi smo razpravljali o nekaterih tipičnih izzivih usposabljanja za porazdeljene modele in delovnih tokov ML. Zagotovili smo pregled distribucije Kubeflow na AWS in delili dva odprtokodna projekta (aws-do-eks in aws-do-kubeflow), ki poenostavljajo zagotavljanje infrastrukture in uvedbo Kubeflow na njej. Nazadnje smo opisali in prikazali hibridno arhitekturo, ki omogoča nemoteno prehajanje delovnih obremenitev med delovanjem na samoupravljani infrastrukturi Kubernetes in popolnoma upravljani infrastrukturi SageMaker. Spodbujamo vas, da to hibridno arhitekturo uporabite za lastne primere uporabe.

Lahko sledite Repozitorij AWS Labs za sledenje vsem prispevkom AWS v Kubeflow. Najdete nas tudi na Kubeflow #AWS Slack Channel; vaše povratne informacije nam bodo pomagale določiti prednost naslednjim funkcijam za prispevanje k projektu Kubeflow.

Posebna zahvala Sree Arasanagatta (vodja razvoja programske opreme AWS ML) in Suraj Kota (razvijalec programske opreme) za njuno podporo pri objavi te objave.

O avtorjih

Kanwaljit Khurmi je specialist za rešitve AI/ML pri Amazon Web Services. Sodeluje z izdelkom AWS, inženiringom in strankami, da bi zagotovil smernice in tehnično pomoč, ki jim pomaga izboljšati vrednost njihovih hibridnih rešitev ML pri uporabi AWS. Kanwaljit je specializiran za pomoč strankam z aplikacijami za vsebnike in strojnim učenjem.

Gautam Kumar je programski inženir z AWS AI Deep Learning. Razvil je AWS Deep Learning Containers in AWS Deep Learning AMI. Navdušen je nad gradnjo orodij in sistemov za AI. V prostem času rad kolesari in bere knjige.

Alex Iankoulski je arhitekt programske opreme in infrastrukture s polnim skladom, ki rad opravlja poglobljeno in praktično delo. Trenutno je glavni arhitekt rešitev za samoupravljano strojno učenje pri AWS. V svoji vlogi se osredotoča na pomoč strankam pri kontejnerizaciji in orkestraciji delovnih obremenitev ML in AI v storitvah AWS, ki jih poganja vsebnik. Je tudi avtor odprte kode Naredi okvir in kapitan Dockerja, ki obožuje uporabo tehnologij vsebnikov za pospešitev hitrosti inovacij ob reševanju največjih izzivov na svetu. V zadnjih 10 letih se je Alex ukvarjal z bojem proti podnebnim spremembam, demokratiziral AI in ML, naredil potovanja varnejša, zdravstveno varstvo boljše in energijo pametnejšo.