Aktivering av hybride ML-arbeidsflyter på Amazon EKS og Amazon SageMaker med ett-klikks Kubeflow på AWS-distribusjon

I dag bygger mange AWS-kunder bedriftsklare maskinlæringsplattformer (ML) på Amazon Elastic Kubernetes-tjeneste (Amazon EKS) ved hjelp av Kubeflow på AWS (en AWS-spesifikk distribusjon av Kubeflow) på tvers av mange brukstilfeller, inkludert datasyn, naturlig språkforståelse, taleoversettelse og økonomisk modellering.

Med siste utgivelse av åpen kildekode Kubeflow v1.6.1, fortsetter Kubeflow-fellesskapet å støtte denne storstilte bruken av Kubeflow for bedriftsbruk. Den siste utgivelsen inkluderer mange nye spennende funksjoner som støtte for Kubernetes v1.22, kombinert Python SDK for PyTorch, MXNet, MPI, XGBoost i Kubeflows distribuerte Training Operator, nye ClusterServingRuntime og ServingRuntime CRD-er for modellservice, og mange flere.

AWS-bidrag til Kubeflow med den nylige lanseringen av Kubeflow på AWS 1.6.1 støtter alle oppstrøms åpen kildekode Kubeflow-funksjoner og inkluderer mange nye integrasjoner med de svært optimaliserte, skybaserte, bedriftsklare AWS-tjenestene som vil hjelpe deg å bygge svært pålitelige, sikre, bærbare og skalerbare ML-systemer.

I dette innlegget diskuterer vi nye Kubeflow på AWS v1.6.1-funksjoner og fremhever tre viktige integrasjoner som har blitt samlet på én plattform for å tilby deg::

• Infrastructure as Code (IaaC) ettklikksløsning som automatiserer ende-til-ende-installasjonen av Kubeflow, inkludert oppretting av EKS-klynge
• Støtte til distribuert opplæring på Amazon SageMaker ved hjelp av Amazon SageMaker-operatører for Kubernetes (ACK) og SageMaker-komponenter for Kubeflow-rørledninger og lokalt på Kubernetes ved hjelp av Kubeflow opplæringsoperatører. Mange kunder bruker denne muligheten til å bygge hybride maskinlæringsarkitekturer der de utnytter både Kubernetes-beregning for eksperimenteringsfasen og SageMaker for å kjøre arbeidsbelastninger i produksjonsskala.
• Forbedret overvåking og observerbarhet for ML-arbeidsbelastninger inkludert Amazon EKS, Kubeflow-beregninger og applikasjonslogger ved bruk av Prometheus, Grafana og Amazon CloudWatch integrasjoner

Brukssaken i denne bloggen vil spesifikt fokusere på SageMaker-integrasjon med Kubeflow på AWS som kan legges til dine eksisterende Kubernetes-arbeidsflyter, slik at du kan bygge hybride maskinlæringsarkitekturer.

Kubeflow på AWS

Kubeflow på AWS 1.6.1 gir en klar vei for å bruke Kubeflow, med tillegg av følgende AWS-tjenester i tillegg til eksisterende muligheter:

• SageMaker-integrasjon med Kubeflow for å kjøre hybride ML-arbeidsflyter ved å bruke SageMaker Operators for Kubernetes (ACK) og SageMaker Components for Kubeflow Pipelines.
• Automatiserte distribusjonsalternativer har blitt forbedret og forenklet ved å bruke Kustomize-skript og Helm-diagrammer.
• Lagt til støtte for Infrastructure as Code (IaC) ett-klikks-distribusjon for Kubeflow på AWS ved å bruke Terraform for alt tilgjengelig distribusjonsalternativer. Dette skriptet automatiserer opprettelsen av følgende AWS-ressurser:
• Støtte for AWS PrivateLink for Amazon S3 som gjør det mulig for ikke-kommersielle regionbrukere å koble til sine respektive S3-endepunkter.
• Lagt til integrasjon med Amazon Managed Service for Prometheus (AMP) og Amazon administrerte Grafana å overvåke beregninger med Kubeflow på AWS.
• Oppdaterte Kubeflow bærbare serverbeholdere med de nyeste dyplæringsbeholderbildene basert på TensorFlow 2.10.0 og PyTorch 1.12.1.
• Integrasjon med AWS DLC-er for å kjøre distribuert trening og slutning arbeidsbelastninger.

Følgende arkitekturdiagram er et raskt øyeblikksbilde av alle tjenesteintegrasjonene (inkludert de som allerede er nevnt) som er tilgjengelige for Kubeflow-kontroll- og dataplankomponenter i Kubeflow på AWS. Kubeflow-kontrollplanet er installert på toppen av Amazon EKS, som er en administrert containertjeneste som brukes til å kjøre og skalere Kubernetes-applikasjoner i skyen. Disse AWS-tjenesteintegrasjonene lar deg koble fra kritiske deler av Kubeflow-kontrollplanet fra Kubernetes, og gir en sikker, skalerbar, spenstig og kostnadsoptimalisert design. For mer informasjon om verdien som disse tjenesteintegrasjonene tilfører over åpen kildekode Kubeflow, se Bygg og distribuer et skalerbart maskinlæringssystem på Kubernetes med Kubeflow på AWS.

La oss diskutere mer detaljert hvordan nøkkelfunksjonene i Kubeflow på AWS 1.6.1 kan være nyttige for organisasjonen din.

Kubeflow på AWS-funksjonsdetaljer

Med Kubeflow 1.6.1-utgivelsen prøvde vi å tilby bedre verktøy for ulike typer kunder som gjør det enkelt å komme i gang med Kubeflow uansett hvilke alternativer du velger. Disse verktøyene gir et godt utgangspunkt og kan modifiseres for å passe dine eksakte behov.

Distribusjonsalternativer

Vi tilbyr forskjellige distribusjonsalternativer for forskjellige kundebrukstilfeller. Her får du velge hvilke AWS-tjenester du vil integrere Kubeflow-distribusjonen din med. Hvis du bestemmer deg for å endre distribusjonsalternativer senere, anbefaler vi at du gjør en ny installasjon for den nye distribusjonen. Følgende distribusjonsalternativer er tilgjengelige:

Hvis du vil distribuere Kubeflow med minimale endringer, bør du vurdere vanilje distribusjonsalternativ. Alle tilgjengelige distribusjonsalternativer kan installeres ved hjelp av Kustomize, Helm eller Terraform.

Vi har også forskjellige tilleggsdistribusjoner som kan installeres på toppen av alle disse distribusjonsalternativene:

Installasjonsalternativer

Etter at du har bestemt deg for hvilket distribusjonsalternativ som passer best for dine behov, kan du velge hvordan du vil installere disse distribusjonene. I et forsøk på å betjene både eksperter og nykommere, har vi forskjellige nivåer av automatisering og konfigurasjon.

Alternativ 1: Terraform (IaC)

Dette oppretter en EKS-klynge og alle de relaterte AWS-infrastrukturressursene, og distribuerer deretter Kubeflow alt i én kommando ved hjelp av Terraform. Internt bruker dette EKS-tegninger og Helm-diagrammer.

Dette alternativet har følgende fordeler:

• Det gir fleksibilitet til bedrifter å distribuere Amazon EKS og Kubeflow med én kommando uten å måtte bekymre seg for spesifikke Kubeflow-komponentkonfigurasjoner. Dette vil i stor grad bidra til å fremskynde teknologievaluering, prototyping og produktutviklingens livssyklus, noe som gir fleksibilitet til å bruke terraform-moduler og modifisere den for å møte alle prosjektspesifikke behov.
• Mange organisasjoner i dag som har Terraform som sentrum for sin skystrategi, kan nå bruke Kubeflow på AWS Terraform-løsning for å oppfylle skymålene sine.

Alternativ 2: Tilpass eller rordiagrammer:

Dette alternativet lar deg distribuere Kubeflow i en to-trinns prosess:

1. Lag AWS-ressurser som Amazon EKS, Amazon RDS, Amazon S3 og Amazon Cognito, enten gjennom de automatiserte skriptene som er inkludert i AWS-distribusjonen eller manuelt etter en trinnvis veiledning.
2. Installer Kubeflow-distribusjoner enten ved hjelp av Helm-diagrammer eller Kustomize.

Dette alternativet har følgende fordeler:

• Hovedmålet med dette installasjonsalternativet er å gi Kubeflow-relaterte Kubernetes-konfigurasjoner. Derfor kan du velge å opprette eller ta inn eksisterende EKS-klynger eller noen av de relaterte AWS-ressursene som Amazon RDS, Amazon S3 og Amazon Cognito, og konfigurere og administrere den til å fungere med Kubeflow på AWS.
• Det er lettere å flytte fra et åpen kildekode Kustomize Kubeflow-manifest til AWS Kubeflow-distribusjon.

Følgende diagram illustrerer arkitekturen til begge alternativene.

Integrasjon med SageMaker

SageMaker er en fullstendig administrert tjeneste designet og optimalisert spesielt for å administrere ML-arbeidsflyter. Det fjerner det udifferensierte tunge løftet av infrastrukturadministrasjon og eliminerer behovet for å investere i IT og DevOps for å administrere klynger for ML-modellbygging, opplæring og inferens.

Mange AWS-kunder som har portabilitetskrav eller lokale standardbegrensninger, bruker Amazon EKS for å sette opp repeterbare ML-rørledninger som kjører trenings- og konklusjonsarbeidsbelastninger. Dette krever imidlertid at utviklere skriver tilpasset kode for å optimalisere den underliggende ML-infrastrukturen, gi høy tilgjengelighet og pålitelighet, og overholde passende sikkerhets- og regulatoriske krav. Disse kundene ønsker derfor å bruke SageMaker for kostnadsoptimalisert og administrert infrastruktur for modellopplæring og utplasseringer og fortsette å bruke Kubernetes for orkestrering og ML-pipelines for å beholde standardisering og portabilitet.

For å møte dette behovet lar AWS deg trene, stille inn og distribuere modeller i SageMaker fra Amazon EKS ved å bruke følgende to alternativer:

• Amazon SageMaker ACK Operators for Kubernetes, som er basert på AWS-kontrollere for Kubernetes (ACK) rammeverk. ACK er AWS-strategien som bringer inn standardisering for å bygge Kubernetes-tilpassede kontrollere som lar Kubernetes-brukere klargjøre AWS-ressurser som databaser eller meldingskøer ganske enkelt ved å bruke Kubernetes API. SageMaker ACK-operatører gjør det enklere for ML-utviklere og dataforskere som bruker Kubernetes som sitt kontrollplan å trene, tune og distribuere ML-modeller i SageMaker uten å logge på SageMaker-konsollen.
• De SageMaker-komponenter for Kubeflow-rørledninger, som lar deg integrere SageMaker med portabiliteten og orkestreringen til Kubeflow Pipelines. Med SageMaker-komponentene kjører hver jobb i pipeline-arbeidsflyten på SageMaker i stedet for den lokale Kubernetes-klyngen. Dette lar deg opprette og overvåke native SageMaker-trening, tuning, endepunkt-distribusjon og batch-transformeringsjobber fra Kubeflow Pipelines, og dermed kan du flytte komplette databehandlinger, inkludert databehandling og opplæringsjobber, fra Kubernetes-klyngen til SageMakers maskinlæringsoptimaliserte administrerte tjeneste.

Fra og med Kubeflow på AWS v1.6.1, samler alle de tilgjengelige Kubeflow-distribusjonsalternativene begge Amazon SageMaker-integrasjonsalternativene som standard på én plattform. Det betyr at du nå kan sende inn SageMaker-jobber ved å bruke SageMaker ACK-operatører fra selve Kubeflow Notebook-serveren ved å sende inn den tilpassede SageMaker-ressursen eller fra Kubeflow-pipeline-trinnet ved å bruke SageMaker-komponenter.

Det er to versjoner av SageMaker Components – Boto3 (AWS SDK for AWS SDK for Python) baserte versjon 1-komponenter og SageMaker Operator for K8s (ACK)-baserte versjon 2-komponenter. De nye SageMaker-komponentene versjon 2 støtter siste SageMaker-trenings-api, og vi vil fortsette å legge til flere SageMaker-funksjoner til denne versjonen av komponenten. Du har imidlertid fleksibiliteten til å kombinere Sagemaker-komponenter versjon 2 for opplæring og versjon 1 for andre SageMaker-funksjoner som hyperparameterinnstilling, behandlingsjobber, hosting og mange flere.

Integrasjon med Prometheus og Grafana

Prometheus er et aggregeringsverktøy for åpen kildekode som du kan konfigurere til å kjøre på Kubernetes-klynger. Når du kjører på Kubernetes-klynger, skraper en hoved Prometheus-server med jevne mellomrom pod-endepunkter.

Kubeflow-komponenter, som Kubeflow Pipelines (KFP) og Notebook, sender ut Prometheus-beregninger for å tillate overvåking av komponentressurser, for eksempel antall kjørende eksperimenter eller notebook-antall.

Disse beregningene kan samles av en Prometheus-server som kjører i Kubernetes-klyngen og spørres ved hjelp av Prometheus Query Language (PromQL). For mer informasjon om funksjonene som Prometheus støtter, sjekk ut Prometheus dokumentasjon.

Kubeflow on AWS-distribusjonen gir støtte for integrasjon med følgende AWS-administrerte tjenester:

1. Amazon Managed Prometheus (AMP) som er en Prometheus-kompatibel overvåkingstjeneste for containerinfrastruktur og applikasjonsberegninger for containere som gjør det enkelt for kunder å sikkert overvåke containermiljøer i stor skala. Ved å bruke AMP kan du visualisere, analysere og alarmere dine beregninger, logger og spor som er samlet inn fra flere datakilder i observerbarhetssystemet ditt, inkludert AWS, tredjeparts ISV-er og andre ressurser på tvers av IT-porteføljen din.
2. Amazon Managed Grafana, en fullstendig administrert og sikker datavisualiseringstjeneste basert på åpen kildekode grafana prosjekt, som gjør det mulig for kunder å umiddelbart spørre, korrelere og visualisere operasjonelle beregninger, logger og spor for applikasjonene deres fra flere datakilder. Amazon Managed Grafana avlaster den operative administrasjonen av Grafana ved å automatisk skalere data- og databaseinfrastruktur etter hvert som brukskravene øker, med automatiserte versjonsoppdateringer og sikkerhetsoppdateringer.

Kubeflow on AWS-distribusjonen gir støtte for integrering av Amazon Managed Service for Prometheus og Amazon Managed Grafana for å lette inntak og visualisering av Prometheus-beregninger sikkert i stor skala.

Følgende beregninger tas inn og kan visualiseres:

• Beregninger som sendes ut fra Kubeflow-komponenter som Kubeflow Pipelines og Notebook-serveren
• KubeFlow kontrollplanmålinger

For å konfigurere Amazon Managed Service for Prometheus og Amazon Managed Grafana for din Kubeflow-klynge, se Bruk Prometheus, Amazon Managed Service for Prometheus og Amazon Managed Grafana til å overvåke beregninger med Kubeflow på AWS.

Løsningsoversikt

I dette tilfellet bruker vi Kubeflow vanilla-distribusjonen ved å bruke Terraform-installasjonsalternativet. Når installasjonen er fullført, logger vi på Kubeflow-dashbordet. Fra dashbordet spinner vi opp en Kubeflow Jupyter notebook-server for å bygge en Kubeflow-pipeline som bruker SageMaker til å kjøre distribuert opplæring for en bildeklassifiseringsmodell og et SageMaker-endepunkt for modellimplementering.

Forutsetninger

Sørg for at du oppfyller følgende forutsetninger:

• Du har en AWS-konto.
• Forsikre deg om at du er i us-west-2 Region for å kjøre dette eksemplet.
• Bruk Google Chrome for å samhandle med AWS-administrasjonskonsoll og Kubeflow.
• Sørg for at kontoen din har en SageMaker Training-ressurstypegrense for ml.p3.2xlarge økt til 2 ved å bruke Service Quotas-konsollen.
• Eventuelt kan du bruke AWS Cloud9, et skybasert integrert utviklingsmiljø (IDE) som gjør det mulig å fullføre alt arbeidet fra nettleseren din. For installasjonsinstruksjoner, se Sett opp Cloud9 IDE. Velg Ubuntu Server 18.04 som plattform i AWS Cloud9-innstillingene.Deretter velger du plusstegnet fra AWS Cloud9-miljøet og åpner ny terminal.

Du konfigurerer også en AWS kommandolinjegrensesnitt (AWS CLI) profil. For å gjøre det trenger du en tilgangsnøkkel-ID og en hemmelig tilgangsnøkkel til en AWS identitets- og tilgangsadministrasjon (JEG ER) bruker konto med administrative rettigheter (legg ved den eksisterende administrerte policyen) og programmatisk tilgang. Se følgende kode:

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

Bekreft tillatelsene som cloud9 vil bruke til å kalle AWS-ressurser.

aws sts get-caller-identity

Bekreft fra utgangen nedenfor at du ser arn av admin-brukeren som du har konfigurert i AWS CLI-profilen. I dette eksemplet er det "kubeflow-bruker"

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

Installer Amazon EKS og Kubeflow på AWS

For å installere Amazon EKS og Kubeflow på AWS, fullfør følgende trinn:

1. Sett opp miljøet ditt for å distribuere 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. Distribuer vaniljeversjonen av Kubeflow på AWS og relaterte AWS-ressurser som EKS ved å bruke Terraform. Vær oppmerksom på at EBS-volumer som brukes i EKS nodegruppe ikke er kryptert 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

Sett opp Kubeflow-tillatelsene

1. Legg til tillatelser til Notebook-pod og Pipeline-komponentpod for å foreta SageMaker, S3 og IAM api-anrop ved å bruke 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. Opprett SageMaker-utførelsesrolle for å gjøre det mulig for SageMaker-treningsjobben å få tilgang til opplæringsdatasettet fra S3-tjenesten ved hjelp 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

Få tilgang til Kubeflow-dashbordet

For å få tilgang til Kubeflow-dashbordet, fullfør følgende trinn:

1. Du kan kjøre Kubeflow-dashbordet lokalt i Cloud9-miljøet uten å utsette URL-ene dine for offentlig internett ved å kjøre under kommandoer.

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

2. Velg Forhåndsvisning kjører applikasjon.
3. Velg ikonet i hjørnet av Kubeflow-dashbordet for å åpne det som en egen fane i Chrome.
4. Skriv inn standard legitimasjon (user@example.com/12341234) for å logge på Kubeflow-dashbordet.

Sett opp Kubeflow på AWS-miljøet

Når du er logget på Kubeflow-dashbordet, sørg for at du har riktig navneområde (kubeflow-user-example-com) valgt ut. Fullfør følgende trinn for å konfigurere Kubeflow på AWS-miljøet:

1. Velg på Kubeflow-dashbordet Notatbøker i navigasjonsruten.
2. Velg Ny Notisbok.
3. Til Navn, Tast inn aws-nb.
4. Til Jupyter Docket Image, velg bildet jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (det siste tilgjengelige jupyter-pytorch DLC-bilde).
5. Til prosessor, Tast inn 1.
6. Til Minne, Tast inn 5.
7. Til GPU, la være som none.
8. Ikke gjør noen endringer i Arbeidsområde og Datavolumer seksjoner.
9. Plukke ut Tillat tilgang til Kubeflow Pipelines i konfigurasjoner og velg Start.
10. Bekreft at notatboken er opprettet (det kan ta et par minutter).
11. Velg Koble for å logge på JupyterLab.
12. Klone repoen ved å gå inn https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git i Klone en repo feltet.
13. Velg Clone.

Kjør et distribuert treningseksempel

Etter at du har konfigurert Jupyter-notisboken, kan du kjøre hele demoen ved å bruke følgende trinn på høyt nivå fra mappen eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training i det klonede depotet:

1. Kjør PyTorch Distributed Data Parallel (DDP) opplæringsskript – Se PyTorch DDP-treningsskriptet cifar10-distributed-gpu-final.py, som inkluderer et eksempel på konvolusjonelt nevralt nettverk og logikk for å distribuere trening på en multi-node CPU og GPU-klynge.
2. Opprett en Kubeflow-pipeline – Kjør den bærbare datamaskinen STEP1.0_create_pipeline_k8s_sagemaker.ipynb å lage en pipeline som kjører og distribuerer modeller på SageMaker. Pass på at du installerer SageMaker-biblioteket som en del av den første bærbare cellen og start kjernen på nytt før du kjører resten av cellene i den bærbare datamaskinen.
3. Påkalle et SageMaker-endepunkt – Kjør den bærbare datamaskinen STEP1.1_invoke_sagemaker_endpoint.ipynb for å påkalle og teste SageMaker-modellslutningsendepunktet opprettet i forrige notatbok.

I de påfølgende avsnittene diskuterer vi hvert av disse trinnene i detalj.

Kjør PyTorch DDP-treningsskriptet

Som en del av den distribuerte opplæringen trener vi en klassifiseringsmodell laget av et enkelt konvolusjonelt nevralt nettverk som opererer på CIFAR10-datasettet. Treningsmanuset cifar10-distributed-gpu-final.py inneholder bare åpen kildekode-bibliotekene og er kompatibel for å kjøre både på Kubernetes og SageMaker treningsklynger på enten GPU-enheter eller CPU-forekomster. La oss se på noen viktige aspekter ved opplæringsskriptet før vi kjører notatbokeksemplene våre.

Vi bruker torch.distributed modul, som inneholder PyTorch-støtte og kommunikasjonsprimitiver for multi-prosess parallellitet på tvers av noder i klyngen:

...
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 lager en enkel bildeklassifiseringsmodell ved å bruke en kombinasjon av konvolusjon, maksimal pooling og lineære lag som en relu aktiveringsfunksjonen brukes i foroverpasset til modelltreningen:

# 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

Hvis treningsklyngen har GPUer, kjører skriptet opplæringen på CUDA-enheter og enhetsvariabelen inneholder standard CUDA-enhet:

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

Før du kjører distribuert trening med PyTorch DistributedDataParallel for å kjøre distribuert prosessering på flere noder, må du initialisere det distribuerte miljøet ved å ringe init_process_group. Dette initialiseres på hver maskin i treningsklyngen.

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

Vi instansierer klassifiseringsmodellen og kopierer over modellen til målenheten. Hvis distribuert trening er aktivert for å kjøre på flere noder, vil DistributedDataParallel klasse brukes som et innpakningsobjekt rundt modellobjektet, som tillater synkron distribuert trening på tvers av flere maskiner. Inndataene deles på batchdimensjonen og en kopi av modellen plasseres på hver maskin og hver enhet. Se følgende kode:

model = Net().to(device)

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

...

Opprett en Kubeflow-pipeline

Notatboken bruker Kubeflow Pipelines SDK og det medfølgende settet med Python-pakker for å spesifisere og kjøre ML-arbeidsflytrørledningene. Som en del av denne SDK-en bruker vi pakkedekoratoren for domenespesifikke språk (DSL). dsl.pipeline, som dekorerer Python-funksjonene for å returnere en pipeline.

Kubeflow-rørledningen bruker SageMaker-komponent V2 for å sende opplæring til SageMaker ved å bruke SageMaker ACK-operatører. SageMaker-modelloppretting og modelldistribusjon bruker SageMaker-komponent V1, som er Boto3-baserte SageMaker-komponenter. Vi bruker en kombinasjon av begge komponentene i dette eksemplet for å demonstrere fleksibiliteten du har i valg.

1. Last inn SageMaker-komponentene ved å bruke følgende kode:

   # 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 den følgende koden lager vi Kubeflow-pipeline hvor vi kjører SageMaker distribuert opplæring ved å bruke to ml.p3.2xlarge forekomster:

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

   Etter at rørledningen er definert, kan du kompilere rørledningen til en Argo YAML-spesifikasjon ved å bruke Kubeflow Pipelines SDK-er kfp.compiler pakke. Du kan kjøre denne pipelinen ved å bruke Kubeflow Pipelines SDK-klienten, som kaller opp Pipelines-tjenestens endepunkt og sender inn passende autentiseringshoder rett fra notatboken. Se følgende kode:

   # 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. Velg Kjør detaljer lenke under den siste cellen for å se Kubeflow-rørledningen. Følgende skjermbilde viser pipeline-detaljene våre for SageMaker-trenings- og distribusjonskomponenten.
3. Velg treningsjobbtrinn og på Logger fanen, velg koblingen CloudWatch-logger for å få tilgang til SageMaker-loggene.
   Følgende skjermbilde viser CloudWatch-loggene for hver av de to ml.p3.2xlarge-forekomstene.
4. Velg en av gruppene for å se loggene.
5. Fang SageMaker-endepunktet ved å velge Sagemaker – Utplasseringsmodell trinn og kopiering av endpoint_name utdata artefaktverdi.

Påkalle et SageMaker-endepunkt

Notatboken STEP1.1_invoke_sagemaker_endpoint.ipynb påkaller SageMaker-slutningsendepunktet opprettet i forrige trinn. Sørg for at du oppdaterer endepunktnavnet:

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

Rydd opp

Gjør følgende for å rydde opp i ressursene dine:

1. Kjør følgende kommandoer i AWS Cloud9 for å slette AWS-ressursene:

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

2. Slett IAM-rolle "sagemakerrole" ved å bruke følgende 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. Slett SageMaker-endepunktet ved å bruke følgende AWS CLI-kommando:

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

Oppsummering

I dette innlegget fremhevet vi verdien som Kubeflow på AWS 1.6.1 gir gjennom native AWS-administrerte tjenesteintegrasjoner for å møte behovet for AI- og ML-brukssaker på bedriftsnivå. Du kan velge mellom flere distribusjonsalternativer for å installere Kubeflow på AWS med ulike tjenesteintegrasjoner ved å bruke Terraform, Kustomize eller Helm. Brukssaken i dette innlegget demonstrerte en Kubeflow-integrasjon med SageMaker som bruker en SageMaker-administrert opplæringsklynge for å kjøre distribuert opplæring for en bildeklassifiseringsmodell og SageMaker-endepunkt for modellimplementering.

Vi har også gjort tilgjengelig en eksempel på rørledning som bruker de nyeste SageMaker-komponentene; du kan kjøre dette direkte fra Kubeflow-dashbordet. Denne rørledningen krever Amazon S3-data og SageMaker utførelse IAM-rolle som nødvendige innganger.

For å komme i gang med Kubeflow på AWS, se de tilgjengelige AWS-integrerte distribusjonsalternativene i Kubeflow på AWS. Du kan følge AWS Labs-depot for å spore alle AWS-bidrag til Kubeflow. Du finner oss også på Kubeflow #AWS Slack Channel; tilbakemeldingen din der vil hjelpe oss med å prioritere de neste funksjonene for å bidra til Kubeflow-prosjektet.

Om forfatterne

Kanwaljit Khurmi er senior løsningsarkitekt hos Amazon Web Services. Han samarbeider med AWS-kundene for å gi veiledning og teknisk assistanse som hjelper dem med å forbedre verdien av løsningene deres når de bruker AWS. Kanwaljit spesialiserer seg på å hjelpe kunder med containeriserte og maskinlæringsapplikasjoner.

Kartik Kalamadi er programvareutviklingsingeniør hos Amazon AI. For tiden fokusert på Machine Learning Kubernetes åpen kildekode-prosjekter som Kubeflow og AWS SageMaker Controller for k8s. På fritiden liker jeg å spille PC-spill og fikle med VR ved å bruke Unity-motoren.

Rahul Kharse er programvareutviklingsingeniør hos Amazon Web Services. Arbeidet hans fokuserer på å integrere AWS-tjenester med åpen kildekode containeriserte ML Ops-plattformer for å forbedre deres skalerbarhet, pålitelighet og sikkerhet. I tillegg til å fokusere på kundeforespørsler om funksjoner, liker Rahul også å eksperimentere med den siste teknologiske utviklingen på feltet.