Aktivering af hybride ML-arbejdsgange på Amazon EKS og Amazon SageMaker med Kubeflow med et enkelt klik på AWS-implementering

I dag bygger mange AWS-kunder enterprise-ready machine learning (ML) platforme på Amazon Elastic Kubernetes Service (Amazon EKS) ved hjælp af Kubeflow på AWS (en AWS-specifik distribution af Kubeflow) på tværs af mange use cases, herunder computersyn, naturlig sprogforståelse, taleoversættelse og økonomisk modellering.

Med seneste udgivelse af open source Kubeflow v1.6.1, fortsætter Kubeflow-fællesskabet med at understøtte denne storstilede anvendelse af Kubeflow til virksomhedsbrug. Den seneste udgivelse indeholder mange nye spændende funktioner som support til Kubernetes v1.22, kombineret Python SDK til PyTorch, MXNet, MPI, XGBoost i Kubeflows distribuerede Training Operator, nye ClusterServingRuntime og ServingRuntime CRD'er til modelservice og mange flere.

AWS-bidrag til Kubeflow med den nylige lancering af Kubeflow på AWS 1.6.1 understøtter alle upstream open source Kubeflow-funktioner og inkluderer mange nye integrationer med de meget optimerede, cloud-native, virksomhedsklare AWS-tjenester, der vil hjælpe dig med at opbygge yderst pålidelige, sikre, bærbare og skalerbare ML-systemer.

I dette indlæg diskuterer vi nye Kubeflow på AWS v1.6.1 funktioner og fremhæver tre vigtige integrationer, der er samlet på én platform for at tilbyde dig::

• Infrastructure as Code (IaaC) et-klik-løsning, der automatiserer end-to-end installationen af ​​Kubeflow, inklusive oprettelse af EKS-klynge
• Støtte til distribueret træning vedr Amazon SageMaker ved brug af Amazon SageMaker-operatører til Kubernetes (ACK) og SageMaker komponenter til Kubeflow rørledninger og lokalt på Kubernetes vha Kubeflow træningsoperatører. Mange kunder bruger denne evne til at bygge hybride maskinlæringsarkitekturer, hvor de udnytter både Kubernetes compute til eksperimenteringsfasen og SageMaker til at køre arbejdsbelastninger i produktionsskala.
• Forbedret overvågning og observerbarhed for ML-arbejdsbelastninger, herunder Amazon EKS, Kubeflow-metrics og applikationslogfiler ved hjælp af Prometheus, Grafana og amazoncloudwatch integrationer

Use casen i denne blog vil specifikt fokusere på SageMaker-integration med Kubeflow på AWS, som kunne føjes til dine eksisterende Kubernetes-arbejdsgange, så du kan bygge hybride maskinlæringsarkitekturer.

Kubeflow på AWS

Kubeflow på AWS 1.6.1 giver en klar vej til at bruge Kubeflow, med tilføjelsen af ​​følgende AWS-tjenester oven i eksisterende muligheder:

• SageMaker Integration med Kubeflow til at køre hybride ML-arbejdsgange ved hjælp af SageMaker Operators for Kubernetes (ACK) og SageMaker Components for Kubeflow Pipelines.
• Automatiske implementeringsmuligheder er blevet forbedret og forenklet ved hjælp af Kustomize-scripts og Helm-diagrammer.
• Tilføjet support til Infrastructure as Code (IaC) et-klik-implementering for Kubeflow på AWS ved hjælp af Terraform for alle de tilgængelige implementeringsmuligheder. Dette script automatiserer oprettelsen af ​​følgende AWS-ressourcer:
• Støtte til AWS PrivateLink til Amazon S3, der gør det muligt for ikke-kommercielle regionsbrugere at oprette forbindelse til deres respektive S3-endepunkter.
• Tilføjet integration med Amazon Managed Service for Prometheus (AMP) og Amazon administrerede Grafana at overvåge metrics med Kubeflow på AWS.
• Opdaterede Kubeflow notebook-servercontainere med de seneste deep learning-containerbilleder baseret på TensorFlow 2.10.0 og PyTorch 1.12.1.
• Integration med AWS DLC'er for at køre distribueret uddannelse , følgeslutning arbejdsbelastninger.

Følgende arkitekturdiagram er et hurtigt øjebliksbillede af alle serviceintegrationer (inklusive dem, der allerede er nævnt), der er tilgængelige for Kubeflow-kontrol- og dataplankomponenter i Kubeflow på AWS. Kubeflow-kontrolplanet er installeret oven på Amazon EKS, som er en administreret containertjeneste, der bruges til at køre og skalere Kubernetes-applikationer i skyen. Disse AWS-tjenesteintegrationer giver dig mulighed for at afkoble kritiske dele af Kubeflow-kontrolplanet fra Kubernetes, hvilket giver et sikkert, skalerbart, modstandsdygtigt og omkostningsoptimeret design. For flere detaljer om den værdi, som disse serviceintegrationer tilføjer over open source Kubeflow, henvises til Byg og implementer et skalerbart maskinlæringssystem på Kubernetes med Kubeflow på AWS.

Lad os diskutere mere detaljeret om, hvordan Kubeflow på AWS 1.6.1-nøglefunktionerne kan være nyttige for din organisation.

Kubeflow på AWS-funktionsdetaljer

Med Kubeflow 1.6.1-udgivelsen forsøgte vi at levere bedre værktøjer til forskellige slags kunder, der gør det nemt at komme i gang med Kubeflow, uanset hvilke muligheder du vælger. Disse værktøjer giver et godt udgangspunkt og kan modificeres, så de passer til netop dine behov.

Distributionsindstillinger

Vi tilbyder forskellige implementeringsmuligheder til forskellige kundetilfælde. Her kan du vælge, hvilke AWS-tjenester du vil integrere din Kubeflow-implementering med. Hvis du beslutter dig for at ændre implementeringsindstillinger senere, anbefaler vi, at du laver en ny installation til den nye implementering. Følgende implementeringsmuligheder er tilgængelige:

Hvis du vil implementere Kubeflow med minimale ændringer, skal du overveje vanilje implementeringsmulighed. Alle tilgængelige implementeringsmuligheder kan installeres ved hjælp af Kustomize, Helm eller Terraform.

Vi har også forskellige tilføjelsesinstallationer, der kan installeres oven på enhver af disse implementeringsmuligheder:

Installationsindstillinger

Når du har besluttet, hvilken implementeringsmulighed der passer bedst til dine behov, kan du vælge, hvordan du vil installere disse implementeringer. I et forsøg på at betjene både eksperter og nytilkomne har vi forskellige niveauer af automatisering og konfiguration.

Mulighed 1: Terraform (IaC)

Dette opretter en EKS-klynge og alle de relaterede AWS-infrastrukturressourcer og implementerer derefter Kubeflow alt i én kommando ved hjælp af Terraform. Internt bruger dette EKS-planer og Helm-diagrammer.

Denne mulighed har følgende fordele:

• Det giver virksomheder fleksibilitet til at implementere Amazon EKS og Kubeflow med én kommando uden at skulle bekymre sig om specifikke Kubeflow-komponentkonfigurationer. Dette vil i høj grad hjælpe med at fremskynde teknologievaluering, prototyping og produktudviklingens livscyklus, hvilket giver fleksibilitet til at bruge terraform-moduler og modificere det for at imødekomme ethvert projektspecifikt behov.
• Mange organisationer i dag, som har Terraform som centrum for deres cloud-strategi, kan nu bruge Kubeflow på AWS Terraform-løsning til at opfylde deres cloud-mål.

Mulighed 2: Tilpasnings- eller Helm-diagrammer:

Denne mulighed giver dig mulighed for at implementere Kubeflow i en to-trins proces:

1. Opret AWS-ressourcer som Amazon EKS, Amazon RDS, Amazon S3 og Amazon Cognito, enten gennem de automatiserede scripts inkluderet i AWS-distributionen eller manuelt efter en trin-for-trin guide.
2. Installer Kubeflow-implementeringer enten ved hjælp af Helm-diagrammer eller Kustomize.

Denne mulighed har følgende fordele:

• Hovedmålet med denne installationsmulighed er at levere Kubeflow-relaterede Kubernetes-konfigurationer. Derfor kan du vælge at oprette eller bringe eksisterende EKS-klynger eller en hvilken som helst af de relaterede AWS-ressourcer som Amazon RDS, Amazon S3 og Amazon Cognito ind og konfigurere og administrere det til at arbejde med Kubeflow på AWS.
• Det er nemmere at flytte fra et open source Kustomize Kubeflow-manifest til AWS Kubeflow-distribution.

Følgende diagram illustrerer arkitekturen af ​​begge muligheder.

Integration med SageMaker

SageMaker er en fuldt administreret tjeneste designet og optimeret specifikt til styring af ML-arbejdsgange. Det fjerner de udifferentierede tunge løft af infrastrukturstyring og eliminerer behovet for at investere i IT og DevOps til at administrere klynger til ML-modelopbygning, træning og inferens.

Mange AWS-kunder, der har mobilitetskrav eller lokale standardrestriktioner, bruger Amazon EKS til at opsætte repeterbare ML-pipelines, der kører trænings- og inferensarbejdsbelastninger. Dette kræver dog, at udviklere skriver tilpasset kode for at optimere den underliggende ML-infrastruktur, levere høj tilgængelighed og pålidelighed og overholde passende sikkerheds- og lovkrav. Disse kunder ønsker derfor at bruge SageMaker til omkostningsoptimeret og administreret infrastruktur til modeltræning og implementeringer og fortsætter med at bruge Kubernetes til orkestrering og ML-pipelines for at bevare standardisering og portabilitet.

For at imødekomme dette behov giver AWS dig mulighed for at træne, tune og implementere modeller i SageMaker fra Amazon EKS ved at bruge følgende to muligheder:

• Amazon SageMaker ACK Operators for Kubernetes, som er baseret på AWS-controllere til Kubernetes (ACK) ramme. ACK er AWS-strategien, der bringer standardisering til bygning af Kubernetes brugerdefinerede controllere, der tillader Kubernetes-brugere at levere AWS-ressourcer som databaser eller meddelelseskøer blot ved at bruge Kubernetes API. SageMaker ACK-operatører gør det nemmere for ML-udviklere og dataforskere, der bruger Kubernetes som deres kontrolplan, at træne, tune og implementere ML-modeller i SageMaker uden at logge ind på SageMaker-konsollen.
• SageMaker-komponenter til Kubeflow-rørledninger, som giver dig mulighed for at integrere SageMaker med portabiliteten og orkestreringen af ​​Kubeflow Pipelines. Med SageMaker-komponenterne kører hvert job i pipeline-workflowet på SageMaker i stedet for den lokale Kubernetes-klynge. Dette giver dig mulighed for at oprette og overvåge indbygget SageMaker-træning, tuning, slutpunktsimplementering og batch-transformationsjob fra dine Kubeflow Pipelines, hvilket giver dig mulighed for at flytte komplet databehandling inklusive databehandling og træningsjob fra Kubernetes-klyngen til SageMakers maskinlæringsoptimerede administrerede service.

Fra og med Kubeflow på AWS v1.6.1 samler alle de tilgængelige Kubeflow-implementeringsmuligheder som standard begge Amazon SageMaker-integrationsmuligheder på én platform. Det betyder, at du nu kan indsende SageMaker-job ved hjælp af SageMaker ACK-operatører fra selve Kubeflow Notebook-serveren ved at indsende den tilpassede SageMaker-ressource eller fra Kubeflow-pipelinetrinet ved hjælp af SageMaker-komponenter.

Der er to versioner af SageMaker Components – Boto3 (AWS SDK for AWS SDK for Python)-baserede version 1-komponenter og SageMaker Operator til K8s (ACK)-baserede version 2-komponenter. De nye SageMaker-komponenter version 2 understøtter den seneste SageMaker-trænings-api, og vi vil fortsætte med at tilføje flere SageMaker-funktioner til denne version af komponenten. Du har dog fleksibiliteten til at kombinere Sagemaker-komponenter version 2 til træning og version 1 til andre SageMaker-funktioner som f.eks. hyperparameterjustering, behandlingsjob, hosting og mange flere.

Integration med Prometheus og Grafana

Prometheus er et open source-metrik-aggregeringsværktøj, som du kan konfigurere til at køre på Kubernetes-klynger. Når den kører på Kubernetes-klynger, skraber en hoved Prometheus-server med jævne mellemrum pod-endepunkter.

Kubeflow-komponenter, såsom Kubeflow Pipelines (KFP) og Notebook, udsender Prometheus-målinger for at tillade overvågning af komponentressourcer såsom antallet af kørende eksperimenter eller notebook-antal.

Disse metrics kan aggregeres af en Prometheus-server, der kører i Kubernetes-klyngen og forespørges ved hjælp af Prometheus Query Language (PromQL). For flere detaljer om de funktioner, som Prometheus understøtter, se Prometheus dokumentation.

Kubeflow på AWS-distributionen giver understøttelse af integrationen med følgende AWS-administrerede tjenester:

1. Amazon Managed Prometheus (AMP), der er en Prometheus-kompatibel overvågningstjeneste for containerinfrastruktur og applikationsmålinger for containere, der gør det nemt for kunderne sikkert at overvåge containermiljøer i stor skala. Ved hjælp af AMP kan du visualisere, analysere og alarmere dine metrics, logfiler og spor indsamlet fra flere datakilder i dit observerbarhedssystem, herunder AWS, tredjeparts ISV'er og andre ressourcer på tværs af din it-portefølje.
2. Amazon Managed Grafana, en fuldt administreret og sikker datavisualiseringstjeneste baseret på open source grafana projekt, der sætter kunder i stand til øjeblikkeligt at forespørge, korrelere og visualisere operationelle målinger, logfiler og spor for deres applikationer fra flere datakilder. Amazon Managed Grafana aflaster den operationelle administration af Grafana ved automatisk at skalere computer- og databaseinfrastruktur, efterhånden som brugskravene stiger, med automatiserede versionsopdateringer og sikkerhedsrettelser.

Kubeflow på AWS-distributionen giver understøttelse af integrationen af ​​Amazon Managed Service for Prometheus og Amazon Managed Grafana for at lette indtagelse og visualisering af Prometheus-metrikker sikkert i skala.

Følgende metrics indtages og kan visualiseres:

• Metrics udsendt fra Kubeflow-komponenter såsom Kubeflow Pipelines og Notebook-serveren
• KubeFlow kontrolplanmålinger

For at konfigurere Amazon Managed Service til Prometheus og Amazon Managed Grafana til din Kubeflow-klynge, se Brug Prometheus, Amazon Managed Service for Prometheus og Amazon Managed Grafana til at overvåge metrics med Kubeflow på AWS.

Løsningsoversigt

I dette tilfælde bruger vi Kubeflow vanilla-implementeringen ved hjælp af Terraform-installationsmuligheden. Når installationen er færdig, logger vi ind på Kubeflow-dashboardet. Fra dashboardet spinder vi en Kubeflow Jupyter notebook-server op for at bygge en Kubeflow-pipeline, der bruger SageMaker til at køre distribueret træning til en billedklassificeringsmodel og et SageMaker-slutpunkt til modelimplementering.

Forudsætninger

Sørg for, at du opfylder følgende forudsætninger:

• Du har en AWS-konto.
• Sørg for, at du er i us-west-2 Region for at køre dette eksempel.
• Brug Google Chrome til at interagere med AWS Management Console og Kubeflow.
• Sørg for, at din konto har en SageMaker Training-ressourcetypegrænse for ml.p3.2xlarge øget til 2 ved hjælp af Service Quotas-konsollen.
• Eventuelt kan du bruge AWS Cloud9, et cloud-baseret integreret udviklingsmiljø (IDE), der gør det muligt at fuldføre alt arbejdet fra din webbrowser. For opsætningsinstruktioner, se Opsæt Cloud9 IDE. Vælg Ubuntu Server 18.04 som platform i AWS Cloud9-indstillingerne.Vælg derefter plustegnet fra dit AWS Cloud9-miljø, og åbn en ny terminal.

Du konfigurerer også en AWS kommandolinjegrænseflade (AWS CLI) profil. For at gøre det skal du bruge et adgangsnøgle-id og en hemmelig adgangsnøgle til en AWS identitets- og adgangsstyring (JEG ER) bruger konto med administrative rettigheder (vedhæft den eksisterende administrerede politik) og programmatisk adgang. 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

Bekræft de tilladelser, som cloud9 vil bruge til at kalde AWS-ressourcer.

aws sts get-caller-identity

Bekræft fra nedenstående output, at du ser arn af den admin-bruger, som du har konfigureret i AWS CLI-profilen. I dette eksempel er det "kubeflow-bruger"

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

Installer Amazon EKS og Kubeflow på AWS

For at installere Amazon EKS og Kubeflow på AWS skal du udføre følgende trin:

1. Konfigurer dit miljø til at implementere 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. Implementer vaniljeversionen af ​​Kubeflow på AWS og relaterede AWS-ressourcer som EKS ved hjælp af Terraform. Bemærk venligst, at EBS-volumener, der bruges i EKS nodegroup, ikke er krypteret 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

Konfigurer Kubeflow-tilladelserne

1. Tilføj tilladelser til Notebook-pod og Pipeline-komponentpod for at foretage SageMaker, S3 og IAM api-opkald ved hjælp af kubeflow_iam_permissions.sh scripts.

   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. Opret SageMaker-udførelsesrolle for at gøre det muligt for SageMaker-uddannelsesjob at få adgang til træningsdatasæt fra S3-tjeneste ved hjælp af sagemaker_role.sh scripts.

   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å adgang til Kubeflow-dashboardet

Udfør følgende trin for at få adgang til Kubeflow-dashboardet:

1. Du kan køre Kubeflow-dashboard lokalt i Cloud9-miljøet uden at udsætte dine URL'er for offentligt internet ved at køre nedenstående kommandoer.

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

2. Vælg Forhåndsvisning af kørende applikation.
3. Vælg ikonet i hjørnet af Kubeflow-dashboardet for at åbne det som en separat fane i Chrome.
4. Indtast standardoplysningerne (user@example.com/12341234) for at logge ind på Kubeflow-dashboardet.

Konfigurer Kubeflow på AWS-miljøet

Når du er logget ind på Kubeflow-dashboardet, skal du sikre dig, at du har det rigtige navneområde (kubeflow-user-example-com) valgt. Udfør følgende trin for at konfigurere dit Kubeflow på AWS-miljø:

1. Vælg på Kubeflow-dashboardet Notebooks i navigationsruden.
2. Vælg Ny notesbog.
3. Til Navn, gå ind aws-nb.
4. Til Jupyter Docket billede, vælg billedet jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (det seneste tilgængelige jupyter-pytorch DLC-billede).
5. Til CPU, gå ind 1.
6. Til Hukommelse, gå ind 5.
7. Til GPU'er, lad være som Ingen.
8. Foretag ikke ændringer i Arbejdsområde , Datamængder sektioner.
9. Type Tillad adgang til Kubeflow Pipelines i Konfigurationer sektion og vælg Start.
10. Bekræft, at din notesbog er oprettet korrekt (det kan tage et par minutter).
11. Vælg Tilslut for at logge ind på JupyterLab.
12. Klon arkivet ved at gå ind https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git i Klon en repo felt.
13. Vælg Klon.

Kør et distribueret træningseksempel

Når du har konfigureret Jupyter notesbogen, kan du køre hele demoen ved at bruge følgende trin på højt niveau fra mappen eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training i det klonede depot:

1. Kør PyTorch Distributed Data Parallel (DDP) træningsscript – Se PyTorch DDP-træningsscriptet cifar10-distributed-gpu-final.py, som inkluderer et eksempel på et foldet neuralt netværk og logik til at distribuere træning på en multi-node CPU og GPU-klynge.
2. Opret en Kubeflow-pipeline – Kør notesbogen STEP1.0_create_pipeline_k8s_sagemaker.ipynb at skabe en pipeline, der kører og implementerer modeller på SageMaker. Sørg for at installere SageMaker-biblioteket som en del af den første notebook-celle og genstart kernen, før du kører resten af ​​notebook-cellerne.
3. Kald et SageMaker-slutpunkt – Kør notesbogen STEP1.1_invoke_sagemaker_endpoint.ipynb for at påkalde og teste SageMaker-modellens slutpunkt, der blev oprettet i den forrige notesbog.

I de efterfølgende afsnit diskuterer vi hvert af disse trin i detaljer.

Kør PyTorch DDP-træningsscriptet

Som en del af den distribuerede træning træner vi en klassifikationsmodel skabt af et simpelt foldet neuralt netværk, der opererer på CIFAR10-datasættet. Træningsmanuskriptet cifar10-distributed-gpu-final.py indeholder kun open source-biblioteker og er kompatibel til at køre både på Kubernetes og SageMaker træningsklynger på enten GPU-enheder eller CPU-instanser. Lad os se på et par vigtige aspekter af træningsscriptet, før vi kører vores notesbogseksempler.

Vi bruger torch.distributed modul, som indeholder PyTorch-understøttelse og kommunikationsprimitiver til multi-proces parallelisme på tværs af 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 skaber en simpel billedklassificeringsmodel ved hjælp af en kombination af foldning, max pooling og lineære lag, hvortil en relu aktiveringsfunktionen anvendes i det fremadgående gennemløb af modeltræ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

Hvis træningsklyngen har GPU'er, kører scriptet træningen på CUDA-enheder, og enhedsvariablen indeholder standard-CUDA-enheden:

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

Før du kører distribueret træning ved hjælp af PyTorch DistributedDataParallel for at køre distribueret behandling på flere noder, skal du initialisere det distribuerede miljø ved at kalde init_process_group. Dette initialiseres på hver maskine i træningsklyngen.

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

Vi instansierer klassificeringsmodellen og kopierer modellen til målenheden. Hvis distribueret træning er aktiveret til at køre på flere noder, DistributedDataParallel klasse bruges som et indpakningsobjekt omkring modelobjektet, hvilket tillader synkron distribueret træning på tværs af flere maskiner. Inputdataene opdeles på batchdimensionen, og en kopi af modellen placeres på hver maskine og hver enhed. Se følgende kode:

model = Net().to(device)

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

...

Opret en Kubeflow-pipeline

Notesbogen bruger Kubeflow Pipelines SDK og dets medfølgende sæt af Python-pakker til at specificere og køre ML-workflow-pipelines. Som en del af denne SDK bruger vi pakkedekoratoren for domænespecifikke sprog (DSL). dsl.pipeline, som dekorerer Python-funktionerne for at returnere en pipeline.

Kubeflow-pipelinen bruger SageMaker-komponent V2 til at indsende træning til SageMaker ved hjælp af SageMaker ACK-operatører. SageMaker-modeloprettelse og modelimplementering bruger SageMaker-komponent V1, som er Boto3-baserede SageMaker-komponenter. Vi bruger en kombination af begge komponenter i dette eksempel for at demonstrere den fleksibilitet, du har i valg.

1. Indlæs SageMaker-komponenterne ved hjælp af 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 kode opretter vi Kubeflow-pipeline, hvor vi kører SageMaker distribueret træning ved hjælp af to ml.p3.2xlarge tilfælde:

   # 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 at pipelinen er defineret, kan du kompilere pipelinen til en Argo YAML-specifikation ved hjælp af Kubeflow Pipelines SDK'er kfp.compiler pakke. Du kan køre denne pipeline ved hjælp af Kubeflow Pipelines SDK-klienten, som kalder Pipelines-tjenestens slutpunkt og sender passende godkendelsesheadere direkte fra notesbogen. 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. Vælg den Kør detaljer link under den sidste celle for at se Kubeflow-pipelinen. Følgende skærmbillede viser vores pipelinedetaljer for SageMaker-trænings- og implementeringskomponenten.
3. Vælg træningsjobbet trin og på Logs fanen, skal du vælge linket CloudWatch-logfiler for at få adgang til SageMaker-logfilerne.
   Følgende skærmbillede viser CloudWatch-logfilerne for hver af de to ml.p3.2xlarge-forekomster.
4. Vælg en af ​​grupperne for at se logfilerne.
5. Fang SageMaker-slutpunktet ved at vælge Sagemaker – Implementeringsmodel trin og kopiering af endpoint_name output artefaktværdi.

Kald et SageMaker-slutpunkt

Notesbogen STEP1.1_invoke_sagemaker_endpoint.ipynb påberåber SageMaker-slutningsendepunktet oprettet i det forrige trin. Sørg for at opdatere slutpunktets navn:

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

Ryd op

For at rydde op i dine ressourcer skal du udføre følgende trin:

1. Kør følgende kommandoer i AWS Cloud9 for at slette AWS-ressourcerne:

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

2. Slet IAM-rolle "sagemakerrole” ved at bruge 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. Slet SageMaker-slutpunktet ved hjælp af følgende AWS CLI-kommando:

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

Resumé

I dette indlæg fremhævede vi den værdi, som Kubeflow på AWS 1.6.1 giver gennem native AWS-administrerede serviceintegrationer for at imødekomme behovet for AI- og ML-brugscases på virksomhedsniveau. Du kan vælge mellem flere implementeringsmuligheder for at installere Kubeflow på AWS med forskellige serviceintegrationer ved hjælp af Terraform, Kustomize eller Helm. Use casen i dette indlæg demonstrerede en Kubeflow-integration med SageMaker, der bruger en SageMaker-administreret træningsklynge til at køre distribueret træning til en billedklassificeringsmodel og SageMaker-slutpunkt til modelimplementering.

Vi har også stillet en eksempel på pipeline der bruger de nyeste SageMaker-komponenter; du kan køre dette direkte fra Kubeflow-dashboardet. Denne pipeline kræver Amazon S3 data , SageMaker udførelse IAM rolle som de nødvendige inputs.

For at komme i gang med Kubeflow på AWS, se de tilgængelige AWS-integrerede implementeringsmuligheder i Kubeflow på AWS. Du kan følge AWS Labs repository at spore alle AWS-bidrag til Kubeflow. Du kan også finde os på Kubeflow #AWS Slack Channel; din feedback der vil hjælpe os med at prioritere de næste funktioner, der skal bidrage til Kubeflow-projektet.

Om forfatterne

Kanwaljit Khurmi er Senior Solutions Architect hos Amazon Web Services. Han arbejder sammen med AWS-kunderne for at yde vejledning og teknisk assistance, der hjælper dem med at forbedre værdien af ​​deres løsninger, når de bruger AWS. Kanwaljit har specialiseret sig i at hjælpe kunder med container- og maskinlæringsapplikationer.

Kartik Kalamadi er softwareudviklingsingeniør hos Amazon AI. I øjeblikket fokuseret på Machine Learning Kubernetes open source-projekter såsom Kubeflow og AWS SageMaker Controller til k8s. I min fritid kan jeg godt lide at spille pc-spil og fifle med VR ved hjælp af Unity-motoren.

Rahul Kharse er softwareudviklingsingeniør hos Amazon Web Services. Hans arbejde fokuserer på at integrere AWS-tjenester med open source containeriserede ML Ops-platforme for at forbedre deres skalerbarhed, pålidelighed og sikkerhed. Udover at fokusere på kundernes ønsker om funktioner, nyder Rahul også at eksperimentere med den nyeste teknologiske udvikling på området.