Hybride ML-workflows mogelijk maken op Amazon EKS en Amazon SageMaker met Kubeflow met één klik op AWS-implementatie

Tegenwoordig bouwen veel AWS-klanten enterprise-ready machine learning (ML)-platforms op Amazon Elastic Kubernetes-service (Amazon EKS) gebruiken Kubeflow op AWS (een AWS-specifieke distributie van Kubeflow) voor vele gebruiksscenario's, waaronder computervisie, begrip van natuurlijke taal, spraakvertaling en financiële modellering.

Met de nieuwste release van open-source Kubeflow v1.6.1, blijft de Kubeflow-community deze grootschalige acceptatie van Kubeflow voor bedrijfsgebruik ondersteunen. De nieuwste release bevat veel nieuwe opwindende functies, zoals ondersteuning voor Kubernetes v1.22, gecombineerde Python SDK voor PyTorch, MXNet, MPI, XGBoost in Kubeflow's gedistribueerde Training Operator, nieuwe ClusterServingRuntime en ServingRuntime CRD's voor modelservice en nog veel meer.

AWS-bijdragen aan Kubeflow met de recente lancering van Kubeflow op AWS 1.6.1 ondersteunen alle upstream open-source Kubeflow-functies en omvatten veel nieuwe integraties met de sterk geoptimaliseerde, cloud-native, enterprise-ready AWS-services die u zullen helpen bij het bouwen van zeer betrouwbare, veilige, draagbare en schaalbare ML-systemen.

In dit bericht bespreken we nieuwe Kubeflow op AWS v1.6.1-functies en belichten we drie belangrijke integraties die op één platform zijn gebundeld om u te bieden::

• Infrastructure as Code (IaaC) oplossing met één klik die de end-to-end installatie van Kubeflow automatiseert, inclusief het maken van EKS-clusters
• Ondersteuning voor gedistribueerde training op Amazon Sage Maker gebruik Amazon SageMaker-operators voor Kubernetes (ACK) en SageMaker-componenten voor Kubeflow-pijplijnen en lokaal op Kubernetes met behulp van Kubeflow-operators trainen. Veel klanten gebruiken deze mogelijkheid om hybride machine learning-architecturen te bouwen, waarbij ze gebruikmaken van zowel Kubernetes-computing voor de experimenteerfase als SageMaker om workloads op productieschaal uit te voeren.
• Verbeterde monitoring en observeerbaarheid voor ML-workloads, waaronder Amazon EKS, Kubeflow-statistieken en applicatielogboeken met behulp van Prometheus, Grafana en Amazon Cloud Watch integraties

De use case in deze blog zal specifiek gericht zijn op SageMaker-integratie met Kubeflow op AWS die kan worden toegevoegd aan uw bestaande Kubernetes-workflows, zodat u hybride machine learning-architecturen kunt bouwen.

Kubeflow op AWS

Kubeflow op AWS 1.6.1 biedt een duidelijk pad om Kubeflow te gebruiken, met de toevoeging van de volgende AWS-services bovenop bestaande mogelijkheden:

• SageMaker-integratie met Kubeflow om hybride ML-workflows uit te voeren met behulp van SageMaker Operators for Kubernetes (ACK) en SageMaker Components for Kubeflow Pipelines.
• Geautomatiseerde implementatieopties zijn verbeterd en vereenvoudigd met behulp van Kustomize-scripts en Helm-grafieken.
• Ondersteuning toegevoegd voor Infrastructure as Code (IaC) implementatie met één klik voor Kubeflow op AWS met behulp van Terraform voor alle beschikbare inzetopties. Dit script automatiseert het maken van de volgende AWS-bronnen:
• Ondersteuning AWS PrivéLink voor Amazon S3 waarmee niet-commerciële regiogebruikers verbinding kunnen maken met hun respectieve S3-eindpunten.
• Toegevoegde integratie met Amazon beheerde service voor Prometheus (AMP) en Amazon beheerde Grafana om statistieken te monitoren met Kubeflow op AWS.
• Bijgewerkte Kubeflow-notebookservercontainers met de nieuwste deep learning-containerimages op basis van TensorFlow 2.10.0 en PyTorch 1.12.1.
• Integratie met AWS DLC's om gedistribueerd uit te voeren opleiding en gevolgtrekking werklast.

Het volgende architectuurdiagram is een snelle momentopname van alle service-integraties (inclusief de reeds genoemde) die beschikbaar zijn voor Kubeflow-besturings- en datavlakcomponenten in Kubeflow op AWS. Het Kubeflow-besturingsvlak wordt bovenop Amazon EKS geïnstalleerd, een beheerde containerservice die wordt gebruikt om Kubernetes-applicaties in de cloud uit te voeren en te schalen. Met deze AWS-service-integraties kunt u kritieke delen van het Kubeflow-besturingsvlak loskoppelen van Kubernetes, waardoor u een veilig, schaalbaar, veerkrachtig en kostengeoptimaliseerd ontwerp krijgt. Raadpleeg voor meer informatie over de waarde die deze service-integraties toevoegen ten opzichte van open-source Kubeflow Bouw en implementeer een schaalbaar machine learning-systeem op Kubernetes met Kubeflow op AWS.

Laten we in meer detail bespreken hoe de belangrijkste functies van Kubeflow op AWS 1.6.1 nuttig kunnen zijn voor uw organisatie.

Kubeflow op AWS-functiedetails

Met de release van Kubeflow 1.6.1 hebben we geprobeerd betere tools te bieden voor verschillende soorten klanten die het gemakkelijk maken om aan de slag te gaan met Kubeflow, welke opties je ook kiest. Deze tools bieden een goed startpunt en kunnen worden aangepast aan uw exacte behoeften.

Implementatie mogelijkheden

We bieden verschillende implementatieopties voor verschillende use-cases van klanten. Hier kunt u kiezen met welke AWS-services u uw Kubeflow-implementatie wilt integreren. Als u besluit de implementatieopties later te wijzigen, raden we u aan een nieuwe installatie uit te voeren voor de nieuwe implementatie. De volgende implementatieopties zijn beschikbaar:

Als u Kubeflow met minimale wijzigingen wilt implementeren, overweeg dan de vanille implementatie optie. Alle beschikbare implementatieopties kunnen worden geïnstalleerd met behulp van Kustomize, Helm of Terraform.

We hebben ook verschillende add-on-implementaties die bovenop een van deze implementatie-opties kunnen worden geïnstalleerd:

Installatie opties

Nadat u hebt besloten welke implementatieoptie het beste bij uw behoeften past, kunt u kiezen hoe u deze implementaties wilt installeren. Om zowel experts als nieuwkomers van dienst te zijn, hebben we verschillende niveaus van automatisering en configuratie.

Optie 1: Terraform (IaC)

Dit creëert een EKS-cluster en alle gerelateerde AWS-infrastructuurbronnen en implementeert vervolgens Kubeflow alles in één opdracht met behulp van Terraform. Intern gebruikt dit EKS-blauwdrukken en Helm-diagrammen.

Deze optie heeft de volgende voordelen:

• Het biedt bedrijven de flexibiliteit om Amazon EKS en Kubeflow met één opdracht te implementeren zonder zich zorgen te hoeven maken over specifieke Kubeflow-componentconfiguraties. Dit zal enorm helpen bij het versnellen van technologie-evaluatie, prototyping en de levenscyclus van productontwikkeling, wat flexibiliteit biedt om terraform-modules te gebruiken en aan te passen om aan projectspecifieke behoeften te voldoen.
• Veel organisaties die tegenwoordig Terraform als middelpunt van hun cloudstrategie hebben, kunnen nu Kubeflow on AWS Terraform-oplossing gebruiken om hun clouddoelen te bereiken.

Optie 2: Kustomize- of Helm-grafieken:

Met deze optie kunt u Kubeflow implementeren in een proces van twee stappen:

1. Creëer AWS-resources zoals Amazon EKS, Amazon RDS, Amazon S3 en Amazon Cognito, hetzij via de geautomatiseerde scripts die zijn opgenomen in de AWS-distributie, hetzij handmatig door een stap-voor-stap handleiding.
2. Installeer Kubeflow-implementaties met behulp van Helm-grafieken of Kustomize.

Deze optie heeft de volgende voordelen:

• Het belangrijkste doel van deze installatieoptie is om Kubeflow-gerelateerde Kubernetes-configuraties te bieden. Daarom kunt u ervoor kiezen om bestaande EKS-clusters of een van de gerelateerde AWS-bronnen zoals Amazon RDS, Amazon S3 en Amazon Cognito te maken of in te voeren, en deze te configureren en te beheren om met Kubeflow op AWS te werken.
• Het is eenvoudiger om over te stappen van een open-source Kustomize Kubeflow-manifest naar AWS Kubeflow-distributie.

Het volgende diagram illustreert de architecturen van beide opties.

Integratie met SageMaker

SageMaker is een volledig beheerde service die speciaal is ontworpen en geoptimaliseerd voor het beheer van ML-workflows. Het neemt het ongedifferentieerde zware werk van infrastructuurbeheer weg en elimineert de noodzaak om te investeren in IT en DevOps om clusters te beheren voor het bouwen van ML-modellen, training en inferentie.

Veel AWS-klanten die portabiliteitsvereisten of on-premises standaardbeperkingen hebben, gebruiken Amazon EKS om herhaalbare ML-pijplijnen in te stellen voor het uitvoeren van trainings- en inferentieworkloads. Dit vereist echter dat ontwikkelaars aangepaste code schrijven om de onderliggende ML-infrastructuur te optimaliseren, hoge beschikbaarheid en betrouwbaarheid te bieden en te voldoen aan de juiste beveiligings- en regelgevingsvereisten. Deze klanten willen daarom SageMaker gebruiken voor kostengeoptimaliseerde en beheerde infrastructuur voor modeltraining en -implementaties en Kubernetes blijven gebruiken voor orkestratie en ML-pijplijnen om standaardisatie en overdraagbaarheid te behouden.

Om aan deze behoefte te voldoen, kunt u met AWS modellen trainen, afstemmen en implementeren in SageMaker van Amazon EKS door de volgende twee opties te gebruiken:

• Amazon SageMaker ACK-operators voor Kubernetes, die zijn gebaseerd op de AWS-controllers voor Kubernetes (ACK) kader. ACK is de AWS-strategie die zorgt voor standaardisatie voor het bouwen van aangepaste Kubernetes-controllers waarmee Kubernetes-gebruikers AWS-resources zoals databases of berichtenwachtrijen kunnen inrichten door simpelweg de Kubernetes API te gebruiken. SageMaker ACK Operators maken het gemakkelijker voor ML-ontwikkelaars en datawetenschappers die Kubernetes als hun besturingsvlak gebruiken om ML-modellen in SageMaker te trainen, af te stemmen en te implementeren zonder zich aan te melden bij de SageMaker-console.
• De SageMaker-componenten voor Kubeflow-pijpleidingen, waarmee u SageMaker kunt integreren met de overdraagbaarheid en orkestratie van Kubeflow Pipelines. Met de SageMaker-componenten wordt elke taak in de pijplijnworkflow uitgevoerd op SageMaker in plaats van op het lokale Kubernetes-cluster. Hierdoor kunt u native SageMaker-trainings-, afstemmings-, eindpuntimplementatie- en batchtransformatietaken maken en bewaken vanuit uw Kubeflow-pijplijnen, waardoor u volledige rekenkracht, inclusief gegevensverwerking en trainingstaken, kunt verplaatsen van het Kubernetes-cluster naar de voor machine learning geoptimaliseerde beheerde service van SageMaker.

Beginnend met Kubeflow op AWS v1.6.1, brengen alle beschikbare Kubeflow-implementatieopties beide Amazon SageMaker-integratieopties standaard samen op één platform. Dat betekent dat u nu SageMaker-taken kunt indienen met behulp van SageMaker ACK-operators vanaf een Kubeflow Notebook-server zelf door de aangepaste SageMaker-resource in te dienen of vanuit de Kubeflow-pijplijnstap met behulp van SageMaker-componenten.

Er zijn twee versies van SageMaker Components - Boto3 (AWS SDK voor AWS SDK voor Python) gebaseerde versie 1 componenten en SageMaker Operator voor K8s (ACK) gebaseerde versie 2 componenten. De nieuwe SageMaker-componenten versie 2 ondersteunen de nieuwste SageMaker-trainingsapis en we zullen doorgaan met het toevoegen van meer SageMaker-functies aan deze versie van de component. U heeft echter de flexibiliteit om Sagemaker-componenten versie 2 te combineren voor training en versie 1 voor andere SageMaker-functies zoals afstemmingsafstemming, verwerkingstaken, hosting en nog veel meer.

Integratie met Prometheus en Grafana

Prometheus is een open-source metrische aggregatietool die u kunt configureren om te worden uitgevoerd op Kubernetes-clusters. Bij uitvoering op Kubernetes-clusters schraapt een Prometheus-hoofdserver periodiek pod-eindpunten.

Kubeflow-componenten, zoals Kubeflow Pipelines (KFP) en Notebook, zenden Prometheus-statistieken uit om componentresources te bewaken, zoals het aantal lopende experimenten of het aantal notebooks.

Deze statistieken kunnen worden geaggregeerd door een Prometheus-server die in het Kubernetes-cluster draait en worden opgevraagd met behulp van Prometheus Query Language (PromQL). Ga voor meer informatie over de functies die Prometheus ondersteunt naar de Prometheus-documentatie.

De Kubeflow on AWS-distributie biedt ondersteuning voor de integratie met de volgende door AWS beheerde services:

1. Amazon Managed Prometheus (AMP) dat is een Prometheus-compatibele monitoringservice voor containerinfrastructuur en applicatiestatistieken voor containers waarmee klanten gemakkelijk containeromgevingen op schaal veilig kunnen monitoren. Met behulp van AMP kunt u uw metrieken, logboeken en sporen die zijn verzameld uit meerdere gegevensbronnen in uw observatiesysteem, waaronder AWS, ISV's van derden en andere bronnen in uw IT-portfolio, visualiseren, analyseren en alarmeren.
2. Amazon Managed Grafana, een volledig beheerde en veilige datavisualisatieservice op basis van open source grafana project, waarmee klanten direct operationele statistieken, logboeken en traceringen voor hun toepassingen uit meerdere gegevensbronnen kunnen opvragen, correleren en visualiseren. Amazon Managed Grafana ontlast het operationele beheer van Grafana door automatisch de computer- en database-infrastructuur te schalen naarmate de gebruikseisen toenemen, met geautomatiseerde versie-updates en beveiligingspatches.

De Kubeflow on AWS-distributie biedt ondersteuning voor de integratie van Amazon Managed Service for Prometheus en Amazon Managed Grafana om de opname en visualisatie van Prometheus-statistieken veilig op schaal te vergemakkelijken.

De volgende statistieken worden opgenomen en kunnen worden gevisualiseerd:

• Statistieken die worden uitgezonden door Kubeflow-componenten zoals Kubeflow Pipelines en de Notebook-server
• Kubeflow metrische gegevens over het controlevlak

Raadpleeg voor het configureren van Amazon Managed Service voor Prometheus en Amazon Managed Grafana voor uw Kubeflow-cluster Gebruik Prometheus, Amazon Managed Service for Prometheus en Amazon Managed Grafana om statistieken te monitoren met Kubeflow op AWS.

Overzicht oplossingen

In deze use case gebruiken we de Kubeflow vanille-implementatie met behulp van de Terraform-installatieoptie. Als de installatie is voltooid, loggen we in op het Kubeflow-dashboard. Vanuit het dashboard draaien we een Kubeflow Jupyter-notebookserver om een ​​Kubeflow-pijplijn te bouwen die SageMaker gebruikt om gedistribueerde training uit te voeren voor een beeldclassificatiemodel en een SageMaker-eindpunt voor modelimplementatie.

Voorwaarden

Zorg dat je aan de volgende voorwaarden voldoet:

• Je hebt een AWS-account.
• Zorg ervoor dat u zich in het us-west-2 Regio om dit voorbeeld uit te voeren.
• Gebruik Google Chrome voor interactie met de AWS-beheerconsole en Kubeflow.
• Zorg ervoor dat uw account de SageMaker Training-resourcetypelimiet voor ml.p3.2xlarge heeft verhoogd naar 2 met behulp van de Service Quotas-console.
• Optioneel kunt u AWS-Cloud9, een cloudgebaseerde geïntegreerde ontwikkelomgeving (IDE) waarmee u al het werk vanuit uw webbrowser kunt voltooien. Raadpleeg voor installatie-instructies: Cloud9 IDE instellen. Selecteer Ubuntu Server 18.04 als platform in de AWS Cloud9-instellingen.Kies vervolgens vanuit uw AWS Cloud9-omgeving het plusteken en open een nieuwe terminal.

Ook configureer je een AWS-opdrachtregelinterface (AWS CLI) profiel. Hiervoor heeft u een toegangssleutel-ID en een geheime toegangssleutel van een AWS Identiteits- en toegangsbeheer (IAM) gebruiker account met beheerdersrechten (voeg het bestaande beheerde beleid toe) en programmatische toegang. Zie de volgende code:

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

Controleer de machtigingen die cloud9 zal gebruiken om AWS-bronnen aan te roepen.

aws sts get-caller-identity

Controleer aan de hand van de onderstaande uitvoer dat u arn ziet van de admin-gebruiker die u hebt geconfigureerd in het AWS CLI-profiel. In dit voorbeeld is dat "kubeflow-gebruiker"

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

Installeer Amazon EKS en Kubeflow op AWS

Voer de volgende stappen uit om Amazon EKS en Kubeflow op AWS te installeren:

1. Stel uw omgeving in voor het implementeren van Kubeflow op 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. Implementeer de standaardversie van Kubeflow op AWS en gerelateerde AWS-resources zoals EKS met behulp van Terraform. Houd er rekening mee dat EBS-volumes die in de EKS-knooppuntengroep worden gebruikt, standaard niet zijn versleuteld:

   #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

Stel de Kubeflow-machtigingen in

1. Machtigingen toevoegen aan Notebook-pod en Pipeline-componentpod om SageMaker-, S3- en IAM-api-aanroepen te doen met behulp van 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. Maak SageMaker-uitvoeringsrol om SageMaker-trainingstaak in staat te stellen toegang te krijgen tot trainingsgegevensset van S3-service met behulp van 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

Toegang tot het Kubeflow-dashboard

Voer de volgende stappen uit om toegang te krijgen tot het Kubeflow-dashboard:

1. U kunt het Kubeflow-dashboard lokaal uitvoeren in een Cloud9-omgeving zonder uw URL's bloot te stellen aan het openbare internet door onderstaande opdrachten uit te voeren.

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

2. Kies Voorbeeld van actieve toepassing.
3. Kies het pictogram in de hoek van het Kubeflow-dashboard om het als een apart tabblad in Chrome te openen.
4. Voer de standaardreferenties in (user@example.com/12341234) om in te loggen op het Kubeflow-dashboard.

Stel de Kubeflow op AWS-omgeving in

Zodra u bent aangemeld bij het Kubeflow-dashboard, zorgt u ervoor dat u de juiste naamruimte hebt (kubeflow-user-example-com) gekozen. Voer de volgende stappen uit om uw Kubeflow op AWS-omgeving in te stellen:

1. Kies op het Kubeflow-dashboard Notitieboekjes in het navigatievenster.
2. Kies Nieuw notebook.
3. Voor Naam, ga naar binnen aws-nb.
4. Voor Jupyter Docket-afbeelding, kies de afbeelding jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (de nieuwste beschikbaar jupyter-pytorch DLC-afbeelding).
5. Voor CPU, ga naar binnen 1.
6. Voor Geheugen, ga naar binnen 5.
7. Voor GPU's, laat als Geen.
8. Breng geen wijzigingen aan in de Werkruimte en Gegevensvolumes secties.
9. kies Toegang tot Kubeflow Pipelines toestaan in de Configuraties sectie en kies Starten.
10. Controleer of uw notitieblok is aangemaakt (dit kan een paar minuten duren).
11. Kies Verbinden om in te loggen bij JupyterLab.
12. Kloon de repo door in te voeren https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git in de Kloon een opslagplaats veld.
13. Kies Kloon.

Voer een gedistribueerd trainingsvoorbeeld uit

Nadat u de Jupyter-notebook hebt ingesteld, kunt u de volledige demo uitvoeren met behulp van de volgende stappen op hoog niveau vanuit de map: eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training in de gekloonde repository:

1. Voer het trainingsscript PyTorch Distributed Data Parallel (DDP) uit – Raadpleeg het PyTorch DDP-trainingsscript cifar10-distributed-gpu-final.py, met een voorbeeld van een convolutioneel neuraal netwerk en logica om training te distribueren op een multi-node CPU- en GPU-cluster.
2. Maak een Kubeflow-pijplijn – Start het notitieblok STEP1.0_create_pipeline_k8s_sagemaker.ipynb om een ​​pijplijn te maken die modellen uitvoert en implementeert op SageMaker. Zorg ervoor dat u de SageMaker-bibliotheek installeert als onderdeel van de eerste notebookcel en start de kernel opnieuw op voordat u de rest van de notebookcellen uitvoert.
3. Roep een SageMaker-eindpunt aan – Start het notitieblok STEP1.1_invoke_sagemaker_endpoint.ipynb om het inferentie-eindpunt van het SageMaker-model dat in de vorige notebook is gemaakt, aan te roepen en te testen.

In de volgende paragrafen bespreken we elk van deze stappen in detail.

Voer het PyTorch DDP-trainingsscript uit

Als onderdeel van de gedistribueerde training trainen we een classificatiemodel dat is gemaakt door een eenvoudig convolutief neuraal netwerk dat werkt op de CIFAR10-dataset. Het trainingsscript cifar10-distributed-gpu-final.py bevat alleen de open-sourcebibliotheken en is compatibel om zowel op Kubernetes- als SageMaker-trainingsclusters op GPU-apparaten of CPU-instanties te draaien. Laten we een paar belangrijke aspecten van het trainingsscript bekijken voordat we onze notebookvoorbeelden uitvoeren.

We maken gebruik van de torch.distributed module, die PyTorch-ondersteuning en communicatieprimitieven bevat voor parallellisme met meerdere processen tussen knooppunten in het cluster:

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

We creëren een eenvoudig beeldclassificatiemodel met behulp van een combinatie van convolutionele, maximale pooling en lineaire lagen waarop a relu activeringsfunctie wordt toegepast in de voorwaartse pass van de modeltraining:

# 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

Als het trainingscluster GPU's heeft, voert het script de training uit op CUDA-apparaten en bevat de apparaatvariabele het standaard CUDA-apparaat:

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

Voordat u gedistribueerde training uitvoert met PyTorch DistributedDataParallel om gedistribueerde verwerking op meerdere knooppunten uit te voeren, moet u de gedistribueerde omgeving initialiseren door te bellen met init_process_group. Dit wordt geïnitialiseerd op elke machine van het trainingscluster.

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

We instantiëren het classificatiemodel en kopiëren het model naar het doelapparaat. Als gedistribueerde training op meerdere knooppunten kan worden uitgevoerd, DistributedDataParallel class wordt gebruikt als een wrapper-object rond het modelobject, waardoor synchrone gedistribueerde training over meerdere machines mogelijk is. De invoergegevens worden gesplitst op de batchdimensie en een replica van het model wordt op elke machine en elk apparaat geplaatst. Zie de volgende code:

model = Net().to(device)

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

...

Maak een Kubeflow-pijplijn

Het notitieboekje gebruikt de Kubeflow Pipelines-SDK en de meegeleverde set Python-pakketten om de ML-werkstroompijplijnen te specificeren en uit te voeren. Als onderdeel van deze SDK gebruiken we de pakketdecorateur voor domeinspecifieke talen (DSL). dsl.pipeline, die de Python-functies siert om een ​​pijplijn te retourneren.

De Kubeflow-pijplijn gebruikt SageMaker-component V2 voor het indienen van training bij SageMaker met behulp van SageMaker ACK-operators. SageMaker-modelcreatie en modelimplementatie maakt gebruik van SageMaker-component V1, dit zijn op Boto3 gebaseerde SageMaker-componenten. In dit voorbeeld gebruiken we een combinatie van beide componenten om aan te tonen dat u flexibel kunt kiezen.

1. Laad de SageMaker-componenten met behulp van de volgende code:

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

   In de volgende code maken we de Kubeflow-pijplijn waar we SageMaker gedistribueerde training uitvoeren met behulp van twee ml.p3.2xlarge gevallen:

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

   Nadat de pijplijn is gedefinieerd, kunt u de pijplijn compileren naar een Argo YAML-specificatie met behulp van de Kubeflow Pipelines SDK's kfp.compiler pakket. U kunt deze pijplijn uitvoeren met behulp van de Kubeflow Pipelines SDK-client, die het Pipelines-service-eindpunt aanroept en de juiste authenticatieheaders rechtstreeks vanuit de notebook doorgeeft. Zie de volgende code:

   # 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. Kies de Gegevens uitvoeren link onder de laatste cel om de Kubeflow-pijplijn te bekijken. De volgende schermafbeelding toont onze pijplijndetails voor de SageMaker-trainings- en implementatiecomponent.
3. Kies de opleidingstaak stap en op de Logs tabblad, kiest u de link CloudWatch-logboeken om toegang te krijgen tot de SageMaker-logboeken.
   De volgende schermafbeelding toont de CloudWatch-logboeken voor elk van de twee ml.p3.2xlarge-instanties.
4. Kies een van de groepen om de logboeken te bekijken.
5. Leg het SageMaker-eindpunt vast door het Sagemaker – Model implementeren stap en het kopiëren van de endpoint_name output artefact waarde.

Roep een SageMaker-eindpunt aan

De notebook STEP1.1_invoke_sagemaker_endpoint.ipynb roept het SageMaker-inferentie-eindpunt op dat in de vorige stap is gemaakt. Zorg ervoor dat u de naam van het eindpunt bijwerkt:

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

Opruimen

Voer de volgende stappen uit om uw bronnen op te schonen:

1. Voer de volgende opdrachten uit in AWS Cloud9 om de AWS-bronnen te verwijderen:

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

2. IAM-rol verwijderen “sagemakerrole” met behulp van de volgende AWS CLI-opdracht:

   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. Verwijder het SageMaker-eindpunt met de volgende AWS CLI-opdracht:

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

Samengevat

In dit bericht hebben we de waarde benadrukt die Kubeflow op AWS 1.6.1 biedt via native AWS-beheerde service-integraties om tegemoet te komen aan de behoefte aan AI- en ML-use-cases op ondernemingsniveau. U kunt kiezen uit verschillende implementatieopties om Kubeflow op AWS te installeren met verschillende service-integraties met behulp van Terraform, Kustomize of Helm. De use case in dit bericht demonstreerde een Kubeflow-integratie met SageMaker die een door SageMaker beheerd trainingscluster gebruikt om gedistribueerde training uit te voeren voor een beeldclassificatiemodel en SageMaker-eindpunt voor modelimplementatie.

We hebben ook een beschikbaar gesteld voorbeeld pijplijn voorbeeld dat de nieuwste SageMaker-componenten gebruikt; u kunt dit rechtstreeks vanuit het Kubeflow-dashboard uitvoeren. Deze pijplijn vereist de Amazon S3-gegevens en SageMaker uitvoering IAM-rol als de vereiste ingangen.

Raadpleeg de beschikbare AWS-geïntegreerde implementatieopties in om aan de slag te gaan met Kubeflow op AWS Kubeflow op AWS. U kunt de . volgen AWS Labs-repository om alle AWS-bijdragen aan Kubeflow bij te houden. U kunt ons ook vinden op de Kubeflow #AWS Slack-kanaal; uw feedback daar helpt ons bij het prioriteren van de volgende functies om bij te dragen aan het Kubeflow-project.

Over de auteurs

Kanwaljit Khurmi is Senior Solutions Architect bij Amazon Web Services. Hij werkt samen met de AWS-klanten om begeleiding en technische assistentie te bieden om hen te helpen de waarde van hun oplossingen te verbeteren bij het gebruik van AWS. Kanwaljit is gespecialiseerd in het helpen van klanten met toepassingen in containers en machine learning.

Kartik Kalamadi is Software Development Engineer bij Amazon AI. Momenteel gericht op Machine Learning Kubernetes open-source projecten zoals Kubeflow en AWS SageMaker Controller voor k8s. In mijn vrije tijd speel ik graag pc-games en speel ik graag met VR met behulp van de Unity-engine.

Rahul Kharse is Software Development Engineer bij Amazon Web Services. Zijn werk richt zich op het integreren van AWS-services met open source gecontaineriseerde ML Ops-platforms om hun schaalbaarheid, betrouwbaarheid en beveiliging te verbeteren. Naast het focussen op verzoeken van klanten om functies, experimenteert Rahul ook graag met de nieuwste technologische ontwikkelingen in het veld.