Aktivera hybrid ML-arbetsflöden på Amazon EKS och Amazon SageMaker med ett klick Kubeflow på AWS-distribution

Idag bygger många AWS-kunder företagsförberedda maskininlärningsplattformar (ML) på Amazon Elastic Kubernetes-tjänst (Amazon EKS) med hjälp av Kubeflow på AWS (en AWS-specifik distribution av Kubeflow) över många användningsfall, inklusive datorseende, förståelse av naturligt språk, talöversättning och finansiell modellering.

Med senaste versionen av öppen källkod Kubeflow v1.6.1, fortsätter Kubeflow-communityt att stödja denna storskaliga användning av Kubeflow för företagsanvändning. Den senaste utgåvan innehåller många nya spännande funktioner som stöd för Kubernetes v1.22, kombinerad Python SDK för PyTorch, MXNet, MPI, XGBoost i Kubeflows distribuerade Training Operator, nya ClusterServingRuntime och ServingRuntime CRD:er för modellservice och många fler.

AWS-bidrag till Kubeflow med den senaste lanseringen av Kubeflow på AWS 1.6.1 stöder alla uppströms Kubeflow-funktioner med öppen källkod och inkluderar många nya integrationer med de mycket optimerade, molnbaserade, företagsklara AWS-tjänsterna som hjälper dig att bygga mycket tillförlitliga, säkra, bärbara och skalbara ML-system.

I det här inlägget diskuterar vi nya Kubeflow på AWS v1.6.1-funktioner och lyfter fram tre viktiga integrationer som har samlats på en plattform för att erbjuda dig::

• Infrastructure as Code (IaaC) ettklickslösning som automatiserar end-to-end-installationen av Kubeflow, inklusive EKS-klusterskapande
• Stöd för distribuerad utbildning på Amazon SageMaker med hjälp av Amazon SageMaker-operatörer för Kubernetes (ACK) och SageMaker komponenter för Kubeflow pipelines och lokalt på Kubernetes med hjälp av Kubeflow utbildningsoperatörer. Många kunder använder denna förmåga för att bygga hybrida maskininlärningsarkitekturer där de utnyttjar både Kubernetes beräkning för experimentfas och SageMaker för att köra arbetsbelastningar i produktionsskala.
• Förbättrad övervakning och observerbarhet för ML-arbetsbelastningar inklusive Amazon EKS, Kubeflow-statistik och applikationsloggar med hjälp av Prometheus, Grafana och amazoncloudwatch integrationer

Användningsfallet i den här bloggen kommer specifikt att fokusera på SageMaker-integrering med Kubeflow på AWS som kan läggas till dina befintliga Kubernetes-arbetsflöden så att du kan bygga hybrida maskininlärningsarkitekturer.

Kubeflow på AWS

Kubeflow på AWS 1.6.1 ger en tydlig väg att använda Kubeflow, med tillägg av följande AWS-tjänster utöver befintliga funktioner:

• SageMaker Integration med Kubeflow för att köra hybrid ML-arbetsflöden med SageMaker Operators for Kubernetes (ACK) och SageMaker Components for Kubeflow Pipelines.
• Automatiska distributionsalternativ har förbättrats och förenklats med hjälp av Kustomize-skript och Helm-diagram.
• Lade till stöd för Infrastructure as Code (IaC) ett-klicks-distribution för Kubeflow på AWS med Terraform för alla tillgängliga distributionsalternativ. Detta skript automatiserar skapandet av följande AWS-resurser:
• Stöd för AWS PrivateLink för Amazon S3 som gör det möjligt för icke-kommersiella regionanvändare att ansluta till sina respektive S3-slutpunkter.
• Lade till integration med Amazon Managed Service för Prometheus (AMP) och Amazon Managed Grafana för att övervaka mätvärden med Kubeflow på AWS.
• Uppdaterade Kubeflow notebook-serverbehållare med de senaste deep learning container-bilderna baserade på TensorFlow 2.10.0 och PyTorch 1.12.1.
• Integration med AWS DLC för att köras distribuerat utbildning och slutledning arbetsbelastningar.

Följande arkitekturdiagram är en snabb ögonblicksbild av alla tjänsteintegrationer (inklusive de som redan nämnts) som är tillgängliga för Kubeflow-kontroll- och dataplanskomponenter i Kubeflow på AWS. Kubeflow-kontrollplanet är installerat ovanpå Amazon EKS, som är en hanterad containertjänst som används för att köra och skala Kubernetes-applikationer i molnet. Dessa AWS-tjänstintegrationer låter dig koppla bort kritiska delar av Kubeflow-kontrollplanet från Kubernetes, vilket ger en säker, skalbar, motståndskraftig och kostnadsoptimerad design. För mer information om värdet som dessa tjänsteintegrationer tillför över Kubeflow med öppen källkod, se Bygg och distribuera ett skalbart maskininlärningssystem på Kubernetes med Kubeflow på AWS.

Låt oss diskutera mer i detalj om hur nyckelfunktionerna i Kubeflow på AWS 1.6.1 kan vara till hjälp för din organisation.

Kubeflow på AWS-funktionsdetaljer

Med Kubeflow 1.6.1-versionen försökte vi tillhandahålla bättre verktyg för olika typer av kunder som gör det enkelt att komma igång med Kubeflow oavsett vilka alternativ du väljer. Dessa verktyg ger en bra utgångspunkt och kan modifieras för att passa dina exakta behov.

Distributionsalternativ

Vi tillhandahåller olika distributionsalternativ för olika kundanvändningsfall. Här får du välja vilka AWS-tjänster du vill integrera din Kubeflow-distribution med. Om du bestämmer dig för att ändra distributionsalternativ senare, rekommenderar vi att du gör en ny installation för den nya distributionen. Följande distributionsalternativ är tillgängliga:

Om du vill distribuera Kubeflow med minimala ändringar, överväg vanilj distributionsalternativ. Alla tillgängliga distributionsalternativ kan installeras med Kustomize, Helm eller Terraform.

Vi har också olika tilläggsinstallationer som kan installeras ovanpå något av dessa distributionsalternativ:

Installationsalternativ

När du har bestämt dig för vilket distributionsalternativ som passar dina behov bäst kan du välja hur du vill installera dessa distributioner. I ett försök att tjäna både experter och nykomlingar har vi olika nivåer av automatisering och konfiguration.

Alternativ 1: Terraform (IaC)

Detta skapar ett EKS-kluster och alla relaterade AWS-infrastrukturresurser och distribuerar sedan Kubeflow allt i ett kommando med Terraform. Internt använder detta EKS-ritningar och Helm-diagram.

Detta alternativ har följande fördelar:

• Det ger företag flexibilitet att distribuera Amazon EKS och Kubeflow med ett kommando utan att behöva oroa sig för specifika Kubeflow-komponentkonfigurationer. Detta kommer oerhört att påskynda teknikutvärdering, prototypframställning och produktutvecklingens livscykel, vilket ger flexibilitet att använda terraform-moduler och modifiera den för att möta alla projektspecifika behov.
• Många organisationer idag som har Terraform som centrum för sin molnstrategi kan nu använda Kubeflow på AWS Terraform-lösning för att uppfylla sina molnmål.

Alternativ 2: Anpassa eller Helm Charts:

Det här alternativet låter dig distribuera Kubeflow i en tvåstegsprocess:

1. Skapa AWS-resurser som Amazon EKS, Amazon RDS, Amazon S3 och Amazon Cognito, antingen genom de automatiserade skript som ingår i AWS-distributionen eller manuellt efter en Steg för steg guide.
2. Installera Kubeflow-distributioner antingen med hjälp av Helm-diagram eller Kustomize.

Detta alternativ har följande fördelar:

• Huvudmålet med detta installationsalternativ är att tillhandahålla Kubeflow-relaterade Kubernetes-konfigurationer. Därför kan du välja att skapa eller ta in befintliga EKS-kluster eller någon av de relaterade AWS-resurserna som Amazon RDS, Amazon S3 och Amazon Cognito, och konfigurera och hantera det för att fungera med Kubeflow på AWS.
• Det är lättare att flytta från ett Kustomize Kubeflow-manifest med öppen källkod till AWS Kubeflow-distribution.

Följande diagram illustrerar arkitekturerna för båda alternativen.

Integration med SageMaker

SageMaker är en helt hanterad tjänst designad och optimerad specifikt för att hantera ML-arbetsflöden. Det tar bort det odifferentierade tunga lyftet av infrastrukturhantering och eliminerar behovet av att investera i IT och DevOps för att hantera kluster för ML-modellbyggnad, utbildning och slutledning.

Många AWS-kunder som har portabilitetskrav eller lokala standardrestriktioner använder Amazon EKS för att sätta upp repeterbara ML-pipelines som kör tränings- och slutledningsarbetsbelastningar. Detta kräver dock att utvecklare skriver anpassad kod för att optimera den underliggande ML-infrastrukturen, tillhandahålla hög tillgänglighet och tillförlitlighet och följa lämpliga säkerhets- och regulatoriska krav. Dessa kunder vill därför använda SageMaker för kostnadsoptimerad och hanterad infrastruktur för modellutbildning och implementeringar och fortsätta använda Kubernetes för orkestrering och ML-pipelines för att behålla standardisering och portabilitet.

För att möta detta behov låter AWS dig träna, ställa in och distribuera modeller i SageMaker från Amazon EKS genom att använda följande två alternativ:

• Amazon SageMaker ACK-operatörer för Kubernetes, som är baserade på AWS-kontroller för Kubernetes (ACK) ram. ACK är AWS-strategin som tar in standardisering för att bygga anpassade Kubernetes-kontroller som tillåter Kubernetes-användare att tillhandahålla AWS-resurser som databaser eller meddelandeköer helt enkelt genom att använda Kubernetes API. SageMaker ACK-operatörer gör det enklare för ML-utvecklare och datavetare som använder Kubernetes som sitt kontrollplan att träna, ställa in och distribuera ML-modeller i SageMaker utan att logga in på SageMaker-konsolen.
• Smakämnen SageMaker-komponenter för Kubeflow Pipelines, som låter dig integrera SageMaker med portabiliteten och orkestreringen av Kubeflow Pipelines. Med SageMaker-komponenterna körs varje jobb i pipeline-arbetsflödet på SageMaker istället för det lokala Kubernetes-klustret. Detta gör att du kan skapa och övervaka inbyggd SageMaker-utbildning, trimning, slutpunktsdistribution och batchtransformeringsjobb från dina Kubeflow Pipelines, vilket gör att du kan flytta komplett beräkning inklusive databearbetning och utbildningsjobb från Kubernetes-klustret till SageMakers maskininlärningsoptimerade hanterade tjänst.

Från och med Kubeflow på AWS v1.6.1, samlar alla tillgängliga Kubeflow-distributionsalternativ som standard båda Amazon SageMaker-integreringsalternativen på en plattform. Det betyder att du nu kan skicka SageMaker-jobb med SageMaker ACK-operatörer från en Kubeflow Notebook-server själv genom att skicka in den anpassade SageMaker-resursen eller från Kubeflow-pipelinesteget med SageMaker-komponenter.

Det finns två versioner av SageMaker Components – Boto3 (AWS SDK för AWS SDK för Python) baserade version 1-komponenter och SageMaker Operator för K8s (ACK)-baserade version 2-komponenter. De nya SageMaker-komponenterna version 2 stöder senaste SageMaker-utbildnings-API och vi kommer att fortsätta att lägga till fler SageMaker-funktioner till den här versionen av komponenten. Du har dock flexibiliteten att kombinera Sagemaker-komponenter version 2 för utbildning och version 1 för andra SageMaker-funktioner som justering av hyperparameter, bearbetningsjobb, hosting och många fler.

Integration med Prometheus och Grafana

Prometheus är ett verktyg för aggregering av statistik med öppen källkod som du kan konfigurera för att köras på Kubernetes-kluster. När den körs på Kubernetes-kluster skrapar en Prometheus-huvudserver med jämna mellanrum podslutpunkter.

Kubeflow-komponenter, som Kubeflow Pipelines (KFP) och Notebook, sänder ut Prometheus-mått för att tillåta övervakning av komponentresurser som antalet pågående experiment eller anteckningsbokens antal.

Dessa mätvärden kan aggregeras av en Prometheus-server som körs i Kubernetes-klustret och frågas med hjälp av Prometheus Query Language (PromQL). För mer information om funktionerna som Prometheus stöder, kolla in Prometheus dokumentation.

Kubeflow on AWS-distributionen ger stöd för integration med följande AWS-hanterade tjänster:

1. Amazon Managed Prometheus (AMP) som är en Prometheus-kompatibel övervakningstjänst för containerinfrastruktur och applikationsmått för containrar som gör det enkelt för kunder att säkert övervaka containermiljöer i stor skala. Med AMP kan du visualisera, analysera och larma på dina mätvärden, loggar och spår som samlats in från flera datakällor i ditt observerbarhetssystem, inklusive AWS, tredjeparts ISV:er och andra resurser i din IT-portfölj.
2. Amazon Managed Grafana, en helt hanterad och säker datavisualiseringstjänst baserad på öppen källkod grafana projekt, som gör det möjligt för kunder att omedelbart fråga, korrelera och visualisera operationella mätvärden, loggar och spår för sina applikationer från flera datakällor. Amazon Managed Grafana avlastar den operativa hanteringen av Grafana genom att automatiskt skala beräknings- och databasinfrastruktur när användningskraven ökar, med automatiserade versionsuppdateringar och säkerhetskorrigeringar.

Kubeflow on AWS-distributionen ger stöd för integrationen av Amazon Managed Service för Prometheus och Amazon Managed Grafana för att underlätta intag och visualisering av Prometheus-mått på ett säkert sätt i stor skala.

Följande mätvärden tas in och kan visualiseras:

• Mätvärden som emitteras från Kubeflow-komponenter som Kubeflow Pipelines och Notebook-servern
• KubeFlow styrplansmått

För att konfigurera Amazon Managed Service för Prometheus och Amazon Managed Grafana för ditt Kubeflow-kluster, se Använd Prometheus, Amazon Managed Service for Prometheus och Amazon Managed Grafana för att övervaka mätvärden med Kubeflow på AWS.

Lösningsöversikt

I det här användningsfallet använder vi Kubeflow vanilla-distributionen med Terraform installationsalternativ. När installationen är klar loggar vi in ​​på Kubeflows instrumentpanel. Från instrumentpanelen snurrar vi upp en Kubeflow Jupyter notebook-server för att bygga en Kubeflow-pipeline som använder SageMaker för att köra distribuerad utbildning för en bildklassificeringsmodell och en SageMaker-slutpunkt för modelldistribution.

Förutsättningar

Se till att du uppfyller följande krav:

• Du har en AWS-konto.
• Se till att du är i us-west-2 Region för att köra det här exemplet.
• Använd Google Chrome för att interagera med AWS Management Console och Kubeflow.
• Se till att ditt konto har en SageMaker Training-resurstypgräns för ml.p3.2xlarge ökad till 2 med hjälp av Service Quotas-konsolen.
• Alternativt kan du använda AWS Cloud9, en molnbaserad integrerad utvecklingsmiljö (IDE) som gör det möjligt att slutföra allt arbete från din webbläsare. För installationsinstruktioner, se Ställ in Cloud9 IDE. Välj Ubuntu Server 18.04 som plattform i AWS Cloud9-inställningarna.Välj sedan plustecknet från din AWS Cloud9-miljö och öppna en ny terminal.

Du konfigurerar också en AWS-kommandoradsgränssnitt (AWS CLI) profil. För att göra det behöver du ett åtkomstnyckel-ID och en hemlig åtkomstnyckel för en AWS identitets- och åtkomsthantering (JAG ÄR) användare konto med administrativa rättigheter (bifoga den befintliga hanterade policyn) och programmatisk åtkomst. Se följande kod:

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

Verifiera behörigheterna som cloud9 kommer att använda för att anropa AWS-resurser.

aws sts get-caller-identity

Verifiera från utgången nedan att du ser arn av administratörsanvändaren som du har konfigurerat i AWS CLI-profilen. I det här exemplet är det "kubeflow-användare"

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

Installera Amazon EKS och Kubeflow på AWS

För att installera Amazon EKS och Kubeflow på AWS, slutför följande steg:

1. Konfigurera din miljö för att distribuera Kubeflow på AWS:

   #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. Distribuera vaniljversionen av Kubeflow på AWS och relaterade AWS-resurser som EKS med Terraform. Observera att EBS-volymer som används i EKS nodgrupp inte är krypterade som standard:

   #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

Ställ in Kubeflow-behörigheterna

1. Lägg till behörigheter till Notebook-pod och Pipeline-komponentpod för att ringa SageMaker, S3 och IAM api-anrop med kubeflow_iam_permissions.sh skript.

   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. Skapa SageMaker exekveringsroll för att göra det möjligt för SageMaker utbildningsjobb att komma åt utbildningsdataset från S3-tjänsten med hjälp av sagemaker_role.sh skript.

   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

Öppna Kubeflow-instrumentpanelen

Följ följande steg för att komma åt Kubeflow-instrumentpanelen:

1. Du kan köra Kubeflow-instrumentpanelen lokalt i Cloud9-miljön utan att exponera dina webbadresser för offentligt internet genom att köra nedanstående kommandon.

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

2. Välja Förhandsgranska program som körs.
3. Välj ikonen i hörnet av Kubeflow-instrumentpanelen för att öppna den som en separat flik i Chrome.
4. Ange standardinloggningsuppgifterna (user@example.com/12341234) för att logga in på Kubeflow-instrumentpanelen.

Konfigurera Kubeflow på AWS-miljön

När du är inloggad på Kubeflow-instrumentpanelen, se till att du har rätt namnutrymme (kubeflow-user-example-com) valt. Slutför följande steg för att konfigurera din Kubeflow på AWS-miljö:

1. Välj på Kubeflow-instrumentpanelen bärbara datorer i navigeringsfönstret.
2. Välja Ny anteckningsbok.
3. För Namn , stiga på aws-nb.
4. För Jupyter Docket Image, välj bilden jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (det senaste tillgängliga jupyter-pytorch DLC-bild).
5. För CPU, stiga på 1.
6. För Minne, stiga på 5.
7. För GPUs, lämna som Ingen.
8. Gör inga ändringar i Arbetsyta och Datavolymer sektioner.
9. Välja Tillåt åtkomst till Kubeflow Pipelines i konfigurationer och välj Starta.
10. Kontrollera att din anteckningsbok har skapats (det kan ta ett par minuter).
11. Välja Kontakta för att logga in på JupyterLab.
12. Klona repet genom att gå in https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git i Klona en repo fält.
13. Välja klon.

Kör ett distribuerat träningsexempel

När du har ställt in Jupyter-anteckningsboken kan du köra hela demon genom att använda följande steg på hög nivå från mappen eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training i det klonade förvaret:

1. Kör PyTorch Distributed Data Parallel (DDP) träningsskript – Se PyTorch DDP-utbildningsskriptet cifar10-distributed-gpu-final.py, som inkluderar ett exempel på ett konvolutionellt neuralt nätverk och logik för att distribuera träning på ett CPU- och GPU-kluster med flera noder.
2. Skapa en Kubeflow-pipeline – Kör anteckningsboken STEP1.0_create_pipeline_k8s_sagemaker.ipynb att skapa en pipeline som kör och distribuerar modeller på SageMaker. Se till att du installerar SageMaker-biblioteket som en del av den första anteckningsboken och starta om kärnan innan du kör resten av anteckningsbokens celler.
3. Anropa en SageMaker-slutpunkt – Kör anteckningsboken STEP1.1_invoke_sagemaker_endpoint.ipynb för att anropa och testa SageMaker-modellslutpunkten som skapades i föregående anteckningsbok.

I de efterföljande avsnitten diskuterar vi vart och ett av dessa steg i detalj.

Kör PyTorch DDP-träningsskriptet

Som en del av den distribuerade utbildningen tränar vi en klassificeringsmodell skapad av ett enkelt konvolutionellt neuralt nätverk som arbetar på CIFAR10-datauppsättningen. Träningsmanuset cifar10-distributed-gpu-final.py innehåller endast biblioteken med öppen källkod och är kompatibel att köra både på Kubernetes och SageMaker träningskluster på antingen GPU-enheter eller CPU-instanser. Låt oss titta på några viktiga aspekter av träningsskriptet innan vi kör våra anteckningsbokexempel.

Vi använder torch.distributed modul, som innehåller PyTorch-stöd och kommunikationsprimitiver för parallellitet i flera processer över noder i klustret:

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

Vi skapar en enkel bildklassificeringsmodell med en kombination av faltning, max pooling och linjära lager till vilka en relu aktiveringsfunktionen tillämpas i framåtpassningen av modellträningen:

# 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

Om träningsklustret har GPU:er kör skriptet träningen på CUDA-enheter och enhetsvariabeln innehåller standard-CUDA-enheten:

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

Innan du kör distribuerad träning med PyTorch DistributedDataParallel för att köra distribuerad bearbetning på flera noder måste du initiera den distribuerade miljön genom att anropa init_process_group. Detta initieras på varje maskin i träningsklustret.

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

Vi instansierar klassificeringsmodellen och kopierar över modellen till målenheten. Om distribuerad träning är aktiverad för att köras på flera noder, DistributedDataParallel klass används som ett omslagsobjekt runt modellobjektet, vilket möjliggör synkron distribuerad träning över flera maskiner. Indata delas upp på batchdimensionen och en kopia av modellen placeras på varje maskin och varje enhet. Se följande kod:

model = Net().to(device)

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

...

Skapa en Kubeflow-pipeline

Anteckningsboken använder Kubeflow Pipelines SDK och dess tillhandahållna uppsättning Python-paket för att specificera och köra pipelines för ML-arbetsflödet. Som en del av denna SDK använder vi paketdekoratorn för domänspecifika språk (DSL). dsl.pipeline, som dekorerar Python-funktionerna för att returnera en pipeline.

Kubeflow-pipelinen använder SageMaker-komponent V2 för att skicka utbildning till SageMaker med SageMaker ACK Operators. SageMaker-modellskapande och modelldistribution använder SageMaker-komponent V1, som är Boto3-baserade SageMaker-komponenter. Vi använder en kombination av båda komponenterna i det här exemplet för att visa vilken flexibilitet du har att välja på.

1. Ladda SageMaker-komponenterna med följande kod:

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

   I följande kod skapar vi Kubeflow pipeline där vi kör SageMaker distribuerad utbildning med hjälp av två ml.p3.2xlarge instanser:

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

   Efter att pipelinen har definierats kan du kompilera pipelinen till en Argo YAML-specifikation med hjälp av Kubeflow Pipelines SDK:s kfp.compiler paket. Du kan köra denna pipeline med hjälp av Kubeflow Pipelines SDK-klienten, som anropar Pipelines-tjänstens slutpunkt och skickar in lämpliga autentiseringsrubriker direkt från anteckningsboken. Se följande kod:

   # 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älj Kör detaljer länk under den sista cellen för att se Kubeflow-pipelinen. Följande skärmdump visar våra pipelinedetaljer för SageMaker-utbildnings- och implementeringskomponenten.
3. Välj träningsjobbet steg och på Loggar fliken, välj länken CloudWatch-loggar för att komma åt SageMaker-loggarna.
   Följande skärmdump visar CloudWatch-loggarna för var och en av de två ml.p3.2xlarge-instanserna.
4. Välj någon av grupperna för att se loggarna.
5. Fånga SageMaker-slutpunkten genom att välja Sagemaker – Implementeringsmodell steg och kopiera endpoint_name utmatningsartefaktvärde.

Anropa en SageMaker-slutpunkt

Anteckningsboken STEP1.1_invoke_sagemaker_endpoint.ipynb anropar SageMaker slutpunkten som skapades i föregående steg. Se till att du uppdaterar ändpunktsnamnet:

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

Städa upp

Gör följande för att städa upp dina resurser:

1. Kör följande kommandon i AWS Cloud9 för att ta bort AWS-resurserna:

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

2. Ta bort IAM-roll "sagemakerrole" med följande AWS CLI-kommando:

   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. Ta bort SageMaker-slutpunkten med följande AWS CLI-kommando:

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

Sammanfattning

I det här inlägget lyfte vi fram värdet som Kubeflow på AWS 1.6.1 ger genom inbyggda AWS-hanterade tjänsteintegrationer för att möta behovet av AI- och ML-användningsfall på företagsnivå. Du kan välja mellan flera distributionsalternativ för att installera Kubeflow på AWS med olika tjänsteintegrationer med Terraform, Kustomize eller Helm. Användningsfallet i det här inlägget visade en Kubeflow-integration med SageMaker som använder ett SageMaker-hanterat träningskluster för att köra distribuerad utbildning för en bildklassificeringsmodell och SageMaker-slutpunkt för modelldistribution.

Vi har också gjort tillgängliga en exempel på pipeline som använder de senaste SageMaker-komponenterna; du kan köra detta direkt från Kubeflow-instrumentpanelen. Denna pipeline kräver Amazon S3-data och SageMaker exekverande IAM-roll som nödvändiga ingångar.

För att komma igång med Kubeflow på AWS, se de tillgängliga AWS-integrerade distributionsalternativen i Kubeflow på AWS. Du kan följa AWS Labs arkiv för att spåra alla AWS-bidrag till Kubeflow. Du hittar oss också på Kubeflow #AWS Slack Channel; din feedback där hjälper oss att prioritera nästa funktioner för att bidra till Kubeflow-projektet.

Om författarna

Kanwaljit Khurmi är Senior Solutions Architect på Amazon Web Services. Han arbetar med AWS-kunderna för att ge vägledning och teknisk assistans som hjälper dem att förbättra värdet av sina lösningar när de använder AWS. Kanwaljit är specialiserat på att hjälpa kunder med container- och maskininlärningsapplikationer.

Kartik Kalamadi är en mjukvaruutvecklingsingenjör på Amazon AI. För närvarande fokuserad på maskininlärning Kubernetes open source-projekt som Kubeflow och AWS SageMaker Controller för k8s. På min fritid gillar jag att spela PC-spel och pilla med VR med Unity-motorn.

Rahul Kharse är en mjukvaruutvecklingsingenjör på Amazon Web Services. Hans arbete fokuserar på att integrera AWS-tjänster med containeriserade ML Ops-plattformar med öppen källkod för att förbättra deras skalbarhet, tillförlitlighet och säkerhet. Förutom att fokusera på kundernas önskemål om funktioner, gillar Rahul också att experimentera med den senaste tekniska utvecklingen inom området.