Hibrid ML-munkafolyamatok engedélyezése az Amazon EKS-en és az Amazon SageMaker-en a Kubeflow egy kattintással az AWS-telepítésen

Manapság sok AWS-ügyfél vállalati használatra kész gépi tanulási (ML) platformokat épít rá Amazon Elastic Kubernetes szolgáltatás (Amazon EKS) segítségével Kubeflow az AWS-en (a Kubeflow AWS-specifikus disztribúciója) számos felhasználási esetben, beleértve a számítógépes látást, a természetes nyelv megértését, a beszédfordítást és a pénzügyi modellezést.

Aktivitáskövető a nyílt forráskódú Kubeflow v1.6.1 legújabb kiadása, a Kubeflow közösség továbbra is támogatja a Kubeflow nagyszabású bevezetését vállalati felhasználási esetekre. A legújabb kiadás számos új izgalmas funkciót tartalmaz, mint például a Kubernetes v1.22 támogatása, a Python SDK for PyTorch, MXNet, MPI, XGBoost a Kubeflow elosztott Training Operatorjában, új ClusterServingRuntime és ServingRuntime CRD-k a modellszolgáltatáshoz és még sok más.

Az AWS hozzájárulása a Kubeflow-hoz a Kubeflow AWS 1.6.1-re való közelmúltbeli bevezetésével támogatja az összes upstream nyílt forráskódú Kubeflow funkciót, és számos új integrációt tartalmaz a magasan optimalizált, felhőalapú, vállalati használatra kész AWS-szolgáltatásokkal, amelyek segítségével rendkívül megbízható, biztonságos, hordozható és méretezhető ML rendszerek.

Ebben a bejegyzésben az AWS v1.6.1-es új Kubeflow funkcióit tárgyaljuk, és kiemelünk három fontos integrációt, amelyek egyetlen platformon vannak csomagolva:

• Infrastructure as Code (IaaC) egykattintásos megoldás, amely automatizálja a Kubeflow végpontok közötti telepítését, beleértve az EKS-fürt létrehozását
• Támogatás az elosztott képzéshez Amazon SageMaker segítségével Amazon SageMaker operátorok a Kubernetes számára (ACK) és SageMaker komponensek Kubeflow csővezetékekhez és helyileg Kubernetes használatával Kubeflow képzési operátorok. Sok ügyfél használja ezt a képességet hibrid gépi tanulási architektúrák felépítésére, ahol a Kubernetes számítást a kísérleti fázishoz és a SageMakert termelési méretű munkaterhelések futtatásához használja.
• Továbbfejlesztett felügyelet és megfigyelhetőség az ML munkaterhelésekhez, beleértve az Amazon EKS-t, a Kubeflow-metrikákat és az alkalmazásnaplókat a Prometheus, Grafana és amazonfelhőóra integrációk

Ebben a blogban a használati eset kifejezetten a SageMaker és az AWS Kubeflow integrációjára összpontosít, amely hozzáadható a meglévő Kubernetes-munkafolyamatokhoz, lehetővé téve hibrid gépi tanulási architektúrák építését.

Kubeflow az AWS-en

A Kubeflow az AWS 1.6.1-ben egyértelmű utat biztosít a Kubeflow használatához, a meglévő képességeken felül a következő AWS-szolgáltatásokkal:

• SageMaker integráció a Kubeflow-val hibrid ML-munkafolyamatok futtatásához SageMaker Operators for Kubernetes (ACK) és SageMaker Components for Kubeflow Pipelines használatával.
• A Kustomize szkriptek és Helm diagramok segítségével továbbfejlesztették és egyszerűsítették az automatikus telepítési lehetőségeket.
• Támogatás hozzáadva az Infrastructure as Code (IaC) egykattintásos telepítéséhez a Kubeflow számára AWS-en a Terraform használatával az összes elérhető telepítési lehetőségek. Ez a szkript automatizálja a következő AWS-erőforrások létrehozását:
• Támogatás AWS PrivateLink az Amazon S3 számára, amely lehetővé teszi a nem kereskedelmi régió felhasználói számára, hogy csatlakozzanak a megfelelő S3-végpontjaikhoz.
• Integráció hozzáadva Amazon által felügyelt szolgáltatás a Prometheus számára (AMP) és Amazon által kezelt Grafana a metrikák figyelésére a Kubeflow segítségével az AWS-en.
• Frissített Kubeflow notebook kiszolgálókonténerek a TensorFlow 2.10.0 és a PyTorch 1.12.1 legújabb mélytanulási tárolóképeivel.
• Integráció AWS DLC-kkel az elosztott futtatáshoz edzés és a következtetés munkaterhelések.

A következő architektúra diagram egy gyors pillanatkép az összes szolgáltatás-integrációról (beleértve a már említetteket is), amelyek elérhetők a Kubeflow vezérléséhez és adatsík-összetevőihez az AWS Kubeflow-ban. A Kubeflow vezérlősík az Amazon EKS tetejére van telepítve, amely egy felügyelt konténerszolgáltatás, amelyet Kubernetes-alkalmazások felhőben történő futtatására és méretezésére használnak. Ezek az AWS-szolgáltatás-integrációk lehetővé teszik a Kubeflow vezérlősík kritikus részeinek leválasztását a Kubernetesről, biztonságos, méretezhető, rugalmas és költségoptimalizált kialakítást biztosítva. Ha további részleteket szeretne megtudni arról, hogy ezek a szolgáltatásintegrációk mekkora értéket adnak a nyílt forráskódú Kubeflow-hoz, tekintse meg a következőt: Építsen és telepítsen méretezhető gépi tanulási rendszert a Kubernetes rendszeren a Kubeflow segítségével az AWS-en.

Beszéljük meg részletesebben, hogy az AWS 1.6.1 Kubeflow kulcsfontosságú funkciói hogyan lehetnek hasznosak a szervezet számára.

A Kubeflow az AWS funkció részletei

A Kubeflow 1.6.1-es kiadásával igyekeztünk jobb eszközöket biztosítani a különféle ügyfelek számára, amelyek megkönnyítik a Kubeflow használatának megkezdését, függetlenül attól, hogy melyik opciót választja. Ezek az eszközök jó kiindulópontot adnak, és az Ön igényei szerint módosíthatók.

Telepítési lehetőségek

Különböző telepítési lehetőségeket biztosítunk a különböző ügyfélhasználati esetekhez. Itt kiválaszthatja, hogy mely AWS-szolgáltatásokkal kívánja integrálni a Kubeflow-telepítést. Ha úgy dönt, hogy később módosítja a központi telepítési beállításokat, javasoljuk, hogy az új központi telepítéshez végezzen új telepítést. A következő telepítési lehetőségek állnak rendelkezésre:

Ha minimális változtatásokkal szeretné telepíteni a Kubeflow-t, fontolja meg a vanília telepítési lehetőség. Az összes elérhető telepítési lehetőség a Kustomize, a Helm vagy a Terraform segítségével telepíthető.

Különféle bővítmény-telepítésekkel is rendelkezünk, amelyek az alábbi telepítési lehetőségek bármelyikére telepíthetők:

Telepítési lehetőségek

Miután eldöntötte, hogy melyik telepítési lehetőség felel meg leginkább az igényeinek, kiválaszthatja, hogyan szeretné telepíteni ezeket a központi telepítéseket. Annak érdekében, hogy a szakértőket és az újoncokat egyaránt kiszolgáljuk, az automatizálás és a konfiguráció különböző szintjei vannak.

1. lehetőség: Terraform (IaC)

Ez létrehoz egy EKS-fürtöt és az összes kapcsolódó AWS-infrastruktúra-erőforrást, majd a Kubeflow-t egy parancsban telepíti a Terraform segítségével. Belsőleg ez EKS tervrajzokat és Helm diagramokat használ.

Ennek az opciónak a következő előnyei vannak:

• Rugalmasságot biztosít a vállalatok számára, hogy egyetlen paranccsal üzembe helyezzék az Amazon EKS-t és a Kubeflow-t anélkül, hogy a Kubeflow egyes összetevőinek konfigurációi miatt kellene aggódniuk. Ez nagymértékben segít felgyorsítani a technológiaértékelést, a prototípus-készítést és a termékfejlesztési életciklust, rugalmasságot biztosítva a terraform modulok használatához és a projektspecifikus igényeknek megfelelő módosításokhoz.
• Manapság sok olyan szervezet, amelynek felhőstratégiájának középpontjában a Terraform áll, már használhatja a Kubeflowt az AWS Terraform megoldáson felhőcéljainak eléréséhez.

2. lehetőség: Kustomize vagy Helm Charts:

Ez a beállítás lehetővé teszi a Kubeflow telepítését kétlépéses folyamatban:

1. Hozzon létre AWS-erőforrásokat, például az Amazon EKS-t, az Amazon RDS-t, az Amazon S3-at és az Amazon Cognito-t, akár az AWS-terjesztésben található automatizált szkriptekkel, akár manuálisan egy Lépésről lépésre útmutató.
2. Telepítse a Kubeflow-telepítéseket Helm diagramok vagy Kustomize segítségével.

Ennek az opciónak a következő előnyei vannak:

• Ennek a telepítési lehetőségnek a fő célja a Kubeflow-hoz kapcsolódó Kubernetes konfigurációk biztosítása. Ezért dönthet úgy, hogy létrehoz vagy behozza a meglévő EKS-fürtöket vagy bármely kapcsolódó AWS-erőforrást, például az Amazon RDS-t, az Amazon S3-at és az Amazon Cognito-t, és beállíthatja és kezelheti, hogy az AWS-en működő Kubeflow-val működjön.
• Könnyebb áttérni a nyílt forráskódú Kustomize Kubeflow-jegyzékfájlról az AWS Kubeflow-terjesztésre.

Az alábbi diagram mindkét opció architektúráját szemlélteti.

Integráció a SageMakerrel

A SageMaker egy teljesen felügyelt szolgáltatás, amelyet kifejezetten az ML munkafolyamatok kezelésére terveztek és optimalizáltak. Megszünteti az infrastruktúra-kezelés differenciálatlan nehézségeit, és szükségtelenné válik az IT-be és a DevOps-ba való befektetés szükségessége az ML-modell-építéshez, -képzéshez és -következtetéshez szükséges fürtök kezeléséhez.

Sok AWS-ügyfél, aki hordozhatósági követelményekkel vagy helyszíni szabványos korlátozásokkal rendelkezik, használja az Amazon EKS-t, hogy megismételhető ML-folyamatokat állítson be, amelyek képzési és következtetési munkaterheléseket futtatnak. Ehhez azonban a fejlesztőknek egyéni kódot kell írniuk az alapul szolgáló ML-infrastruktúra optimalizálása, magas rendelkezésre állás és megbízhatóság biztosítása, valamint a megfelelő biztonsági és szabályozási követelmények betartása érdekében. Ezek az ügyfelek ezért a SageMaker-t szeretnék használni a költségoptimalizált és felügyelt infrastruktúrához a modellképzéshez és -telepítésekhez, és továbbra is a Kubernetes alkalmazást szeretnék használni a hangszereléshez és az ML-folyamatokhoz a szabványosítás és a hordozhatóság megőrzése érdekében.

Ennek az igénynek a kielégítésére az AWS lehetővé teszi modellek betanítását, hangolását és üzembe helyezését a SageMakerben az Amazon EKS-ből a következő két lehetőség használatával:

• Amazon SageMaker ACK operátorok Kuberneteshez, amelyek a AWS vezérlők Kuberneteshez (ACK) keretrendszer. Az ACK az AWS-stratégia, amely szabványosítást biztosít a Kubernetes egyéni vezérlők felépítéséhez, amely lehetővé teszi a Kubernetes-felhasználók számára, hogy AWS-erőforrásokat, például adatbázisokat vagy üzenetsorokat biztosítsanak egyszerűen a Kubernetes API használatával. A SageMaker ACK operátorok megkönnyítik a Kubernetes-et vezérlősíkként használó ML-fejlesztők és adattudósok számára az ML-modellek betanítását, hangolását és üzembe helyezését a SageMakerben anélkül, hogy bejelentkeznének a SageMaker konzolba.
• A SageMaker komponensek Kubeflow csővezetékekhez, amelyek lehetővé teszik a SageMaker integrálását a Kubeflow Pipelines hordozhatóságával és hangszerelésével. A SageMaker összetevőkkel a folyamat minden egyes jobja a SageMakeren fut a helyi Kubernetes-fürt helyett. Ez lehetővé teszi a natív SageMaker-oktatási, hangolási, végpont-telepítési és kötegelt átalakítási feladatok létrehozását és figyelését a Kubeflow-folyamatokból, így lehetővé teszi a teljes számítási feladat áthelyezését, beleértve az adatfeldolgozási és betanítási feladatokat a Kubernetes-fürtből a SageMaker gépi tanulásra optimalizált felügyelt szolgáltatásába.

Az AWS v1.6.1-es Kubeflow-tól kezdve az összes elérhető Kubeflow-telepítési lehetőség alapértelmezés szerint egy platformon egyesíti mindkét Amazon SageMaker integrációs lehetőséget. Ez azt jelenti, hogy most már SageMaker-feladatokat küldhet be SageMaker ACK-operátorok használatával egy Kubeflow Notebook-kiszolgálóról az egyéni SageMaker-erőforrás elküldésével vagy a Kubeflow-folyamat lépéséből a SageMaker-összetevők használatával.

A SageMaker Components két változata létezik – Boto3 (AWS SDK for AWS SDK for Python) 1-es verziójú komponensek és SageMaker Operator for K8s (ACK) alapú 2-es verziójú összetevők. Az új SageMaker összetevők 2-es verziója támogatja a SageMaker legújabb képzési programját, és továbbra is további SageMaker funkciókat adunk az összetevő ezen verziójához. Ugyanakkor rugalmasan kombinálhatja a Sagemaker 2-es verzióját a képzéshez és az 1-es verziót más SageMaker-funkciókhoz, mint például a hiperparaméter-hangolás, a feldolgozási feladatok, a hosting és még sok más.

Integráció a Prometheusszal és a Grafanával

A Prometheus egy nyílt forráskódú mérőszám-összesítő eszköz, amelyet beállíthat a Kubernetes-fürtökön való futtatásra. Ha Kubernetes-fürtökön fut, a fő Prometheus-kiszolgáló rendszeresen lekaparja a pod-végpontokat.

A Kubeflow-összetevők, mint például a Kubeflow Pipelines (KFP) és a Notebook, Prometheus-metrikákat bocsátanak ki, amelyek lehetővé teszik az összetevő-erőforrások, például a futó kísérletek vagy a notebookok számának figyelését.

Ezeket a mutatókat a Kubernetes-fürtben futó Prometheus-kiszolgáló összesítheti, és a Prometheus Query Language (PromQL) segítségével lekérdezheti. A Prometheus által támogatott szolgáltatásokkal kapcsolatos további részletekért tekintse meg a Prometheus dokumentáció.

A Kubeflow on AWS disztribúciója támogatja a következő AWS által felügyelt szolgáltatásokkal való integrációt:

1. Amazon Managed Prometheus (AMP), azaz a Prométheusz- kompatibilis felügyeleti szolgáltatás a konténer-infrastruktúrához és a konténerek alkalmazási mérőszámaihoz, amely megkönnyíti az ügyfelek számára a konténerkörnyezetek biztonságos, nagy léptékű figyelését. Az AMP segítségével megjelenítheti, elemezheti és riaszthatja a megfigyelési rendszerében található több adatforrásból gyűjtött metrikákat, naplókat és nyomkövetéseket, beleértve az AWS-t, a harmadik féltől származó ISV-ket és egyéb erőforrásokat az IT-portfóliójában.
2. Az Amazon Managed Grafana egy teljesen felügyelt és biztonságos adatvizualizációs szolgáltatás, amely nyílt forráskódon alapul grafana projekt, amely lehetővé teszi az ügyfelek számára, hogy több adatforrásból azonnal lekérdezzenek, korreláljanak és megjelenítsék alkalmazásaik működési mérőszámait, naplóit és nyomkövetéseit. Az Amazon Managed Grafana tehermentesíti a Grafana működési felügyeletét azáltal, hogy a használati igények növekedésével automatikusan méretezi a számítási és adatbázis-infrastruktúrát, automatizált verziófrissítésekkel és biztonsági javításokkal.

A Kubeflow on AWS disztribúciója támogatja az Amazon Managed Service for Prometheus és az Amazon Managed Grafana integrációját, hogy megkönnyítse a Prometheus metrikák biztonságos, nagy léptékű bevitelét és megjelenítését.

A következő mutatók bekerülnek, és megjeleníthetők:

• A Kubeflow-összetevők, például a Kubeflow-folyamatok és a Notebook-kiszolgáló által kibocsátott metrikák
• KubeFlow vezérlősík-metrikák

Az Amazon Managed Service for Prometheus és az Amazon Managed Grafana konfigurálásához a Kubeflow-fürthöz, tekintse meg a következőt: A Prometheus, az Amazon Managed Service for Prometheus és az Amazon Managed Grafana használatával figyelheti a mutatókat a Kubeflow segítségével az AWS-en.

Megoldás áttekintése

Ebben a használati esetben a Kubeflow vanilla telepítését használjuk a Terraform telepítési opcióval. Amikor a telepítés befejeződött, bejelentkezünk a Kubeflow irányítópultjára. Az irányítópultról felpörgetünk egy Kubeflow Jupyter notebook szervert, hogy létrehozzunk egy Kubeflow folyamatot, amely a SageMaker segítségével elosztott képzést futtat egy képbesorolási modellhez és egy SageMaker végpontot a modell telepítéséhez.

Előfeltételek

Győződjön meg arról, hogy megfelel a következő előfeltételeknek:

• Van egy AWS-fiók.
• Győződjön meg róla, hogy a us-west-2 Régió a példa futtatásához.
• Használja a Google Chrome-ot a AWS felügyeleti konzol és Kubeflow.
• Győződjön meg arról, hogy fiókja rendelkezik a SageMaker Training erőforrástípus-korlátozással az ml.p3.2xlarge esetében 2-re növelve a szolgáltatáskvóták konzoljával.
• 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. Válassza ki az Ubuntu Server 18.04 platformot az AWS Cloud9 beállításainál.Ezután az AWS Cloud9 környezetében válassza ki a pluszjelet, és nyissa meg az új terminált.

Ön is beállít egy AWS parancssori interfész (AWS CLI) profilt. 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

Ellenőrizze, hogy a cloud9 milyen engedélyeket fog használni az AWS-erőforrások hívásához.

aws sts get-caller-identity

Az alábbi kimeneten ellenőrizze, hogy látja-e az AWS CLI-profilban konfigurált adminisztrátor felhasználó arnját. Ebben a példában ez a „kubeflow-user”

{
    "UserId": "*******",
    "Account": "********",
    "Arn": "arn:aws:iam::*******:user/kubeflow-user"
}

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

Az Amazon EKS és a Kubeflow AWS-re történő telepítéséhez hajtsa végre a következő lépéseket:

1. Állítsa be a környezetet a Kubeflow AWS-en való üzembe helyezéséhez:

   #Clone the awslabs/kubeflow-manifests and the kubeflow/manifests repositories and check out the release branches of your choosing
   export KUBEFLOW_RELEASE_VERSION=v1.6.1
   export AWS_RELEASE_VERSION=v1.6.1-aws-b1.0.0
   git clone https://github.com/awslabs/kubeflow-manifests.git && cd kubeflow-manifests
   git checkout ${AWS_RELEASE_VERSION}
   git clone --branch ${KUBEFLOW_RELEASE_VERSION} https://github.com/kubeflow/manifests.git upstream
   
   export MANIFEST_DIR=$PWD

   #Install the necessary tools with the following command:
   make install-tools
   source ~/.bash_profile

2. Telepítse a Kubeflow vanilla verzióját az AWS-re és a kapcsolódó AWS-erőforrásokra, például az EKS-re a Terraform segítségével. Kérjük, vegye figyelembe, hogy az EKS csomópontcsoportban használt EBS-kötetek alapértelmezés szerint nincsenek titkosítva:

   #Define the following environment variables
   
   #Region to create the cluster in
   export CLUSTER_REGION=us-west-2
   #Name of the cluster to create
   export CLUSTER_NAME=

   cd deployments/vanilla/terraform
   
   #Save the variables to a .tfvars file
   cat < sample.auto.tfvars
   cluster_name="${CLUSTER_NAME}"
   cluster_region="${CLUSTER_REGION}"
   EOF
   
   #Run the following one-click command to deploy terraform to install EKS infrastructure and Kubeflow
   make deploy

Állítsa be a Kubeflow engedélyeket

1. Adjon hozzá engedélyeket a Notebook pod és a Pipeline komponens podhoz, hogy SageMaker, S3 és IAM api hívásokat kezdeményezzen kubeflow_iam_permissions.sh szkripteket.

   export NAMESPACE=kubeflow-user-example-com
   
   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/kubeflow_iam_permissions.sh
   chmod +x kubeflow_iam_permissions.sh
   ./kubeflow_iam_permissions.sh $NAMESPACE $CLUSTER_NAME $CLUSTER_REGION

2. Hozzon létre SageMaker végrehajtási szerepet, hogy lehetővé tegye a SageMaker képzési feladat számára, hogy hozzáférjen a képzési adatkészlethez az S3 szolgáltatásból sagemaker_role.sh szkripteket.

   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/sagemaker_role.sh
   chmod +x sagemaker_role.sh
   ./sagemaker_role.sh

Hozzáférés a Kubeflow irányítópultjához

A Kubeflow irányítópultjának eléréséhez hajtsa végre a következő lépéseket:

1. A Kubeflow irányítópultot helyileg futtathatja Cloud9 környezetben anélkül, hogy az alábbi parancsok futtatásával kitenné az URL-címeket a nyilvános internetre.

   # Configure Kubecontext
   $(terraform output -raw configure_kubectl)
   
   cd ${MANIFEST_DIR}
   make port-forward

2. 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 Futó alkalmazás előnézete.
3. Válassza a Kubeflow irányítópult sarkában található ikont, hogy külön lapként nyissa meg a Chrome-ban.
4. Adja meg az alapértelmezett hitelesítő adatokat (user@example.com/12341234) a Kubeflow irányítópultjára való bejelentkezéshez.

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

Miután bejelentkezett a Kubeflow irányítópultra, győződjön meg arról, hogy a megfelelő névtérrel (kubeflow-user-example-com) választott. Hajtsa végre a következő lépéseket a Kubeflow on AWS környezet beállításához:

1. A Kubeflow irányítópulton válassza a lehetőséget notebookok a navigációs ablaktáblában.
2. 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.
3. A Név, belép aws-nb.
4. A Jupyter Docket kép, válassza ki a képet jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (a legújabb elérhető jupyter-pytorch DLC kép).
5. A CPU, belép 1.
6. A Memory design, belép 5.
7. A GPU, hagyja másként Egyik sem.
8. Ne változtasson a Munkaterület és a Adatmennyiségek szakaszok.
9. választ Hozzáférés engedélyezése a Kubeflow-csővezetékekhez a Konfigurációk szakaszt, és válassza az Indítás lehetőséget.
10. Ellenőrizze, hogy a jegyzetfüzet sikeresen létrejött-e (ez eltarthat néhány percig).
11. 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 Csatlakozás hogy bejelentkezzen a JupyterLabba.
12. Belépéssel klónozza a repót https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git a Repo klónozása mező.
13. 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 Clone.

Futtasson egy elosztott képzési példát

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 eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training a klónozott adattárban:

1. Futtassa a PyTorch Distributed Data Parallel (DDP) betanító parancsfájlt – Tekintse meg a PyTorch DDP képzési parancsfájlt cifar10-distributed-gpu-final.py, amely egy mintakonvolúciós neurális hálózatot és logikát tartalmaz a képzés elosztásához egy több csomópontból álló CPU- és GPU-fürtön.
2. Hozzon létre egy Kubeflow folyamatot – Futtassa a notebookot STEP1.0_create_pipeline_k8s_sagemaker.ipynb egy folyamat létrehozásához, amely modelleket futtat és telepít a SageMakeren. Ügyeljen arra, hogy a SageMaker könyvtárat az első jegyzetfüzet cellájának részeként telepítse, és indítsa újra a kernelt, mielőtt futtatná a többi jegyzetfüzet cellát.
3. Hívjon meg egy SageMaker végpontot – Futtassa a notebookot STEP1.1_invoke_sagemaker_endpoint.ipynb az előző jegyzetfüzetben létrehozott SageMaker modell következtetési végpont meghívásához és teszteléséhez.

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

Futtassa a PyTorch DDP képzési parancsfájlt

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 konvolúciós, max pooling és lineáris rétegek kombinációjával, amelyekhez a relu aktiváló funkciót alkalmazunk a modellképzés előrehaladási szakaszában:

# 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

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. Lásd a következő kódot:

model = Net().to(device)

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

...

Hozzon létre egy Kubeflow folyamatot

A notebook a Kubeflow Pipelines SDK és Python-csomagjainak készlete az ML-munkafolyamat-folyamatok meghatározásához és futtatásához. Ennek az SDK-nak a részeként a domain-specifikus nyelvi (DSL) csomagdekorátort használjuk dsl.pipeline, amely a Python függvényeket díszíti, hogy visszaadja a folyamatot.

A Kubeflow folyamatfolyamat a SageMaker V2 komponensét használja a képzés SageMakernek történő benyújtásához a SageMaker ACK operátorok használatával. A SageMaker modell létrehozása és üzembe helyezése a SageMaker V1 összetevőt használja, amelyek Boto3-alapú SageMaker összetevők. Ebben a példában a két összetevő kombinációját használjuk, hogy demonstráljuk a választási rugalmasságot.

1. Töltse be a SageMaker összetevőket a következő kóddal:

   # Loads SageMaker training components v2 for Kubeflow pipeline from the URL
   sagemaker_train_ack_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/d4aaa03035f221351ebe72fbd74fcfccaf25bb66/components/aws/sagemaker/TrainingJob/component.yaml')
   
   # Loads SageMaker components v1 for Kubeflow pipeline from the URL
   sagemaker_model_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/model/component.yaml')
   sagemaker_deploy_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/deploy/component.yaml')

   A következő kódban létrehozzuk a Kubeflow folyamatot, ahol a SageMaker elosztott képzést futtatjuk kettővel ml.p3.2xlarge esetek:

   # Create Kubeflow Pipeline using Amazon SageMaker Service
   @dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
   def pytorch_cnn_pipeline(region=target_region,
   train_image=aws_dlc_sagemaker_train_image,
   serving_image=aws_dlc_sagemaker_serving_image,
   learning_rate='0.01',
   pytorch_backend='gloo',
   training_job_name=pytorch_distributed_jobname,
   instance_type='ml.p3.2xlarge',
   instance_count='2',
   network_isolation='False',
   traffic_encryption='False',
   ):
   
   # Step to run training on SageMaker using SageMaker Components V2 for Pipeline.
   training = sagemaker_train_ack_op(
   region=region,
   algorithm_specification=(f'{{ '
   f'"trainingImage": "{train_image}",'
   '"trainingInputMode": "File"'
   f'}}'),
   training_job_name=training_job_name,
   hyper_parameters=(f'{{ '
   f'"backend": "{pytorch_backend}",'
   '"batch-size": "64",'
   '"epochs": "10",'
   f'"lr": "{learning_rate}",'
   '"model-type": "custom",'
   '"sagemaker_container_log_level": "20",'
   '"sagemaker_program": "cifar10-distributed-gpu-final.py",'
   f'"sagemaker_region": "{region}",'
   f'"sagemaker_submit_directory": "{source_s3}"'
   f'}}'),
   resource_config=(f'{{ '
   f'"instanceType": "{instance_type}",'
   f'"instanceCount": {instance_count},'
   '"volumeSizeInGB": 50'
   f'}}'),
   input_data_config=training_input(datasets),
   output_data_config=training_output(bucket_name),
   enable_network_isolation=network_isolation,
   enable_inter_container_traffic_encryption=traffic_encryption,
   role_arn=role,
   stopping_condition={"maxRuntimeInSeconds": 3600}
   )
   
   model_artifact_url = get_s3_model_artifact_op(
   training.outputs["model_artifacts"]
   ).output
   
   # This step creates SageMaker Model which refers to model artifacts and inference script to deserialize the input image
   create_model = sagemaker_model_op(
   region=region,
   model_name=training_job_name,
   image=serving_image,
   model_artifact_url=model_artifact_url,
   network_isolation=network_isolation,
   environment=(f'{{ '
   '"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",'
   '"SAGEMAKER_PROGRAM": "inference.py",'
   f'"SAGEMAKER_REGION": "{region}",'
   f'"SAGEMAKER_SUBMIT_DIRECTORY": "{model_artifact_url}"'
   f'}}'),
   role=role
   )
   
   # This step creates SageMaker Endpoint which will be called to run inference
   prediction = sagemaker_deploy_op(
   region=region,
   model_name_1=create_model.output,
   instance_type_1='ml.c5.xlarge'
   )
   
   #Disable pipeline cache
   training.execution_options.caching_strategy.max_cache_staleness = "P0D"

   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 Pipelines 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="ml_workflow")
   
   # 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.

2. Válassza a Futtatás részletei hivatkozást az utolsó cella alatt a Kubeflow folyamat megtekintéséhez. A következő képernyőképen láthatók a SageMaker képzési és üzembe helyezési összetevőjének folyamatai.
3. 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.
4. A naplók megtekintéséhez válassza ki bármelyik csoportot.
5. Rögzítse a SageMaker végpontot a lehetőség kiválasztásával Sagemaker – Modell telepítése lépést és másolja a endpoint_name kimeneti műtermék értéke.

Hívjon meg egy SageMaker végpontot

A jegyzetfüzet STEP1.1_invoke_sagemaker_endpoint.ipynb meghívja az előző lépésben létrehozott SageMaker következtetési végpontot. Győződjön meg róla, hogy frissítette a végpont nevét:

# Invoke SageMaker Endpoint. * Ensure you update the endpoint
# You can grab the SageMaker Endpoint name by either 1) going to the pipeline visualization of Kubeflow console and click the component for deployment, or 2) Go to SageMaker console and go to the list of endpoints, and then substitute the name to the EndpointName='...' in this cell.

endpointName=''

response = client.invoke_endpoint(EndpointName=endpointName,
ContentType='application/x-image',
Body=payload)

pred = json.loads(response['Body'].read().decode())

output_vector_list=pred['score']

# Get outout vector of 10 classes
output_vector = output_vector_list[0]

# Find the class with highest probability
max=output_vector[0]
index = 0
for i in range(1,len(output_vector)):
if output_vector[i] > max:
max = output_vector[i]
index = i

print(f'Index of the maximum value is : {index}')

labels = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

print(labels[index])

Tisztítsuk meg

Az erőforrások megtisztításához hajtsa végre a következő lépéseket:

1. Futtassa a következő parancsokat az AWS Cloud9-ben az AWS-erőforrások törléséhez:

   cd ${MANIFEST_DIR}/deployments/vanilla/terraform
   make delete

2. IAM szerepkör törlése "sagemakerrole” a következő AWS CLI paranccsal:

   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   aws iam delete-role --role-name sagemakerrole

3. Törölje a SageMaker végpontot a következő AWS CLI paranccsal:

   aws sagemaker delete-endpoint --endpoint-name  --region us-west-2

Összegzésként

Ebben a bejegyzésben kiemeltük azt az értéket, amelyet a Kubeflow az AWS 1.6.1-en a natív AWS által felügyelt szolgáltatásintegrációkon keresztül biztosít a vállalati szintű AI és ML használati esetek szükségleteinek kielégítése érdekében. Számos üzembe helyezési lehetőség közül választhat a Kubeflow AWS-re történő telepítéséhez, különféle szolgáltatás-integrációkkal a Terraform, a Kustomize vagy a Helm használatával. Az ebben a bejegyzésben szereplő használati eset egy Kubeflow-integrációt mutatott be a SageMakerrel, amely egy SageMaker által felügyelt képzési fürtöt használ a képosztályozási modell elosztott képzésének futtatásához, a SageMaker-végpont pedig a modell üzembe helyezéséhez.

Elérhetővé tettük továbbá a minta csővezeték példa amely a legújabb SageMaker komponenseket használja; ezt közvetlenül a Kubeflow irányítópultjáról futtathatja. Ez a csővezeték megköveteli a Amazon S3 adatok és a SageMaker végrehajtási IAM szerepkör mint a szükséges bemenetek.

A Kubeflow AWS-en való használatának megkezdéséhez tekintse meg a rendelkezésre álló AWS-be integrált központi telepítési lehetőségeket Kubeflow az AWS-en. Követheti 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.

A szerzőkről

Kanwaljit Khurmi az Amazon Web Services vezető megoldási építésze. Együttműködik az AWS-ügyfelekkel, hogy útmutatást és technikai segítséget nyújtson, segítve őket 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.

Kartik Kalamadi az Amazon AI szoftverfejlesztő mérnöke. Jelenleg a Machine Learning Kubernetes nyílt forráskódú projektekre összpontosít, mint például a Kubeflow és az AWS SageMaker Controller for k8s. Szabadidőmben szeretek PC-s játékokkal játszani, és a VR-el babrálni a Unity motor segítségével.

Rahul Kharse az Amazon Web Services szoftverfejlesztő mérnöke. Munkája az AWS-szolgáltatások nyílt forráskódú, konténeres ML Ops platformokkal való integrálására összpontosít, hogy javítsa azok méretezhetőségét, megbízhatóságát és biztonságát. Amellett, hogy az ügyfelek szolgáltatások iránti igényére összpontosít, Rahul szívesen kísérletezik a terület legújabb technológiai fejlesztéseivel.