Aktivieren von hybriden ML-Workflows auf Amazon EKS und Amazon SageMaker mit Ein-Klick-Bereitstellung von Kubeflow auf AWS

Heutzutage bauen viele AWS-Kunden unternehmensfähige Plattformen für maschinelles Lernen (ML) auf Amazon Elastic Kubernetes-Service (Amazon EKS) verwenden Kubeflow auf AWS (eine AWS-spezifische Distribution von Kubeflow) für viele Anwendungsfälle, darunter Computer Vision, natürliches Sprachverständnis, Sprachübersetzung und Finanzmodellierung.

Mit der neueste Version von Open-Source-Kubeflow v1.6.1unterstützt die Kubeflow-Community weiterhin diese groß angelegte Einführung von Kubeflow für Anwendungsfälle in Unternehmen. Die neueste Version enthält viele neue aufregende Funktionen wie Unterstützung für Kubernetes v1.22, kombiniertes Python-SDK für PyTorch, MXNet, MPI, XGBoost im verteilten Training Operator von Kubeflow, neue ClusterServingRuntime- und ServingRuntime-CRDs für den Modelldienst und vieles mehr.

AWS-Beiträge zu Kubeflow mit der kürzlichen Einführung von Kubeflow on AWS 1.6.1 unterstützen alle Upstream-Open-Source-Funktionen von Kubeflow und beinhalten viele neue Integrationen mit den hochoptimierten, Cloud-nativen, unternehmensfähigen AWS-Services, die Ihnen helfen werden, äußerst zuverlässige, sichere, portable und skalierbare ML-Systeme.

In diesem Beitrag diskutieren wir neue Funktionen von Kubeflow auf AWS v1.6.1 und heben drei wichtige Integrationen hervor, die auf einer Plattform gebündelt wurden, um Ihnen Folgendes zu bieten:

• Infrastructure as Code (IaaC) One-Click-Lösung, die die End-to-End-Installation von Kubeflow automatisiert, einschließlich EKS-Cluster-Erstellung
• Unterstützung für verteiltes Training auf Amazon Sage Maker Verwendung von Amazon SageMaker-Operatoren für Kubernetes (ACK) und SageMaker-Komponenten für Kubeflow-Pipelines und lokal auf Kubernetes mit Kubeflow-Schulungsoperatoren. Viele Kunden nutzen diese Funktion, um Hybridarchitekturen für maschinelles Lernen zu erstellen, in denen sie sowohl Kubernetes-Computing für die Experimentierphase als auch SageMaker nutzen, um Workloads im Produktionsmaßstab auszuführen.
• Verbesserte Überwachung und Beobachtbarkeit für ML-Workloads, einschließlich Amazon EKS, Kubeflow-Metriken und Anwendungsprotokolle mit Prometheus, Grafana und Amazon CloudWatch Integrationen

Der Anwendungsfall in diesem Blog konzentriert sich speziell auf die SageMaker-Integration mit Kubeflow auf AWS, die zu Ihren bestehenden Kubernetes-Workflows hinzugefügt werden könnte, sodass Sie hybride Architekturen für maschinelles Lernen erstellen können.

Kubeflow auf AWS

Kubeflow auf AWS 1.6.1 bietet einen klaren Weg zur Verwendung von Kubeflow, mit der Hinzufügung der folgenden AWS-Services zusätzlich zu den vorhandenen Funktionen:

• SageMaker-Integration mit Kubeflow zum Ausführen hybrider ML-Workflows mit SageMaker-Operatoren für Kubernetes (ACK) und SageMaker-Komponenten für Kubeflow-Pipelines.
• Automatisierte Bereitstellungsoptionen wurden mithilfe von Kustomize-Skripts und Helm-Diagrammen verbessert und vereinfacht.
• Unterstützung für die Ein-Klick-Bereitstellung von Infrastructure as Code (IaC) für Kubeflow auf AWS mit Terraform für alle verfügbaren Funktionen hinzugefügt Bereitstellungsoptionen. Dieses Skript automatisiert die Erstellung der folgenden AWS-Ressourcen:
• Unterstützung für AWS PrivateLink für Amazon S3, die es Benutzern aus nicht-kommerziellen Regionen ermöglicht, sich mit ihren jeweiligen S3-Endpunkten zu verbinden.
• Integration mit hinzugefügt Amazon Managed Service für Prometheus (AMP) und Von Amazon verwaltetes Grafana um Metriken mit Kubeflow auf AWS zu überwachen.
• Aktualisierte Kubeflow-Notebook-Server-Container mit den neuesten Deep-Learning-Container-Images basierend auf TensorFlow 2.10.0 und PyTorch 1.12.1.
• Integration mit AWS DLCs zur verteilten Ausführung TAUCHERAUSBILDUNG und Inferenz Arbeitslasten.

Das folgende Architekturdiagramm ist eine schnelle Momentaufnahme aller Serviceintegrationen (einschließlich der bereits erwähnten), die für Kubeflow-Steuerungs- und Datenebenenkomponenten in Kubeflow auf AWS verfügbar sind. Die Kubeflow-Steuerungsebene wird auf Amazon EKS installiert, einem verwalteten Containerdienst, der zum Ausführen und Skalieren von Kubernetes-Anwendungen in der Cloud verwendet wird. Diese AWS-Service-Integrationen ermöglichen es Ihnen, kritische Teile der Kubeflow-Steuerungsebene von Kubernetes zu entkoppeln und so ein sicheres, skalierbares, robustes und kostenoptimiertes Design bereitzustellen. Weitere Einzelheiten zum Wert, den diese Dienstintegrationen gegenüber Open-Source-Kubeflow hinzufügen, finden Sie unter Erstellen und implementieren Sie ein skalierbares maschinelles Lernsystem auf Kubernetes mit Kubeflow auf AWS.

Lassen Sie uns detaillierter besprechen, wie die Schlüsselfunktionen von Kubeflow auf AWS 1.6.1 für Ihr Unternehmen hilfreich sein könnten.

Kubeflow on AWS-Funktionsdetails

Mit der Version 1.6.1 von Kubeflow haben wir versucht, bessere Tools für verschiedene Arten von Kunden bereitzustellen, die den Einstieg in Kubeflow erleichtern, unabhängig davon, für welche Optionen Sie sich entscheiden. Diese Tools bieten einen guten Ausgangspunkt und können an Ihre genauen Anforderungen angepasst werden.

Bereitstellungsoptionen

Wir bieten verschiedene Bereitstellungsoptionen für unterschiedliche Kundenanwendungsfälle. Hier können Sie auswählen, mit welchen AWS-Services Sie Ihre Kubeflow-Bereitstellung integrieren möchten. Wenn Sie sich später entscheiden, die Bereitstellungsoptionen zu ändern, empfehlen wir Ihnen, eine Neuinstallation für die neue Bereitstellung durchzuführen. Die folgenden Bereitstellungsoptionen sind verfügbar:

Wenn Sie Kubeflow mit minimalen Änderungen bereitstellen möchten, sollten Sie die Vanille Bereitstellungsoption. Alle verfügbaren Bereitstellungsoptionen können mit Kustomize, Helm oder Terraform installiert werden.

Wir haben auch verschiedene Add-On-Bereitstellungen, die zusätzlich zu diesen Bereitstellungsoptionen installiert werden können:

Installationsoptionen

Nachdem Sie entschieden haben, welche Bereitstellungsoption Ihren Anforderungen am besten entspricht, können Sie auswählen, wie Sie diese Bereitstellungen installieren möchten. Um Experten und Neueinsteiger gleichermaßen zu bedienen, haben wir verschiedene Automatisierungs- und Konfigurationsstufen.

Option 1: Terraform (IaC)

Dadurch wird ein EKS-Cluster und alle zugehörigen AWS-Infrastrukturressourcen erstellt und dann Kubeflow in einem Befehl mit Terraform bereitgestellt. Intern verwendet dies EKS-Blueprints und Helm-Charts.

Diese Option hat folgende Vorteile:

• Es bietet Unternehmen die Flexibilität, Amazon EKS und Kubeflow mit einem Befehl bereitzustellen, ohne sich um bestimmte Kubeflow-Komponentenkonfigurationen kümmern zu müssen. Dies wird immens dazu beitragen, die Technologiebewertung, das Prototyping und den Produktentwicklungslebenszyklus zu beschleunigen und bietet die Flexibilität, Terraform-Module zu verwenden und sie an projektspezifische Anforderungen anzupassen.
• Viele Organisationen, die heute Terraform als Mittelpunkt ihrer Cloud-Strategie haben, können jetzt die Terraform-Lösung von Kubeflow auf AWS verwenden, um ihre Cloud-Ziele zu erreichen.

Option 2: Anpassen oder Helm-Diagramme:

Mit dieser Option können Sie Kubeflow in einem zweistufigen Prozess bereitstellen:

1. Erstellen Sie AWS-Ressourcen wie Amazon EKS, Amazon RDS, Amazon S3 und Amazon Cognito entweder über die in der AWS-Distribution enthaltenen automatisierten Skripts oder manuell nach a Schritt-für-Schritt-Anleitung.
2. Installieren Sie Kubeflow-Bereitstellungen entweder mit Helm-Diagrammen oder Kustomize.

Diese Option hat folgende Vorteile:

• Das Hauptziel dieser Installationsoption besteht darin, Kubeflow-bezogene Kubernetes-Konfigurationen bereitzustellen. Daher können Sie vorhandene EKS-Cluster oder eine der zugehörigen AWS-Ressourcen wie Amazon RDS, Amazon S3 und Amazon Cognito erstellen oder einbinden und sie für die Arbeit mit Kubeflow auf AWS konfigurieren und verwalten.
• Es ist einfacher, von einem Kustomize Kubeflow-Open-Source-Manifest zu einer AWS Kubeflow-Distribution zu wechseln.

Das folgende Diagramm veranschaulicht die Architekturen beider Optionen.

Integration mit SageMaker

SageMaker ist ein vollständig verwalteter Dienst, der speziell für die Verwaltung von ML-Workflows entwickelt und optimiert wurde. Es beseitigt das undifferenzierte schwere Heben der Infrastrukturverwaltung und beseitigt die Notwendigkeit, in IT und DevOps zu investieren, um Cluster für die Erstellung, Schulung und Inferenz von ML-Modellen zu verwalten.

Viele AWS-Kunden mit Portabilitätsanforderungen oder lokalen Standardeinschränkungen verwenden Amazon EKS, um wiederholbare ML-Pipelines einzurichten, die Trainings- und Inferenz-Workloads ausführen. Dies erfordert jedoch, dass Entwickler benutzerdefinierten Code schreiben, um die zugrunde liegende ML-Infrastruktur zu optimieren, hohe Verfügbarkeit und Zuverlässigkeit bereitzustellen und die entsprechenden Sicherheits- und Regulierungsanforderungen einzuhalten. Diese Kunden möchten daher SageMaker für eine kostenoptimierte und verwaltete Infrastruktur für Modelltraining und -bereitstellungen verwenden und weiterhin Kubernetes für die Orchestrierung und ML-Pipelines verwenden, um Standardisierung und Portabilität beizubehalten.

Um diesem Bedarf gerecht zu werden, ermöglicht Ihnen AWS das Trainieren, Optimieren und Bereitstellen von Modellen in SageMaker von Amazon EKS, indem Sie die folgenden zwei Optionen verwenden:

• Amazon SageMaker ACK-Operatoren für Kubernetes, die auf der AWS-Controller für Kubernetes (ACK)-Framework. ACK ist die AWS-Strategie, die eine Standardisierung für die Erstellung benutzerdefinierter Kubernetes-Controller einführt, die es Kubernetes-Benutzern ermöglichen, AWS-Ressourcen wie Datenbanken oder Nachrichtenwarteschlangen einfach über die Kubernetes-API bereitzustellen. SageMaker ACK-Operatoren erleichtern ML-Entwicklern und Datenwissenschaftlern, die Kubernetes als Steuerungsebene verwenden, das Trainieren, Optimieren und Bereitstellen von ML-Modellen in SageMaker, ohne sich bei der SageMaker-Konsole anzumelden.
• Das SageMaker-Komponenten für Kubeflow-Pipelines, mit denen Sie SageMaker mit der Portabilität und Orchestrierung von Kubeflow-Pipelines integrieren können. Mit den SageMaker-Komponenten wird jeder Job im Pipeline-Workflow auf SageMaker statt auf dem lokalen Kubernetes-Cluster ausgeführt. Auf diese Weise können Sie native SageMaker-Trainings-, Tuning-, Endpunktbereitstellungs- und Batch-Transformationsjobs aus Ihren Kubeflow-Pipelines erstellen und überwachen, wodurch Sie die gesamte Rechenleistung einschließlich Datenverarbeitungs- und Trainingsjobs aus dem Kubernetes-Cluster in den für maschinelles Lernen optimierten Managed Service von SageMaker verschieben können.

Ab Kubeflow on AWS v1.6.1 vereinen alle verfügbaren Kubeflow-Bereitstellungsoptionen standardmäßig beide Amazon SageMaker-Integrationsoptionen auf einer Plattform. Das bedeutet, dass Sie jetzt SageMaker-Jobs mit SageMaker-ACK-Operatoren von einem Kubeflow-Notebook-Server selbst senden können, indem Sie die benutzerdefinierte SageMaker-Ressource oder den Kubeflow-Pipelineschritt mit SageMaker-Komponenten senden.

Es gibt zwei Versionen von SageMaker-Komponenten – Boto3 (AWS SDK for AWS SDK for Python)-basierte Version 1-Komponenten und SageMaker Operator for K8s (ACK)-basierte Version 2-Komponenten. Die neue Version 2 der SageMaker-Komponenten unterstützt die neuesten SageMaker-Trainings-APIs, und wir werden dieser Version der Komponente weitere SageMaker-Funktionen hinzufügen. Sie haben jedoch die Flexibilität, Sagemaker-Komponenten Version 2 für Schulungen und Version 1 für andere SageMaker-Funktionen wie Hyperparameter-Tuning, Verarbeitung von Jobs, Hosting und vieles mehr zu kombinieren.

Integration mit Prometheus und Grafana

Prometheus ist ein Open-Source-Tool zur Aggregation von Metriken, das Sie für die Ausführung auf Kubernetes-Clustern konfigurieren können. Bei der Ausführung auf Kubernetes-Clustern kratzt ein Prometheus-Hauptserver regelmäßig Pod-Endpunkte.

Kubeflow-Komponenten wie Kubeflow Pipelines (KFP) und Notebook geben Prometheus-Metriken aus, um die Überwachung von Komponentenressourcen wie der Anzahl der ausgeführten Experimente oder der Anzahl der Notebooks zu ermöglichen.

Diese Metriken können von einem Prometheus-Server, der im Kubernetes-Cluster ausgeführt wird, aggregiert und mit Prometheus Query Language (PromQL) abgefragt werden. Weitere Einzelheiten zu den von Prometheus unterstützten Funktionen finden Sie unter Prometheus-Dokumentation.

Die Kubeflow on AWS-Distribution bietet Unterstützung für die Integration mit den folgenden verwalteten AWS-Services:

1. Amazon Managed Prometheus (AMP), das ist ein Prometheus-kompatibler Überwachungsdienst für Containerinfrastruktur und Anwendungsmetriken für Container, der es Kunden erleichtert, Containerumgebungen in großem Umfang sicher zu überwachen. Mit AMP können Sie Ihre Metriken, Protokolle und Traces, die aus mehreren Datenquellen in Ihrem Observability-System gesammelt wurden, einschließlich AWS, ISVs von Drittanbietern und anderen Ressourcen in Ihrem IT-Portfolio, visualisieren, analysieren und alarmieren.
2. Amazon Managed Grafana, ein vollständig verwalteter und sicherer Datenvisualisierungsdienst auf Basis von Open Source Grafana Projekt, das es Kunden ermöglicht, Betriebsmetriken, Protokolle und Ablaufverfolgungen für ihre Anwendungen aus mehreren Datenquellen sofort abzufragen, zu korrelieren und zu visualisieren. Amazon Managed Grafana entlastet die Betriebsverwaltung von Grafana, indem es die Rechen- und Datenbankinfrastruktur automatisch skaliert, wenn die Nutzungsanforderungen steigen, mit automatisierten Versionsaktualisierungen und Sicherheitspatches.

Die Kubeflow-on-AWS-Distribution bietet Unterstützung für die Integration von Amazon Managed Service for Prometheus und Amazon Managed Grafana, um die sichere Aufnahme und Visualisierung von Prometheus-Metriken in großem Umfang zu erleichtern.

Die folgenden Metriken werden erfasst und können visualisiert werden:

• Metriken, die von Kubeflow-Komponenten wie Kubeflow-Pipelines und dem Notebook-Server ausgegeben werden
• Kubeflow Kontrollebenenmetriken

Informationen zum Konfigurieren von Amazon Managed Service for Prometheus und Amazon Managed Grafana für Ihren Kubeflow-Cluster finden Sie unter Verwenden Sie Prometheus, Amazon Managed Service for Prometheus und Amazon Managed Grafana, um Metriken mit Kubeflow auf AWS zu überwachen.

Lösungsüberblick

In diesem Anwendungsfall verwenden wir die Kubeflow-Vanilla-Bereitstellung mit der Terraform-Installationsoption. Wenn die Installation abgeschlossen ist, melden wir uns beim Kubeflow-Dashboard an. Vom Dashboard aus starten wir einen Kubeflow Jupyter-Notebook-Server, um eine Kubeflow-Pipeline zu erstellen, die SageMaker verwendet, um verteiltes Training für ein Bildklassifizierungsmodell und einen SageMaker-Endpunkt für die Modellbereitstellung auszuführen.

Voraussetzungen:

Stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

• Du hast ein AWS-Konto.
• Stellen Sie sicher, dass Sie in der us-west-2 Region zum Ausführen dieses Beispiels.
• Verwenden Sie Google Chrome für die Interaktion mit dem AWS-Managementkonsole und Kubeflow.
• Stellen Sie sicher, dass Ihr Konto das SageMaker Training-Ressourcentyp-Limit für ml.p3.2xlarge mithilfe der Service-Quotas-Konsole auf 2 erhöht hat.
• Optional können Sie AWS Cloud9, eine Cloud-basierte integrierte Entwicklungsumgebung (IDE), die es ermöglicht, die gesamte Arbeit von Ihrem Webbrowser aus zu erledigen. Anweisungen zur Einrichtung finden Sie unter Richten Sie die Cloud9-IDE ein. Wählen Sie Ubuntu Server 18.04 als Plattform in den AWS Cloud9-Einstellungen aus.Wählen Sie dann in Ihrer AWS Cloud9-Umgebung das Pluszeichen und öffnen Sie ein neues Terminal.

Sie konfigurieren auch eine AWS-Befehlszeilenschnittstelle (AWS CLI)-Profil. Dazu benötigen Sie eine Zugangsschlüssel-ID und einen geheimen Zugangsschlüssel von an AWS Identity and Access Management and (ICH BIN) Benutzer Konto mit Administratorrechten (hängen Sie die vorhandene verwaltete Richtlinie an) und programmgesteuertem Zugriff. Siehe folgenden 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

Überprüfen Sie die Berechtigungen, die cloud9 zum Aufrufen von AWS-Ressourcen verwendet.

aws sts get-caller-identity

Vergewissern Sie sich anhand der folgenden Ausgabe, dass Sie arn des Admin-Benutzers sehen, den Sie im AWS CLI-Profil konfiguriert haben. In diesem Beispiel ist es „kubeflow-user“.

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

Installieren Sie Amazon EKS und Kubeflow auf AWS

Führen Sie die folgenden Schritte aus, um Amazon EKS und Kubeflow auf AWS zu installieren:

1. Richten Sie Ihre Umgebung für die Bereitstellung von Kubeflow auf AWS ein:

   #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. Stellen Sie die Vanilla-Version von Kubeflow auf AWS und verwandten AWS-Ressourcen wie EKS mit Terraform bereit. Bitte beachten Sie, dass in der EKS-Knotengruppe verwendete EBS-Volumes standardmäßig nicht verschlüsselt sind:

   #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

Richten Sie die Kubeflow-Berechtigungen ein

1. Fügen Sie dem Notebook-Pod und dem Pipeline-Komponenten-Pod Berechtigungen hinzu, um SageMaker-, S3- und IAM-API-Aufrufe zu verwenden kubeflow_iam_permissions.sh Skripte.

   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. Erstellen Sie eine SageMaker-Ausführungsrolle, damit der SageMaker-Trainingsjob über den S3-Dienst auf das Trainingsdataset zugreifen kann sagemaker_role.sh Skripte.

   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

Greifen Sie auf das Kubeflow-Dashboard zu

Führen Sie die folgenden Schritte aus, um auf das Kubeflow-Dashboard zuzugreifen:

1. Sie können das Kubeflow-Dashboard lokal in der Cloud9-Umgebung ausführen, ohne Ihre URLs dem öffentlichen Internet zugänglich zu machen, indem Sie die folgenden Befehle ausführen.

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

2. Auswählen Vorschau der laufenden Anwendung.
3. Wählen Sie das Symbol in der Ecke des Kubeflow-Dashboards, um es als separate Registerkarte in Chrome zu öffnen.
4. Geben Sie die Standardanmeldeinformationen ein (user@example.com/12341234), um sich beim Kubeflow-Dashboard anzumelden.

Richten Sie die Kubeflow-on-AWS-Umgebung ein

Nachdem Sie sich beim Kubeflow-Dashboard angemeldet haben, stellen Sie sicher, dass Sie den richtigen Namespace haben (kubeflow-user-example-com) gewählt. Führen Sie die folgenden Schritte aus, um Ihre Kubeflow-on-AWS-Umgebung einzurichten:

1. Wählen Sie im Kubeflow-Dashboard aus Notizbücher im Navigationsbereich.
2. Auswählen Neues Notizbuch.
3. Aussichten für Name und Vorname, eingeben aws-nb.
4. Aussichten für Jupyter-Docket-Image, wählen Sie das Bild aus jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (das neuste verfügbare jupyter-pytorch DLC-Bild).
5. Aussichten für CPU, eingeben 1.
6. Aussichten für Memory, eingeben 5.
7. Aussichten für GPUs, verlassen als Andere.
8. Nehmen Sie keine Änderungen an der vor Arbeitsplatz und Datenvolumen .
9. Auswählen Zugriff auf Kubeflow-Pipelines zulassen der Konfigurationen Abschnitt und wählen Sie Starten.
10. Vergewissern Sie sich, dass Ihr Notizbuch erfolgreich erstellt wurde (dies kann einige Minuten dauern).
11. Auswählen Vernetz Dich um sich bei JupyterLab anzumelden.
12. Klonen Sie das Repo, indem Sie es eingeben https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git der Klonen Sie ein Repo Feld.
13. Auswählen Clone.

Führen Sie ein verteiltes Trainingsbeispiel aus

Nachdem Sie das Jupyter-Notebook eingerichtet haben, können Sie die gesamte Demo mithilfe der folgenden allgemeinen Schritte aus dem Ordner ausführen eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training im geklonten Repository:

1. Führen Sie das PyTorch Distributed Data Parallel (DDP)-Trainingsskript aus – Siehe PyTorch DDP-Schulungsskript cifar10-distributed-gpu-final.py, das ein Beispiel für ein Convolutional Neural Network und eine Logik enthält, um das Training auf einem CPU- und GPU-Cluster mit mehreren Knoten zu verteilen.
2. Erstellen Sie eine Kubeflow-Pipeline – Führen Sie das Notebook aus STEP1.0_create_pipeline_k8s_sagemaker.ipynb um eine Pipeline zu erstellen, die Modelle auf SageMaker ausführt und bereitstellt. Stellen Sie sicher, dass Sie die SageMaker-Bibliothek als Teil der ersten Notebook-Zelle installieren und den Kernel neu starten, bevor Sie die restlichen Notebook-Zellen ausführen.
3. Rufen Sie einen SageMaker-Endpunkt auf – Führen Sie das Notebook aus STEP1.1_invoke_sagemaker_endpoint.ipynb zum Aufrufen und Testen des SageMaker-Modellrückschlussendpunkts, der im vorherigen Notebook erstellt wurde.

In den folgenden Abschnitten besprechen wir jeden dieser Schritte im Detail.

Führen Sie das PyTorch DDP-Trainingsskript aus

Als Teil des verteilten Trainings trainieren wir ein Klassifizierungsmodell, das von einem einfachen Convolutional Neural Network erstellt wurde, das auf dem CIFAR10-Datensatz arbeitet. Das Trainingsskript cifar10-distributed-gpu-final.py enthält nur die Open-Source-Bibliotheken und ist kompatibel, um sowohl auf Kubernetes- als auch auf SageMaker-Trainingsclustern auf GPU-Geräten oder CPU-Instanzen ausgeführt zu werden. Sehen wir uns einige wichtige Aspekte des Trainingsskripts an, bevor wir unsere Notebook-Beispiele ausführen.

Wir nutzen die torch.distributed -Modul, das PyTorch-Unterstützung und Kommunikationsprimitive für Multiprozess-Parallelität über Knoten im Cluster enthält:

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

Wir erstellen ein einfaches Bildklassifizierungsmodell unter Verwendung einer Kombination aus Faltungs-, Max-Pooling- und linearen Schichten, zu denen a relu Die Aktivierungsfunktion wird im Vorwärtsdurchgang des Modelltrainings angewendet:

# 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

Wenn der Trainingscluster über GPUs verfügt, führt das Skript das Training auf CUDA-Geräten aus und die Gerätevariable enthält das standardmäßige CUDA-Gerät:

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

Bevor Sie verteiltes Training mit PyTorch ausführen DistributedDataParallel Um die verteilte Verarbeitung auf mehreren Knoten auszuführen, müssen Sie die verteilte Umgebung durch einen Aufruf initialisieren init_process_group. Dieser wird auf jeder Maschine des Trainingsclusters initialisiert.

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

Wir instanziieren das Klassifikatormodell und kopieren das Modell auf das Zielgerät. Wenn das verteilte Training aktiviert ist, um auf mehreren Knoten ausgeführt zu werden, wird die DistributedDataParallel -Klasse wird als Wrapper-Objekt um das Modellobjekt herum verwendet, was ein synchron verteiltes Training über mehrere Computer ermöglicht. Die Eingabedaten werden nach Chargendimension aufgeteilt und eine Kopie des Modells wird auf jeder Maschine und jedem Gerät platziert. Siehe folgenden Code:

model = Net().to(device)

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

...

Erstellen Sie eine Kubeflow-Pipeline

Das Notebook verwendet die Kubeflow Pipelines-SDK und den bereitgestellten Satz von Python-Paketen zum Angeben und Ausführen der ML-Workflow-Pipelines. Als Teil dieses SDK verwenden wir den Paket-Decorator für domänenspezifische Sprachen (DSL). dsl.pipeline, das die Python-Funktionen dekoriert, um eine Pipeline zurückzugeben.

Die Kubeflow-Pipeline verwendet die SageMaker-Komponente V2 zum Senden von Schulungen an SageMaker mithilfe von SageMaker-ACK-Operatoren. Die SageMaker-Modellerstellung und -Modellbereitstellung verwendet die SageMaker-Komponente V1, bei der es sich um Boto3-basierte SageMaker-Komponenten handelt. Wir verwenden in diesem Beispiel eine Kombination aus beiden Komponenten, um die Flexibilität zu demonstrieren, die Sie bei der Auswahl haben.

1. Laden Sie die SageMaker-Komponenten mit dem folgenden 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')

   Im folgenden Code erstellen wir die Kubeflow-Pipeline, in der wir das verteilte SageMaker-Training mit zwei ausführen ml.p3.2xlarge Instanzen:

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

   Nachdem die Pipeline definiert wurde, können Sie die Pipeline mithilfe der Kubeflow Pipelines SDKs in eine Argo YAML-Spezifikation kompilieren kfp.compiler Paket. Sie können diese Pipeline mit dem Kubeflow Pipelines SDK-Client ausführen, der den Pipelines-Dienstendpunkt aufruft und die entsprechenden Authentifizierungsheader direkt vom Notebook übergibt. Siehe folgenden 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. Wähle die Ausführungsdetails Link unter der letzten Zelle, um die Kubeflow-Pipeline anzuzeigen. Der folgende Screenshot zeigt unsere Pipeline-Details für die SageMaker-Schulungs- und Bereitstellungskomponente.
3. Wählen Sie den Trainingsjob-Schritt und auf der Logs Wählen Sie auf der Registerkarte CloudWatch logs den Link CloudWatch logs aus, um auf die SageMaker-Protokolle zuzugreifen.
   Der folgende Screenshot zeigt die CloudWatch-Protokolle für jede der beiden ml.p3.2xlarge-Instanzen.
4. Wählen Sie eine der Gruppen aus, um die Protokolle anzuzeigen.
5. Erfassen Sie den SageMaker-Endpunkt, indem Sie die auswählen Sagemaker – Bereitstellungsmodell Schritt und Kopieren der endpoint_name Artefaktwert ausgeben.

Rufen Sie einen SageMaker-Endpunkt auf

Das Notebook STEP1.1_invoke_sagemaker_endpoint.ipynb ruft den im vorherigen Schritt erstellten SageMaker-Inferenzendpunkt auf. Stellen Sie sicher, dass Sie den Endpunktnamen aktualisieren:

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

Aufräumen

Führen Sie die folgenden Schritte aus, um Ihre Ressourcen zu bereinigen:

1. Führen Sie die folgenden Befehle in AWS Cloud9 aus, um die AWS-Ressourcen zu löschen:

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

2. IAM-Rolle löschen „sagemakerrole“ mit dem folgenden AWS CLI-Befehl:

   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. Löschen Sie den SageMaker-Endpunkt mit dem folgenden AWS CLI-Befehl:

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

Zusammenfassung

In diesem Beitrag haben wir den Wert hervorgehoben, den Kubeflow auf AWS 1.6.1 durch native AWS-verwaltete Service-Integrationen bietet, um die Anforderungen von KI- und ML-Anwendungsfällen auf Unternehmensebene zu erfüllen. Sie können aus mehreren Bereitstellungsoptionen wählen, um Kubeflow auf AWS mit verschiedenen Service-Integrationen mit Terraform, Kustomize oder Helm zu installieren. Der Anwendungsfall in diesem Beitrag demonstriert eine Kubeflow-Integration mit SageMaker, die einen von SageMaker verwalteten Schulungscluster verwendet, um verteilte Schulungen für ein Bildklassifizierungsmodell und einen SageMaker-Endpunkt für die Modellbereitstellung auszuführen.

Wir haben auch zur Verfügung gestellt Beispiel-Pipeline-Beispiel das die neuesten SageMaker-Komponenten verwendet; Sie können dies direkt über das Kubeflow-Dashboard ausführen. Diese Pipeline erfordert die Amazon S3-Daten und SageMaker-Ausführungs-IAM-Rolle als erforderliche Eingaben.

Um mit Kubeflow auf AWS zu beginnen, lesen Sie die verfügbaren AWS-integrierten Bereitstellungsoptionen in Kubeflow auf AWS. Sie können dem folgen AWS Labs-Repository um alle AWS-Beiträge zu Kubeflow zu verfolgen. Sie finden uns auch auf der Kubeflow #AWS Slack-Channel; Ihr Feedback dort wird uns helfen, die nächsten Funktionen zu priorisieren, die zum Kubeflow-Projekt beitragen.

Über die Autoren

Kanwaljit Khurmi ist Senior Solutions Architect bei Amazon Web Services. Er arbeitet mit den AWS-Kunden zusammen, um Anleitungen und technische Unterstützung bereitzustellen, die ihnen helfen, den Wert ihrer Lösungen bei der Verwendung von AWS zu verbessern. Kanwaljit ist darauf spezialisiert, Kunden mit containerisierten und maschinellen Lernanwendungen zu unterstützen.

Kartik Kalamadi ist Softwareentwicklungsingenieur bei Amazon AI. Derzeit konzentriert er sich auf Kubernetes-Open-Source-Projekte für maschinelles Lernen wie Kubeflow und AWS SageMaker Controller für k8s. In meiner Freizeit spiele ich gerne PC-Spiele und fummele mit der Unity-Engine an VR herum.

Raul Kharse ist Softwareentwicklungsingenieur bei Amazon Web Services. Seine Arbeit konzentriert sich auf die Integration von AWS-Services mit Open-Source-Container-ML-Ops-Plattformen, um deren Skalierbarkeit, Zuverlässigkeit und Sicherheit zu verbessern. Rahul konzentriert sich nicht nur auf Kundenwünsche nach Funktionen, sondern experimentiert auch gerne mit den neuesten technologischen Entwicklungen auf diesem Gebiet.