Rugalmas és méretezhető elosztott képzési architektúrák létrehozása a Kubeflow segítségével az AWS-en és az Amazon SageMakeren

Ebben a bejegyzésben bemutatjuk, hogyan Kubeflow az AWS-en (a Kubeflow AWS-specifikus disztribúciója) együtt használják AWS Deep Learning Containers és a Amazon elasztikus fájlrendszer (Amazon EFS) leegyszerűsíti az együttműködést, és rugalmasságot biztosít a mély tanulási modellek nagyszabású képzésében mindkét területen Amazon Elastic Kubernetes szolgáltatás (Amazon EKS) és Amazon SageMaker hibrid architektúra megközelítést alkalmazva.

A gépi tanulás (ML) fejlesztése komplex és folyamatosan fejlődő nyílt forráskódú keretrendszerekre és eszközkészletekre, valamint összetett és folyamatosan fejlődő hardver-ökoszisztémákra támaszkodik. Ez kihívást jelent, amikor az ML-fejlesztést fürtökre méretezzük. A konténerek megoldást kínálnak, mert nem csak a betanítási kódot, hanem a teljes függőségi köteget a hardverkönyvtárakig képesek teljesen magába foglalni. Ez konzisztens és hordozható ML környezetet biztosít, és megkönnyíti a betanítási környezet reprodukálhatóságát a betanítási fürt minden egyes csomópontján.

A Kubernetes egy széles körben elterjedt rendszer az infrastruktúra-telepítés automatizálására, az erőforrás-skálázásra és ezeknek a konténeres alkalmazásoknak a kezelésére. A Kubernetes azonban nem az ML szem előtt tartásával készült, így a YAML specifikációs fájlokra való erős támaszkodása miatt az adattudósok számára ellentmondásos lehet. Nincs Jupyter-élmény, és nincs sok ML-specifikus képesség, mint például a munkafolyamat-kezelés és a folyamatkezelés, valamint az ML-szakértők által elvárt egyéb képességek, mint például a hiperparaméter-hangolás, a modelltárolás és egyebek. Ilyen képességek kiépíthetők, de a Kubernetes nem ennek az elsődleges célja volt.

A nyílt forráskódú közösség észrevette, és kifejlesztett egy réteget a Kubernetes tetején, a Kubeflow néven. A Kubeflow célja, hogy a végpontok közötti ML munkafolyamatok telepítését a Kubernetes rendszeren egyszerűvé, hordozhatóvá és méretezhetővé tegye. A Kubeflow segítségével a legjobb nyílt forráskódú rendszereket telepítheti az ML-hez különféle infrastruktúrákban.

A Kubeflow és a Kubernetes rugalmasságot és vezérlést biztosít az adattudós csapatok számára. Ugyanakkor továbbra is kihívást jelent a méretarányosan működő oktatási klaszterek magas kihasználtságának biztosítása, csökkentett működési költségek mellett.

Ez a bejegyzés bemutatja, hogy a helyszíni korlátozásokkal vagy meglévő Kubernetes-befektetésekkel rendelkező ügyfelek hogyan kezelhetik ezt a kihívást az Amazon EKS és a Kubeflow segítségével az AWS-en, hogy ML-folyamatot valósítsanak meg az elosztott képzéshez önmenedzselésen alapuló megközelítésen, és hogyan használják a teljesen felügyelt SageMaker-t költségoptimalizált, teljes körűen menedzselt és termelési léptékű képzési infrastruktúra. Ez magában foglalja a hibrid elosztott betanítási architektúra lépésről lépésre történő megvalósítását, amely lehetővé teszi, hogy futás közben válasszon a két megközelítés közül, maximális irányítást és rugalmasságot biztosítva a telepítések szigorú követelményei mellett. Látni fogja, hogyan használhatja tovább a nyílt forráskódú könyvtárakat a mély tanulási képzési szkriptjében, és továbbra is kompatibilissé teheti azt Kubernetesen és SageMakeren egyaránt, platform-agnosztikus módon.

Hogyan segít a Kubeflow az AWS-en és a SageMakeren?

A mély tanulási keretrendszerekkel, például TensorFlow, PyTorch, MXNet és másokkal épített neurális hálózati modellek sokkal nagyobb pontosságot biztosítanak a lényegesen nagyobb betanítási adatkészletek használatával, különösen számítógépes látás és természetes nyelvi feldolgozás esetén. Nagy betanítási adatkészletek esetén azonban tovább tart a mély tanulási modellek betanítása, ami végső soron lelassítja a piacra kerülés idejét. Ha ki tudnánk skálázni egy klasztert, és a modell képzési idejét hetekről napokra vagy órákra csökkentené, az óriási hatással lehet a termelékenységre és az üzleti sebességre.

Az Amazon EKS segíti a felügyelt Kubernetes vezérlősíkot. Az Amazon EKS segítségével nagyszabású képzési fürtöket hozhat létre CPU- és GPU-példányokkal, a Kubeflow eszközkészlet pedig ML-barát, nyílt forráskódú eszközöket biztosít, valamint a Kubeflow Pipelines segítségével hordozható és méretezhető ML-munkafolyamatokat működtethet csapata termelékenységének és hatékonyságának növelése érdekében. csökkenti a piacra jutás idejét.

Ezzel a megközelítéssel azonban felmerülhet néhány kihívás:

• A fürt maximális kihasználásának biztosítása az adattudományi csapatok között. Például igény szerint kell biztosítania a GPU-példányokat, és biztosítania kell azok magas kihasználtságát az olyan igényes, termelési méretű feladatokhoz, mint például a mélytanulási képzés, és a CPU-példányokat kell használnia a kevésbé igényes feladatokhoz, például az adat-előfeldolgozáshoz.
• A Kubernetes-fürt dolgozó csomópontjában telepített nehézsúlyú Kubeflow infrastruktúra-összetevők magas rendelkezésre állása, beleértve az adatbázist, a tárolást és a hitelesítést. Például a Kubeflow vezérlősík olyan műtermékeket (például MySQL-példányokat, pod-naplókat vagy MinIO-tárhelyet) állít elő, amelyek idővel növekednek, és átméretezhető tárolóköteteket igényelnek folyamatos megfigyelési képességekkel.
• A képzési adatkészlet, kód és számítási környezet megosztása fejlesztők, képzési fürtök és projektek között kihívást jelent. Például, ha saját könyvtárkészletén dolgozik, és ezek a könyvtárak erősen kölcsönösen függenek egymástól, nagyon nehéz lesz megosztani és futtatni ugyanazt a kódrészletet egyazon csapat adattudósai között. Ezenkívül minden edzési futáshoz le kell töltenie az edzési adatkészletet, és új kódmódosításokkal kell elkészítenie az edzési képet.

A Kubeflow az AWS-en segít ezeknek a kihívásoknak a megoldásában, és vállalati szintű, félig menedzselt Kubeflow terméket biztosít. Az AWS-en futó Kubeflow segítségével bizonyos Kubeflow vezérlősík-szolgáltatásokat, például adatbázist, tárolást, megfigyelést és felhasználókezelést lecserélhet olyan AWS-felügyelt szolgáltatásokra, mint pl. Amazon Relációs adatbázis-szolgáltatás (Amazon RDS), Amazon egyszerű tárolási szolgáltatás (Amazon S3), Amazon elasztikus fájlrendszer (Amazon EFS), Amazon FSx, amazonfelhőóraés Amazon Cognito.

A Kubeflow összetevőinek cseréje leválasztja a Kubeflow vezérlősík kritikus részeit a Kubernetesről, biztonságos, méretezhető, rugalmas és költségoptimalizált kialakítást biztosítva. Ez a megközelítés tárhelyet és számítási erőforrásokat is felszabadít az EKS adatsíkjáról, amelyre olyan alkalmazásoknak lehet szükségük, mint például az elosztott modellképzés vagy a felhasználói notebook szerverek. A Kubeflow az AWS-en ezenkívül a Jupyter notebookok natív integrációját is biztosítja Deep Learning Container (DLC) képekkel, amelyek előre csomagolva és előre konfigurálva vannak AWS-re optimalizált mélytanulási keretrendszerekkel, mint például a PyTorch és a TensorFlow, amelyek lehetővé teszik, hogy azonnal elkezdje írni a képzési kódot, anélkül, hogy foglalkozna. függőségi felbontásokkal és keretrendszer-optimalizálással. Ezenkívül az Amazon EFS integrációja a képzési fürtökkel és a fejlesztői környezettel lehetővé teszi a kód és a feldolgozott betanítási adatkészlet megosztását, így elkerülhető a konténerkép létrehozása és a hatalmas adatkészletek betöltése minden kódváltás után. Az AWS-en futó Kubeflow-val való integráció felgyorsítja a modellépítést és a betanítási időt, és lehetővé teszi a jobb együttműködést az egyszerűbb adat- és kódmegosztással.

A Kubeflow az AWS-en segít egy rendkívül elérhető és robusztus ML platform felépítésében. Ez a platform rugalmasságot biztosít a mély tanulási modellek felépítéséhez és betanításához, valamint hozzáférést biztosít számos nyílt forráskódú eszközkészlethez, betekintést nyújt a naplókba, és interaktív hibakeresést tesz lehetővé a kísérletezéshez. Azonban az infrastrukturális erőforrások maximális kihasználása a mély tanulási modellek több száz GPU-n való betanítása közben még mindig sok működési költséggel jár. Ez megoldható a SageMaker használatával, amely egy teljesen felügyelt szolgáltatás, amelyet a hatékony és költségoptimalizált oktatási fürtök kezelésére terveztek és optimalizáltak, amelyek csak kérésre kerülnek kiépítésre, szükség szerint méretezhetők, és automatikusan leállnak, amikor a feladatok befejeződnek, ezáltal közel 100 % erőforrás-felhasználás. A SageMaker-t a Kubeflow-folyamatokkal integrálhatja felügyelt SageMaker-összetevők használatával. Ez lehetővé teszi az ML-munkafolyamatok operacionalizálását a Kubeflow folyamatok részeként, ahol a Kubernetes a helyi képzéshez, a SageMaker pedig a termékléptékű oktatáshoz használható hibrid architektúrában.

Megoldás áttekintése

A következő architektúra leírja, hogyan használjuk a Kubeflow-folyamatokat hordozható és méretezhető végpontok közötti ML-munkafolyamatok létrehozására és üzembe helyezésére, hogy feltételesen futtathassuk az elosztott képzést Kubernetesen a Kubeflow képzés vagy a SageMaker segítségével a futásidejű paraméter alapján.

A Kubeflow képzés Kubernetes-operátorok csoportja, amely a Kubeflow-hoz hozzáadja az ML-modellek elosztott képzésének támogatását különböző keretrendszerek használatával, például TensorFlow, PyTorch és mások. pytorch-operator a Kubernetes Kubeflow megvalósítása egyéni erőforrás (PyTorchJob) elosztott PyTorch képzési feladatok futtatásához Kubernetesen.

A PyTorchJob Launcher összetevőt a Kubeflow folyamat részeként használjuk a PyTorch elosztott képzésének futtatására a kísérleti szakaszban, amikor rugalmasságra és az összes mögöttes erőforráshoz való hozzáférésre van szükségünk az interaktív hibakereséshez és elemzéshez.

A Kubeflow Pipelines-ekhez SageMaker-komponenseket is használunk a modellképzés gyártási léptékű futtatásához. Ez lehetővé teszi számunkra, hogy kihasználjuk az olyan hatékony SageMaker funkciók előnyeit, mint a teljesen felügyelt szolgáltatások, az elosztott képzési feladatok maximális GPU-kihasználással és a költséghatékony képzés Amazon rugalmas számítási felhő (Amazon EC2) Spot példányok.

A munkafolyamat-létrehozási folyamat részeként a következő lépéseket kell végrehajtania (az előző diagramon látható módon) a folyamat létrehozásához:

1. A Kubeflow-jegyzékfájl segítségével hozzon létre egy Kubeflow-irányítópultot, és érje el a Jupyter-jegyzetfüzeteket a Kubeflow központi irányítópultjáról.
2. Használja a Kubeflow-folyamat SDK-t Kubeflow-folyamatok létrehozásához és fordításához Python-kóddal. A csővezeték-összeállítás a Python függvényt munkafolyamat-erőforrássá alakítja, amely Argo-kompatibilis YAML formátum.
3. A Kubeflow Pipelines SDK-ügyfél segítségével hívja meg a folyamatszolgáltatás végpontját a folyamat futtatásához.
4. A folyamat értékeli a feltételes futásidejű változókat, és eldönti, hogy a SageMaker vagy a Kubernetes a cél futtatási környezet.
5. Használja a Kubeflow PyTorch Launcher összetevőt elosztott képzések futtatásához a natív Kubernetes környezetben, vagy használja a SageMaker összetevőt a képzés elküldéséhez a SageMaker felügyelt platformon.

A következő ábra az architektúrában részt vevő Kubeflow Pipelines összetevőket mutatja be, amelyek rugalmasságot biztosítanak számunkra a Kubernetes vagy a SageMaker elosztott környezetek közötti választásban.

Case Workflow használata

A következő lépésenkénti megközelítést alkalmazzuk a használati eset telepítéséhez és futtatásához az elosztott képzéshez az Amazon EKS és a SageMaker segítségével az AWS Kubeflow használatával.

Előfeltételek

Ehhez az áttekintéshez a következő előfeltételekkel kell rendelkeznie:

• An AWS-fiók.
• Egy gép a Dockerrel és a AWS parancssori interfész (AWS CLI) telepítve.
• Opcionálisan használhatja AWS Cloud9, egy felhő alapú integrált fejlesztői környezet (IDE), amely lehetővé teszi az összes munka elvégzését a webböngészőből. A beállítási utasításokat lásd: A Cloud9 IDE beállítása. Cloud9-környezetében válassza ki a pluszjelet, és nyissa meg az új terminált.
• Hozzon létre egy szerepet a névvel sagemakerrole. Felügyelt házirendek hozzáadása AmazonSageMakerFullAccess és a AmazonS3FullAccess hogy a SageMaker hozzáférjen az S3 gyűjtőhelyekhez. Ezt a szerepet a Kubeflow Pipelines lépés részeként beküldött SageMaker-feladat használja.
• Győződjön meg arról, hogy fiókjában rendelkezik SageMaker Training erőforrástípus-korlátozással ml.p3.2xlarge használatával 2-re nőtt Szolgáltatáskvóta-konzol

1. Telepítse az Amazon EKS-t és a Kubeflow-t az AWS-re

Számos különböző megközelítést használhat Kubernetes-fürt létrehozásához és a Kubeflow üzembe helyezéséhez. Ebben a bejegyzésben egy olyan megközelítésre összpontosítunk, amelyről úgy gondoljuk, hogy egyszerűbbé teszi a folyamatot. Először létrehozunk egy EKS-fürtöt, majd telepítjük rá a Kubeflow-t az AWS v1.5-re. Mindegyik feladathoz egy megfelelő nyílt forráskódú projektet használunk, amely követi a Végezze el a keretrendszert. Ahelyett, hogy minden egyes feladathoz előfeltételeket telepítenénk, Docker-tárolókat építünk, amelyek minden szükséges eszközzel rendelkeznek, és a tárolókon belülről hajtják végre a feladatokat.

Ebben a bejegyzésben a Do Framework-et használjuk, amely automatizálja a Kubeflow telepítését az Amazon EFS-sel kiegészítőként. A hivatalos Kubeflow on AWS üzembe helyezési lehetőségek éles üzembe helyezésekhez lásd: bevetés.

Konfigurálja az aktuális munkakönyvtárat és az AWS parancssori felületet

Beállítunk egy munkakönyvtárat, hogy a következő lépések kiindulópontjaként hivatkozhassunk rá:

export working_dir=$PWD

Konfigurálunk egy AWS CLI profilt is. Ehhez szüksége van egy hozzáférési kulcs azonosítójára és titkos hozzáférési kulcsára AWS Identity and Access Management (AMI) használó fiók rendszergazdai jogosultságokkal (csatolja a meglévő felügyelt házirendet) és programozott hozzáféréssel. Lásd a következő kódot:

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 Hozzon létre egy EKS-fürtöt

Ha már rendelkezik elérhető EKS-fürttel, ugorhat a következő szakaszra. Ehhez a bejegyzéshez a aws-do-eks projekt klaszterünk létrehozásához.

1. Először klónozza a projektet a munkakönyvtárába

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

2. Ezután építse meg és futtassa a aws-do-eks tartály:

   ./build.sh
   ./run.sh

   A build.sh script létrehoz egy Docker-tároló lemezképet, amely minden szükséges eszközzel és szkripttel rendelkezik az EKS-fürtök kiépítéséhez és működtetéséhez. Az run.sh script elindít egy tárolót a létrehozott Docker lemezkép segítségével, és fenntartja azt, így használhatjuk EKS felügyeleti környezetünkként. Az Ön állapotának megtekintéséhez aws-do-eks konténer, futhat ./status.sh. Ha a tároló Kilépve állapotú, használhatja a ./start.sh szkriptet a tároló megjelenítéséhez vagy a tároló újraindításához, futtathatja ./stop.sh követ ./run.sh.

3. Nyisson meg egy shellt a futás közben aws-do-eks tartály:
4. A KubeFlow-telepítés EKS-fürtkonfigurációjának áttekintéséhez futtassa a következő parancsot:

   vi ./eks-kubeflow.yaml

   Alapértelmezés szerint ez a konfiguráció egy nevű fürtöt hoz létre eks-kubeflow a us-west-2 Régió hat m5.xnagy csomóponttal. Ezenkívül az EBS kötetek titkosítása alapértelmezés szerint nincs engedélyezve. Hozzáadásával engedélyezheti "volumeEncrypted: true" a csomópontcsoporthoz, és az alapértelmezett kulccsal titkosítja. Szükség esetén módosítsa az egyéb konfigurációs beállításokat.

5. A fürt létrehozásához futtassa a következő parancsot:

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

   A fürt kiépítési folyamata akár 30 percig is eltarthat.

6. A fürt sikeres létrehozásának ellenőrzéséhez futtassa a következő parancsot:

   kubectl get nodes

   A sikeresen létrehozott fürt előző parancsának kimenete a következő kódhoz hasonlít:

   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

Hozzon létre egy EFS-kötetet a SageMaker képzési feladathoz

Ebben a használati esetben felgyorsítja a SageMaker képzési munkát azáltal, hogy mély tanulási modelleket tanít az Amazon EFS-ben már tárolt adatokból. Ennek a választásnak az az előnye, hogy közvetlenül elindítja a képzési feladatokat az Amazon EFS-ben tárolt adatokból, adatmozgatás nélkül, ami gyorsabb edzéskezdési időt eredményez.

Létrehozunk egy EFS-kötetet, és telepítjük az EFS Container Storage Interface (CSI) illesztőprogramot. Ezt a ben található telepítési parancsfájl hajtja végre /eks/deployment/csi/efs belül aws-do-eks tartály.

Ez a szkript feltételezi, hogy fiókjában egy EKS-fürt található. Készlet CLUSTER_NAME= abban az esetben, ha egynél több EKS-klasztere van.

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

Ez a parancsfájl EFS-kötetet biztosít, és csatlakoztatási célokat hoz létre a fürt VPC alhálózataihoz. Ezután telepíti az EFS CSI illesztőprogramot, és létrehozza a efs-sc tárolási osztály és efs-pv állandó mennyiség az EKS-fürtben.

A szkript sikeres befejezése után a következő kimenetet kell látnia:

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

Hozzon létre egy Amazon S3 VPC végpontot

Olyan privát VPC-t használ, amelyhez a SageMaker képzési munkája és az EFS fájlrendszere hozzáfér. Ahhoz, hogy a SageMaker képzési fürt hozzáférést biztosítson a privát VPC-ből származó S3-gyűjtőkhöz, hozzon létre egy VPC-végpontot:

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

Most kiléphet a aws-do-eks konténerhéjat, és folytassa a következő szakaszsal:

exit

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

1.2 A Kubeflow üzembe helyezése AWS-en az Amazon EKS rendszeren

A Kubeflow Amazon EKS rendszeren történő üzembe helyezéséhez a aws-do-kubeflow projekt.

1. A tár klónozása a következő parancsokkal:

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

2. Ezután állítsa be a projektet:

   ./config.sh

   Ez a szkript megnyitja a projekt konfigurációs fájlját egy szövegszerkesztőben. Azért fontos AWS_REGION be kell állítani arra a Régióra, amelyben a fürt található, valamint AWS_CLUSTER_NAME hogy megfeleljen a korábban létrehozott fürt nevének. Alapértelmezés szerint a konfiguráció már megfelelően be van állítva, így ha nem kell változtatásokat végrehajtania, egyszerűen zárja be a szerkesztőt.

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

   A build.sh szkript létrehoz egy Docker-tároló lemezképet, amely rendelkezik minden szükséges eszközzel a Kubeflow telepítéséhez és kezeléséhez egy meglévő Kubernetes-fürtön. Az run.sh script elindít egy tárolót a Docker lemezkép használatával, az exec.sh szkript pedig egy parancshéjat nyit meg a tárolóban, amelyet Kubeflow felügyeleti környezetünkként használhatunk. Használhatja a ./status.sh szkriptet, hogy megnézze, vajon a aws-do-kubeflow konténer működik és működik, és a ./stop.sh és a ./run.sh szkripteket, hogy szükség szerint újraindítsa.

3. Miután megnyílt egy héj a aws-do-eks tárolóban, ellenőrizheti, hogy a konfigurált fürt kontextus megfelel-e az elvárásoknak:

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

4. A Kubeflow EKS-fürtön való üzembe helyezéséhez futtassa a deploy.sh forgatókönyv:

   ./kubeflow-deploy.sh

   A központi telepítés akkor sikeres, ha a kubeflow névtérben lévő összes pod Futó állapotba kerül. Egy tipikus kimenet a következő kódhoz hasonlít:

   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. A KubeFlow podok állapotának egy külön ablakban történő figyeléséhez használhatja a következő parancsot:

   watch kubectl -n kubeflow get pods

6. nyomja meg Ctrl + C amikor az összes pod fut, akkor a következő parancs futtatásával tegye közzé a Kubeflow irányítópultját a fürtön kívül:

   ./kubeflow-expose.sh

A következő kódhoz hasonló kimenetet kell látnia:

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

Ez a parancs port továbbítja az Istio bemeneti átjáró szolgáltatást a fürtről a helyi 8080-as portra. A Kubeflow irányítópult eléréséhez látogasson el a következő oldalra. http://localhost:8080 és jelentkezzen be az alapértelmezett felhasználói hitelesítő adatokkal (felhasznalo@example.com/12341234). Ha futtatod a aws-do-kubeflow tárolót az AWS Cloud9-ben, akkor választhat Preview, majd válassza ki Futó alkalmazás előnézete. Ha a Docker Desktopon fut, előfordulhat, hogy futtatnia kell a ./kubeflow-expose.sh script kívül aws-do-kubeflow tartály.

2. Állítsa be a Kubeflow on AWS környezetet

A Kubeflow on AWS-környezet beállításához létrehozunk egy EFS-kötetet és egy Jupyter-jegyzetfüzetet.

2.1 Hozzon létre egy EFS-kötetet

EFS-kötet létrehozásához hajtsa végre a következő lépéseket:

• A Kubeflow irányítópulton válassza a lehetőséget Kötetek a navigációs ablaktáblában.
• Válaszd Új kötet.
• A Név, belép efs-sc-claim.
• A Kötet mérete, belép 10.
• A Tárolási osztály, választ efs-sc.
• A Hozzáférési mód, választ ReadWriteOnce.
• A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Teremt.

2.2 Hozzon létre egy Jupyter notebookot

Új jegyzetfüzet létrehozásához hajtsa végre a következő lépéseket:

• A Kubeflow irányítópulton válassza a lehetőséget notebookok a navigációs ablaktáblában.
• A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Új notebook.
• A Név, belép aws-hybrid-nb.
• A Jupyter Docket kép, válassza ki a képet c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (a legújabb elérhető jupyter-pytorch DLC-kép).
• A CPU, belép 1.
• A Memory design, belép 5.
• A GPU, hagyja másként Egyik sem.
• Ne változtasson a Munkaterület kötet szakasz.
• A Adatmennyiségek szakaszban válassza Csatolja a meglévő kötetet és bontsa ki a Meglévő kötet részt
• A Név, választ efs-sc-claim.
• A Szerelési ösvény, belép /home/jovyan/efs-sc-claim.
  Ezzel csatlakoztatja az EFS-kötetet a Jupyter notebook podhoz, és láthatja a mappát efs-sc-claim a Jupyter labor felületén. Ebbe a mappába menti a betanítási adatkészletet és a képzési kódot, hogy a képzési fürtök hozzáférhessenek anélkül, hogy újra kellene építeniük a tárolóképeket teszteléshez.
• választ Hozzáférés engedélyezése a Kubeflow-csővezetékekhez a Konfiguráció részben.
• A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Indít.
  Ellenőrizze, hogy a jegyzetfüzet sikeresen létrejött-e (ez eltarthat néhány percig).
• A notebookok oldalon válassza a lehetőséget Csatlakozás hogy bejelentkezzen a JupyterLab környezetbe.
• A megy menüben válasszon Adattár klónozása.
• A Repo klónozása, belép https://github.com/aws-samples/aws-do-kubeflow.
  

3. Futtasson elosztott edzést

A Jupyter notebook beállítása után a teljes demót a következő magas szintű lépések végrehajtásával futtathatja a mappából aws-do-kubeflow/workshop a klónozott adattárban:

• PyTorch Distributed Data Parallel (DDP) képzési szkript: Tekintse meg a PyTorch DDP betanító szkriptet, a cifar10-distributed-gpu-final.py, amely egy minta konvolúciós neurális hálózatot és logikát tartalmaz a több csomópontból álló CPU- és GPU-fürtön való képzés elosztásához. (Részletekért lásd a 3.1-et)
• Könyvtárak telepítése: Futtassa a notebookot 0_initialize_dependencies.ipynb hogy inicializálja az összes függőséget. (Részletekért lásd a 3.2-et)
• Futtasson elosztott PyTorch munkatréninget Kubernetesen: Futtassa a notebookot 1_submit_pytorchdist_k8s.ipynb elosztott képzés létrehozása és elküldése egy elsődleges és két dolgozó tárolón a Kubernetes egyéni erőforrás PyTorchJob YAML fájl használatával Python kóddal. (Részletekért lásd a 3.3-et)
• Hozzon létre egy hibrid Kubeflow-folyamatot: Futtassa a notebookot 2_create_pipeline_k8s_sagemaker.ipynb a hibrid Kubeflow folyamat létrehozása, amely elosztott képzést futtat a SageMaker vagy az Amazon EKS rendszeren a futásidejű változó használatával training_runtime. (Részletekért lásd a 3.4-et)

Győződjön meg róla, hogy futtatta a notebookot 1_submit_pytorchdist_k8s.ipynb mielőtt elindítja a notebookot 2_create_pipeline_k8s_sagemaker.ipynb.

A következő szakaszokban ezeket a lépéseket részletesen tárgyaljuk.

3.1 PyTorch Distributed Data Parallel (DDP) betanító szkript

Az elosztott képzés részeként egy egyszerű konvolúciós neurális hálózat által létrehozott osztályozási modellt tanítunk, amely a CIFAR10 adatkészleten működik. A képzési forgatókönyv cifar10-distributed-gpu-final.py csak a nyílt forráskódú könyvtárakat tartalmazza, és kompatibilis mind a Kubernetes, mind a SageMaker oktatási fürtök futtatásával GPU-eszközökön vagy CPU-példányokon. Nézzük meg a képzési szkript néhány fontos szempontját, mielőtt futtatnánk a notebook példáinkat.

Az általunk használt torch.distributed modul, amely PyTorch támogatást és kommunikációs primitíveket tartalmaz a fürt csomópontjai közötti többfolyamatos párhuzamosság érdekében:

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

Egy egyszerű képosztályozási modellt hozunk létre a konvolúciós, a max pooling és a lineáris rétegek kombinációjával, amelyre egy relu aktiválási függvényt alkalmazunk a modellképzés előrehaladott lépésében:

# 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

A DataLoader fáklyát használjuk, amely egyesíti az adatkészletet és DistributedSampler (elosztott módon betölti az adatok egy részhalmazát a torch.nn.parallel.DistributedDataParallel), és egy- vagy többfolyamatos iterátort biztosít az adatok felett:

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

Ha a betanító fürt GPU-kkal rendelkezik, a szkript a betanítást CUDA-eszközökön futtatja, és az eszközváltozó az alapértelmezett CUDA-eszközt tartalmazza:

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

Mielőtt elosztott képzést futtatna a PyTorch használatával DistributedDataParallel az elosztott feldolgozás több csomóponton történő futtatásához hívással inicializálni kell az elosztott környezetet init_process_group. Ez inicializálva van a képzési fürt minden gépén.

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

Példányosítjuk az osztályozó modellt, és átmásoljuk a modellt a céleszközre. Ha az elosztott betanítás engedélyezve van több csomóponton, akkor a DistributedDataParallel osztályt burkoló objektumként használják a modellobjektum körül, amely lehetővé teszi a szinkron elosztott képzést több gép között. A bemeneti adatok fel vannak osztva a köteg dimenzióra, és a modell másolata minden gépre és eszközre kerül.

model = Net().to(device)

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

...

3.2 Könyvtárak telepítése

Telepíteni kell az összes szükséges könyvtárat a PyTorch elosztott képzési példa futtatásához. Ez magában foglalja a Kubeflow Pipelines SDK-t, a Training Operator Python SDK-t, a Python-klienst a Kuberneteshez és az Amazon SageMaker Python SDK-t.

#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 Futtassa az elosztott PyTorch munkatréningeket Kubernetesen

A jegyzetfüzet 1_submit_pytorchdist_k8s.ipynb létrehozza a Kubernetes egyéni erőforrás PyTorchJob YAML fájlt a Kubeflow képzés és a Kubernetes ügyfél Python SDK segítségével. Az alábbiakban néhány fontos részlet ebből a jegyzetfüzetből.

Létrehozzuk a PyTorchJob YAML-t az elsődleges és a munkavégző konténerekkel, ahogy az a következő kódban látható:

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

Ez elküldésre kerül a Kubernetes vezérlősíkra a használatával PyTorchJobClient:

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

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Tekintse meg a Kubernetes edzésnaplóit

A képzési naplókat megtekintheti ugyanabból a Jupyter-jegyzetfüzetből Python kóddal, vagy a Kubernetes-ügyfélhéjból.

3.4 Hozzon létre egy hibrid Kubeflow-folyamatot

A jegyzetfüzet 2_create_pipeline_k8s_sagemaker.ipynb feltételes futásidejű változón alapuló hibrid Kubeflow-folyamatot hoz létre training_runtime, ahogy az a következő kódban is látható. A notebook a Kubeflow Pipelines SDK és Python-csomagokat biztosít az ML-munkafolyamat-folyamatok meghatározásához és futtatásához. Ennek az SDK-nak a részeként a következő csomagokat használjuk:

• A domain-specifikus nyelvi (DSL) csomagdekorátor dsl.pipeline, amely a Python függvényeket díszíti, hogy visszaadja a folyamatot
• A dsl.Condition csomag, amely olyan műveletek csoportját jelöli, amelyek csak akkor futnak le, ha egy bizonyos feltétel teljesül, például a training_runtime érték as sagemaker or kubernetes

Lásd a következő kódot:

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

A SageMaker elosztott képzést két ml.p3.2xlarge példány használatával konfiguráljuk.

A folyamat definiálása után a folyamatot lefordíthatja egy Argo YAML specifikációra a Kubeflow Pipelines SDK segítségével kfp.compiler csomag. Ezt a folyamatot a Kubeflow Pipeline SDK-ügyféllel futtathatja, amely meghívja a Pipelines szolgáltatás végpontját, és közvetlenül a jegyzetfüzetből továbbítja a megfelelő hitelesítési fejléceket. Lásd a következő kódot:

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

Ha kap egy sagemaker import hiba, futtassa a !pip install sagemaker parancsot, és indítsa újra a kernelt (a mag menüben válasszon Indítsa újra a Kernelt).

Válassza a Futtatás részletei hivatkozást az utolsó cella alatt a Kubeflow folyamat megtekintéséhez.

Ismételje meg a folyamat létrehozásának lépését a következővel: training_runtime='kubernetes' a Kubernetes környezetben futtatott folyamat teszteléséhez. Az training_runtime változó a CI/CD folyamatban is átadható egy éles forgatókönyvben.

Tekintse meg a SageMaker összetevő Kubeflow-folyamat futtatási naplóit

A következő képernyőképen a SageMaker komponens folyamatának részletei láthatók.

Válassza ki a képzési munka lépését, és a Naplók lapon válassza a CloudWatch naplók hivatkozást a SageMaker naplók eléréséhez.

A következő képernyőképen a CloudWatch naplók láthatók mind a két ml.p3.2xlarge példányhoz.

A naplók megtekintéséhez válassza ki bármelyik csoportot.

Tekintse meg a Kubeflow-folyamat futtatási naplóit a Kubeflow PyTorchJob Launcher összetevőhöz

A következő képernyőképen a Kubeflow komponensünk folyamatának részletei láthatók.

segítségével futtassa a következő parancsokat Kubectl a Kubernetes-fürthöz csatlakoztatott Kubernetes-ügyfélhéjon a naplók megtekintéséhez (cserélje ki a névteret és a podneveket):

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

4.1 Tisztítás

A fiókban létrehozott összes erőforrás megtisztításához fordított sorrendben kell eltávolítanunk őket.

1. Futtatással törölje a Kubeflow telepítést ./kubeflow-remove.sh a aws-do-kubeflow tartály. A parancsok első készlete nem kötelező, és akkor használható, ha még nincs parancshéj a gépedben aws-do-kubeflow konténer nyitva.

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

2. Tól aws-do-eks konténer mappát, távolítsa el az EFS-kötetet. A parancsok első készlete nem kötelező, és akkor használható, ha még nincs parancshéj a sajátjában aws-do-eks konténer nyitva.

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

   Az Amazon EFS törlése szükséges a fürtünkhöz létrehozott VPC-vel társított hálózati interfész felszabadításához. Vegye figyelembe, hogy az EFS-kötet törlése megsemmisíti a rajta tárolt adatokat.

3. Tól aws-do-eks konténer, futtassa a eks-delete.sh szkript a fürt és a hozzá kapcsolódó egyéb erőforrások törléséhez, beleértve a VPC-t is:

   cd /eks
   ./eks-delete.sh

Összegzésként

Ebben a bejegyzésben az elosztott modellképzés és az ML munkafolyamatok néhány tipikus kihívását tárgyaltuk. Áttekintést adtunk a Kubeflow-ról az AWS-terjesztésen, és megosztottunk két nyílt forráskódú projektet (aws-do-eks és a aws-do-kubeflow), amelyek leegyszerűsítik az infrastruktúra kiépítését és a Kubeflow telepítését rajta. Végül leírtunk és bemutattunk egy hibrid architektúrát, amely lehetővé teszi a munkaterhelések zökkenőmentes átmenetét az önállóan felügyelt Kubernetes és a teljesen felügyelt SageMaker infrastruktúra között. Javasoljuk, hogy ezt a hibrid architektúrát használja saját felhasználási eseteire.

Követheted a AWS Labs adattár hogy nyomon kövesse az összes AWS-hozzájárulást a Kubeflow-hoz. Megtalálhat minket a Kubeflow #AWS Slack Channel; az Ön visszajelzése segíteni fog nekünk abban, hogy a Kubeflow projekthez hozzájáruló következő funkciókat rangsoroljuk.

Külön köszönet Sree Arasanagattának (AWS ML szoftverfejlesztési menedzser) és Suraj Kotának (szoftverfejlesztő mérnök) a poszt elindításához nyújtott támogatásukért.

A szerzőkről

Kanwaljit Khurmi AI/ML Specialist Solutions Architect az Amazon Web Servicesnél. Együttműködik az AWS termékkel, a mérnökökkel és az ügyfelekkel, hogy útmutatást és technikai segítséget nyújtson, segítve őket hibrid ML megoldásaik értékének növelésében az AWS használata során. A Kanwaljit arra specializálódott, hogy segítse az ügyfeleket konténeres és gépi tanulási alkalmazásokkal.

Gautam Kumar AWS AI Deep Learning szoftvermérnök. Kifejlesztette az AWS Deep Learning Containers és az AWS Deep Learning AMI-t. Szenvedélye az AI eszközök és rendszerek építése. Szabadidejében szeret biciklizni és könyveket olvasni.

Alex Iankoulski egy full-stack szoftver és infrastruktúra építész, aki szeret mélyreható, gyakorlatias munkát végezni. Jelenleg az AWS-nél az önállóan menedzselt gépi tanulás fő megoldási építésze. Munkájában arra összpontosít, hogy segítse az ügyfeleket az ML és AI munkaterhelések konténerezésében és összehangolásában a konténeralapú AWS szolgáltatásokon. Ő a nyílt forráskód szerzője is Készíts keretet és egy Docker kapitány, aki szereti a konténertechnológiák alkalmazását az innováció ütemének felgyorsítására, miközben megoldja a világ legnagyobb kihívásait. Az elmúlt 10 évben Alex az éghajlatváltozás leküzdésén, a mesterséges intelligencia és az ML demokratizálásán, az utazás biztonságosabbá tételén, az egészségügy jobbá tételén és az energiaügyek okosabbá tételén dolgozott.