Activation des workflows ML hybrides sur Amazon EKS et Amazon SageMaker avec le déploiement en un clic de Kubeflow sur AWS

Aujourd'hui, de nombreux clients AWS créent des plates-formes d'apprentissage automatique (ML) prêtes pour l'entreprise sur Service Amazon Elastic Kubernetes (Amazon EKS) en utilisant Kubeflow sur AWS (une distribution de Kubeflow spécifique à AWS) dans de nombreux cas d'utilisation, notamment la vision par ordinateur, la compréhension du langage naturel, la traduction vocale et la modélisation financière.

Avec la dernière version de Kubeflow v1.6.1 open source, la communauté Kubeflow continue de soutenir cette adoption à grande échelle de Kubeflow pour les cas d'utilisation en entreprise. La dernière version comprend de nombreuses nouvelles fonctionnalités intéressantes telles que la prise en charge de Kubernetes v1.22, le SDK Python combiné pour PyTorch, MXNet, MPI, XGBoost dans l'opérateur de formation distribué de Kubeflow, les nouveaux CRD ClusterServingRuntime et ServingRuntime pour le service de modèle, et bien d'autres.

Les contributions d'AWS à Kubeflow avec le récent lancement de Kubeflow sur AWS 1.6.1 prennent en charge toutes les fonctionnalités Kubeflow open source en amont et incluent de nombreuses nouvelles intégrations avec les services AWS hautement optimisés, natifs du cloud et prêts pour l'entreprise qui vous aideront à créer des des systèmes de ML sécurisés, portables et évolutifs.

Dans cet article, nous discutons des nouvelles fonctionnalités de Kubeflow sur AWS v1.6.1 et mettons en évidence trois intégrations importantes qui ont été regroupées sur une seule plateforme pour vous offrir :

• Solution en un clic d'infrastructure en tant que code (IaaC) qui automatise l'installation de bout en bout de Kubeflow, y compris la création de cluster EKS
• Prise en charge de la formation distribuée sur Amazon Sage Maker en utilisant Opérateurs Amazon SageMaker pour Kubernetes (ACK) et Composants SageMaker pour les pipelines Kubeflow et localement sur Kubernetes en utilisant Opérateurs de formation Kubeflow. De nombreux clients utilisent cette capacité pour créer des architectures d'apprentissage automatique hybrides dans lesquelles ils exploitent à la fois le calcul Kubernetes pour la phase d'expérimentation et SageMaker pour exécuter des charges de travail à l'échelle de la production.
• Surveillance et observabilité améliorées pour les charges de travail ML, y compris Amazon EKS, les métriques Kubeflow et les journaux d'application à l'aide de Prometheus, Grafana et Amazon Cloud Watch intégrations

Le cas d'utilisation de ce blog se concentrera spécifiquement sur l'intégration de SageMaker avec Kubeflow sur AWS qui pourrait être ajoutée à vos flux de travail Kubernetes existants vous permettant de créer des architectures d'apprentissage automatique hybrides.

Kubeflow sur AWS

Kubeflow sur AWS 1.6.1 fournit un chemin clair pour utiliser Kubeflow, avec l'ajout des services AWS suivants en plus des fonctionnalités existantes :

• Intégration SageMaker avec Kubeflow pour exécuter des workflows ML hybrides à l'aide des opérateurs SageMaker pour Kubernetes (ACK) et des composants SageMaker pour les pipelines Kubeflow.
• Les options de déploiement automatisé ont été améliorées et simplifiées à l'aide de scripts Kustomize et de graphiques Helm.
• Ajout de la prise en charge du déploiement en un clic d'Infrastructure as Code (IaC) pour Kubeflow sur AWS à l'aide de Terraform pour tous les éléments disponibles options de déploiement. Ce script automatise la création des ressources AWS suivantes :
• Support pour Lien privé AWS pour Amazon S3 permettant aux utilisateurs régionaux non commerciaux de se connecter à leurs points de terminaison S3 respectifs.
• Ajout de l'intégration avec Service géré Amazon pour Prometheus (AMP) et Grafana géré par Amazon pour surveiller les métriques avec Kubeflow sur AWS.
• Mise à jour des conteneurs de serveur de bloc-notes Kubeflow avec les dernières images de conteneur d'apprentissage en profondeur basées sur TensorFlow 2.10.0 et PyTorch 1.12.1.
• Intégration avec les DLC AWS pour une exécution distribuée Formation ainsi que inférence charges de travail.

Le diagramme d'architecture suivant est un aperçu rapide de toutes les intégrations de services (y compris celles déjà mentionnées) qui sont disponibles pour les composants de contrôle et de plan de données Kubeflow dans Kubeflow sur AWS. Le plan de contrôle Kubeflow est installé au-dessus d'Amazon EKS, qui est un service de conteneur géré utilisé pour exécuter et faire évoluer les applications Kubernetes dans le cloud. Ces intégrations de services AWS vous permettent de dissocier les parties critiques du plan de contrôle Kubeflow de Kubernetes, offrant une conception sécurisée, évolutive, résiliente et optimisée en termes de coûts. Pour plus de détails sur la valeur que ces intégrations de services ajoutent à Kubeflow open source, consultez Créez et déployez un système de machine learning évolutif sur Kubernetes avec Kubeflow sur AWS.

Discutons plus en détail de la façon dont les fonctionnalités clés de Kubeflow sur AWS 1.6.1 pourraient être utiles à votre organisation.

Détails des fonctionnalités de Kubeflow sur AWS

Avec la version 1.6.1 de Kubeflow, nous avons essayé de fournir de meilleurs outils pour différents types de clients qui facilitent la prise en main de Kubeflow, quelles que soient les options que vous choisissez. Ces outils fournissent un bon point de départ et peuvent être modifiés pour répondre à vos besoins précis.

Options de déploiement

Nous fournissons différentes options de déploiement pour différents cas d'utilisation client. Ici, vous pouvez choisir les services AWS avec lesquels vous souhaitez intégrer votre déploiement Kubeflow. Si vous décidez de modifier les options de déploiement ultérieurement, nous vous recommandons d'effectuer une nouvelle installation pour le nouveau déploiement. Les options de déploiement suivantes sont disponibles :

Si vous souhaitez déployer Kubeflow avec des changements minimes, considérez le vanille possibilité de déploiement. Toutes les options de déploiement disponibles peuvent être installées à l'aide de Kustomize, Helm ou Terraform.

Nous proposons également différents déploiements de modules complémentaires qui peuvent être installés en plus de l'une de ces options de déploiement :

Options d'installation

Une fois que vous avez décidé quelle option de déploiement correspond le mieux à vos besoins, vous pouvez choisir comment vous souhaitez installer ces déploiements. Dans un effort pour servir les experts et les nouveaux arrivants, nous avons différents niveaux d'automatisation et de configuration.

Option 1 : Terraform (IaC)

Cela crée un cluster EKS et toutes les ressources d'infrastructure AWS associées, puis déploie Kubeflow en une seule commande à l'aide de Terraform. En interne, cela utilise des plans EKS et des graphiques Helm.

Cette option présente les avantages suivants :

• Il offre aux entreprises la flexibilité de déployer Amazon EKS et Kubeflow avec une seule commande sans avoir à se soucier des configurations de composants Kubeflow spécifiques. Cela aidera énormément à accélérer l'évaluation de la technologie, le prototypage et le cycle de vie du développement du produit, offrant la flexibilité d'utiliser les modules terraform et de le modifier pour répondre à tous les besoins spécifiques au projet.
• Aujourd'hui, de nombreuses organisations qui placent Terraform au centre de leur stratégie cloud peuvent désormais utiliser Kubeflow sur la solution AWS Terraform pour atteindre leurs objectifs cloud.

Option 2 : Kustomize ou Helm Charts :

Cette option vous permet de déployer Kubeflow en deux étapes :

1. Créez des ressources AWS comme Amazon EKS, Amazon RDS, Amazon S3 et Amazon Cognito, soit via les scripts automatisés inclus dans la distribution AWS, soit manuellement en suivant un étape par étape.
2. Installez les déploiements Kubeflow à l'aide des chartes Helm ou de Kustomize.

Cette option présente les avantages suivants :

• L'objectif principal de cette option d'installation est de fournir des configurations Kubernetes liées à Kubeflow. Par conséquent, vous pouvez choisir de créer ou d'intégrer des clusters EKS existants ou l'une des ressources AWS associées comme Amazon RDS, Amazon S3 et Amazon Cognito, et de le configurer et de le gérer pour qu'il fonctionne avec Kubeflow sur AWS.
• Il est plus facile de passer d'un manifeste open source Kustomize Kubeflow à une distribution AWS Kubeflow.

Le diagramme suivant illustre les architectures des deux options.

Intégration avec SageMaker

SageMaker est un service entièrement géré conçu et optimisé spécifiquement pour la gestion des flux de travail ML. Il supprime les lourdes charges indifférenciées de la gestion de l'infrastructure et élimine le besoin d'investir dans l'informatique et le DevOps pour gérer les clusters pour la création de modèles ML, la formation et l'inférence.

De nombreux clients AWS qui ont des exigences de portabilité ou des restrictions standard sur site utilisent Amazon EKS pour configurer des pipelines ML reproductibles exécutant des charges de travail de formation et d'inférence. Cependant, cela nécessite que les développeurs écrivent du code personnalisé pour optimiser l'infrastructure ML sous-jacente, fournir une disponibilité et une fiabilité élevées et se conformer aux exigences de sécurité et réglementaires appropriées. Ces clients souhaitent donc utiliser SageMaker pour une infrastructure gérée et optimisée en termes de coûts pour la formation et les déploiements de modèles et continuer à utiliser Kubernetes pour l'orchestration et les pipelines ML afin de conserver la standardisation et la portabilité.

Pour répondre à ce besoin, AWS vous permet de former, d'ajuster et de déployer des modèles dans SageMaker à partir d'Amazon EKS en utilisant les deux options suivantes :

• Les opérateurs Amazon SageMaker ACK pour Kubernetes, qui sont basés sur le Contrôleurs AWS pour Kubernetes (ACK). ACK est la stratégie AWS qui apporte la normalisation pour la création de contrôleurs personnalisés Kubernetes qui permettent aux utilisateurs de Kubernetes de provisionner des ressources AWS telles que des bases de données ou des files d'attente de messages simplement en utilisant l'API Kubernetes. Les opérateurs SageMaker ACK permettent aux développeurs ML et aux data scientists qui utilisent Kubernetes comme plan de contrôle de former, régler et déployer plus facilement des modèles ML dans SageMaker sans se connecter à la console SageMaker.
• La Composants SageMaker pour les pipelines Kubeflow, qui vous permettent d'intégrer SageMaker à la portabilité et à l'orchestration de Kubeflow Pipelines. Avec les composants SageMaker, chaque tâche du workflow du pipeline s'exécute sur SageMaker au lieu du cluster Kubernetes local. Cela vous permet de créer et de surveiller des tâches natives de formation, de réglage, de déploiement de points de terminaison et de transformation par lots SageMaker à partir de vos pipelines Kubeflow, vous permettant ainsi de déplacer le calcul complet, y compris les tâches de traitement de données et de formation, du cluster Kubernetes vers le service géré optimisé pour l'apprentissage automatique de SageMaker.

À partir de Kubeflow sur AWS v1.6.1, toutes les options de déploiement Kubeflow disponibles regroupent les deux options d'intégration Amazon SageMaker par défaut sur une seule plateforme. Cela signifie que vous pouvez désormais soumettre des tâches SageMaker à l'aide des opérateurs SageMaker ACK à partir d'un serveur Kubeflow Notebook lui-même en soumettant la ressource SageMaker personnalisée ou à partir de l'étape du pipeline Kubeflow à l'aide des composants SageMaker.

Il existe deux versions des composants SageMaker - Boto3 (AWS SDK pour AWS SDK pour Python) composants basés sur la version 1 et SageMaker Operator for K8s (ACK) composants basés sur la version 2. La nouvelle version 2 des composants SageMaker prend en charge les dernières API de formation SageMaker et nous continuerons à ajouter d'autres fonctionnalités SageMaker à cette version du composant. Vous avez cependant la possibilité de combiner les composants Sagemaker version 2 pour la formation et la version 1 pour d'autres fonctionnalités SageMaker telles que le réglage des hyperparamètres, le traitement des tâches, l'hébergement et bien d'autres.

Intégration avec Prometheus et Grafana

Prometheus est un outil d'agrégation de métriques open source que vous pouvez configurer pour s'exécuter sur des clusters Kubernetes. Lors de l'exécution sur des clusters Kubernetes, un serveur Prometheus principal récupère périodiquement les points de terminaison des pods.

Les composants Kubeflow, tels que Kubeflow Pipelines (KFP) et Notebook, émettent des métriques Prometheus pour permettre de surveiller les ressources des composants telles que le nombre d'expériences en cours ou le nombre de notebooks.

Ces métriques peuvent être agrégées par un serveur Prometheus exécuté dans le cluster Kubernetes et interrogées à l'aide du langage de requête Prometheus (PromQL). Pour plus de détails sur les fonctionnalités prises en charge par Prometheus, consultez le Documentation Prometheus.

La distribution Kubeflow sur AWS prend en charge l'intégration avec les services gérés AWS suivants :

1. Amazon Managed Prometheus (AMP) qui est un Prométhée-service de surveillance compatible pour l'infrastructure de conteneurs et les métriques d'application pour les conteneurs qui permettent aux clients de surveiller facilement et en toute sécurité les environnements de conteneurs à grande échelle. À l'aide d'AMP, vous pouvez visualiser, analyser et alerter sur vos métriques, journaux et traces collectés à partir de plusieurs sources de données dans votre système d'observabilité, y compris AWS, des ISV tiers et d'autres ressources de votre portefeuille informatique.
2. Amazon Managed Grafana, un service de visualisation de données entièrement géré et sécurisé basé sur l'open source grafana projet, qui permet aux clients d'interroger, de corréler et de visualiser instantanément les métriques opérationnelles, les journaux et les traces de leurs applications à partir de plusieurs sources de données. Amazon Managed Grafana décharge la gestion opérationnelle de Grafana en adaptant automatiquement l'infrastructure de calcul et de base de données à mesure que les demandes d'utilisation augmentent, avec des mises à jour de version automatisées et des correctifs de sécurité.

La distribution Kubeflow sur AWS prend en charge l'intégration d'Amazon Managed Service for Prometheus et d'Amazon Managed Grafana pour faciliter l'ingestion et la visualisation des métriques Prometheus en toute sécurité à grande échelle.

Les métriques suivantes sont ingérées et peuvent être visualisées :

• Métriques émises par les composants Kubeflow tels que Kubeflow Pipelines et le serveur Notebook
• Kubeflow métriques du plan de contrôle

Pour configurer Amazon Managed Service for Prometheus et Amazon Managed Grafana pour votre cluster Kubeflow, consultez Utilisez Prometheus, Amazon Managed Service for Prometheus et Amazon Managed Grafana pour surveiller les métriques avec Kubeflow sur AWS.

Vue d'ensemble de la solution

Dans ce cas d'utilisation, nous utilisons le déploiement Kubeflow vanilla à l'aide de l'option d'installation Terraform. Une fois l'installation terminée, nous nous connectons au tableau de bord Kubeflow. À partir du tableau de bord, nous faisons tourner un serveur de bloc-notes Kubeflow Jupyter pour créer un pipeline Kubeflow qui utilise SageMaker pour exécuter une formation distribuée pour un modèle de classification d'images et un point de terminaison SageMaker pour le déploiement du modèle.

Pré-requis

Assurez-vous de remplir les conditions préalables suivantes :

• Vous avez un Compte AWS.
• Assurez-vous que vous êtes dans le us-west-2 Région pour exécuter cet exemple.
• Utilisez Google Chrome pour interagir avec le Console de gestion AWS et Kubeflow.
• Assurez-vous que votre compte dispose d'une limite de type de ressource de formation SageMaker pour ml.p3.2xlarge augmentée à 2 à l'aide de la console Quotas de service.
• En option, vous pouvez utiliser AWSCloud9, un environnement de développement intégré (IDE) basé sur le cloud qui permet d'effectuer tout le travail à partir de votre navigateur Web. Pour les instructions de configuration, reportez-vous à Configurer l'IDE Cloud9. Sélectionnez Ubuntu Server 18.04 comme plate-forme dans les paramètres AWS Cloud9.Ensuite, à partir de votre environnement AWS Cloud9, choisissez le signe plus et ouvrez un nouveau terminal.

Vous configurez également un Interface de ligne de commande AWS (AWS CLI). Pour ce faire, vous avez besoin d'un ID de clé d'accès et d'une clé d'accès secrète d'un Gestion des identités et des accès AWS (JE SUIS) utilisateur compte avec des privilèges administratifs (joindre la stratégie gérée existante) et un accès par programmation. Voir le code suivant :

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

Vérifiez les autorisations que cloud9 utilisera pour appeler les ressources AWS.

aws sts get-caller-identity

Vérifiez à partir de la sortie ci-dessous que vous voyez arn de l'utilisateur admin que vous avez configuré dans le profil AWS CLI. Dans cet exemple, il s'agit de "kubeflow-user"

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

Installer Amazon EKS et Kubeflow sur AWS

Pour installer Amazon EKS et Kubeflow sur AWS, procédez comme suit :

1. Configurez votre environnement pour déployer Kubeflow sur 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. Déployez la version vanille de Kubeflow sur AWS et les ressources AWS associées comme EKS à l'aide de Terraform. Veuillez noter que les volumes EBS utilisés dans le groupe de nœuds EKS ne sont pas chiffrés par défaut :

   #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

Configurer les autorisations Kubeflow

1. Ajoutez des autorisations au module Notebook et au module de composant Pipeline pour effectuer des appels d'API SageMaker, S3 et IAM à l'aide 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. Créez un rôle d'exécution SageMaker pour permettre à la tâche de formation SageMaker d'accéder à l'ensemble de données de formation à partir du service S3 à l'aide de 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

Accéder au tableau de bord Kubeflow

Pour accéder au tableau de bord Kubeflow, procédez comme suit :

1. Vous pouvez exécuter le tableau de bord Kubeflow localement dans l'environnement Cloud9 sans exposer vos URL à Internet public en exécutant les commandes ci-dessous.

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

2. Selectionnez Aperçu de l'application en cours d'exécution.
3. Choisissez l'icône dans le coin du tableau de bord Kubeflow pour l'ouvrir en tant qu'onglet séparé dans Chrome.
4. Entrez les informations d'identification par défaut (user@example.com/12341234) pour vous connecter au tableau de bord Kubeflow.

Configurer l'environnement Kubeflow sur AWS

Une fois connecté au tableau de bord Kubeflow, assurez-vous d'avoir le bon espace de noms (kubeflow-user-example-com) choisi. Effectuez les étapes suivantes pour configurer votre environnement Kubeflow sur AWS :

1. Sur le tableau de bord Kubeflow, choisissez Carnets dans le volet de navigation.
2. Selectionnez Nouveau carnet.
3. Pour Nom, Entrer aws-nb.
4. Pour Image du dossier Jupyter, choisissez l'image jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (le dernier disponible jupyter-pytorch image DLC).
5. Pour Processeur, Entrer 1.
6. Pour Mémoire, Entrer 5.
7. Pour GPU, laissez comme Aucun.
8. N'apportez aucune modification au Espace de travail ainsi que Volumes de données sections.
9. Sélectionnez Autoriser l'accès à Kubeflow Pipelines dans l' Configurations section et choisissez Lancer.
10. Vérifiez que votre bloc-notes est créé avec succès (cela peut prendre quelques minutes).
11. Selectionnez NOUS CONTACTER pour vous connecter à JupyterLab.
12. Clonez le repo en saisissant https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git dans l' Cloner un dépôt champ.
13. Selectionnez Cloner.

Exécuter un exemple de formation distribuée

Après avoir configuré le bloc-notes Jupyter, vous pouvez exécuter l'intégralité de la démonstration en suivant les étapes de haut niveau suivantes à partir du dossier eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training dans le dépôt cloné :

1. Exécutez le script de formation PyTorch Distributed Data Parallel (DDP) – Reportez-vous au script de formation PyTorch DDP cifar10-distributed-gpu-final.py, qui inclut un exemple de réseau neuronal convolutif et une logique pour distribuer la formation sur un cluster CPU et GPU à plusieurs nœuds.
2. Créer un pipeline Kubeflow – Exécutez le bloc-notes STEP1.0_create_pipeline_k8s_sagemaker.ipynb pour créer un pipeline qui exécute et déploie des modèles sur SageMaker. Assurez-vous d'installer la bibliothèque SageMaker dans le cadre de la première cellule de bloc-notes et de redémarrer le noyau avant d'exécuter le reste des cellules de bloc-notes.
3. Appeler un point de terminaison SageMaker – Exécutez le bloc-notes STEP1.1_invoke_sagemaker_endpoint.ipynb pour appeler et tester le point de terminaison d'inférence de modèle SageMaker créé dans le bloc-notes précédent.

Dans les sections suivantes, nous détaillons chacune de ces étapes.

Exécutez le script de formation PyTorch DDP

Dans le cadre de la formation distribuée, nous formons un modèle de classification créé par un simple réseau neuronal convolutif qui fonctionne sur l'ensemble de données CIFAR10. Le scénario de formation cifar10-distributed-gpu-final.py contient uniquement les bibliothèques open source et est compatible pour s'exécuter à la fois sur les clusters de formation Kubernetes et SageMaker sur des périphériques GPU ou des instances CPU. Examinons quelques aspects importants du script de formation avant d'exécuter nos exemples de bloc-notes.

Nous utilisons les torch.distributed module, qui contient la prise en charge de PyTorch et les primitives de communication pour le parallélisme multi-processus entre les nœuds du 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
...

Nous créons un modèle simple de classification d'images en utilisant une combinaison de couches convolutives, de regroupement maximal et linéaires auxquelles un relu la fonction d'activation est appliquée dans le passage vers l'avant de l'entraînement du modèle :

# 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

Si le cluster d'entraînement a des GPU, le script exécute l'entraînement sur les appareils CUDA et la variable d'appareil contient l'appareil CUDA par défaut :

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

Avant d'exécuter une formation distribuée à l'aide de PyTorch DistributedDataParallel pour exécuter un traitement distribué sur plusieurs nœuds, vous devez initialiser l'environnement distribué en appelant init_process_group. Celui-ci est initialisé sur chaque machine du cluster d'apprentissage.

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

Nous instancions le modèle de classifieur et copions le modèle sur l'appareil cible. Si la formation distribuée est activée pour s'exécuter sur plusieurs nœuds, le DistributedDataParallel La classe est utilisée comme objet wrapper autour de l'objet modèle, ce qui permet une formation distribuée synchrone sur plusieurs machines. Les données d'entrée sont réparties sur la dimension du lot et une réplique du modèle est placée sur chaque machine et chaque appareil. Voir le code suivant :

model = Net().to(device)

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

...

Créer un pipeline Kubeflow

Le bloc-notes utilise le Kit de développement logiciel (SDK) Kubeflow Pipelines et son ensemble de packages Python fourni pour spécifier et exécuter les pipelines de workflow ML. Dans le cadre de ce SDK, nous utilisons le décorateur de package de langage spécifique au domaine (DSL) dsl.pipeline, qui décore les fonctions Python pour renvoyer un pipeline.

Le pipeline Kubeflow utilise le composant SageMaker V2 pour soumettre la formation à SageMaker à l'aide des opérateurs SageMaker ACK. La création et le déploiement de modèles SageMaker utilisent le composant SageMaker V1, qui sont des composants SageMaker basés sur Boto3. Nous utilisons une combinaison des deux composants dans cet exemple pour démontrer la flexibilité dont vous disposez en matière de choix.

1. Chargez les composants SageMaker à l'aide du code suivant :

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

   Dans le code suivant, nous créons le pipeline Kubeflow où nous exécutons la formation distribuée SageMaker à l'aide de deux ml.p3.2xlarge les instances:

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

   Une fois le pipeline défini, vous pouvez compiler le pipeline selon une spécification Argo YAML à l'aide du SDK Kubeflow Pipelines. kfp.compiler forfait. Vous pouvez exécuter ce pipeline à l'aide du client SDK Kubeflow Pipelines, qui appelle le point de terminaison du service Pipelines et transmet les en-têtes d'authentification appropriés directement depuis le bloc-notes. Voir le code suivant :

   # 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. Choisissez le Détails de l'exécution sous la dernière cellule pour afficher le pipeline Kubeflow. La capture d'écran suivante montre les détails de notre pipeline pour le composant de formation et de déploiement SageMaker.
3. Choisissez l'étape de la tâche d'entraînement et sur la Journaux , choisissez le lien CloudWatch logs pour accéder aux journaux SageMaker.
   La capture d'écran suivante montre les journaux CloudWatch pour chacune des deux instances ml.p3.2xlarge.
4. Choisissez l'un des groupes pour voir les journaux.
5. Capturez le point de terminaison SageMaker en choisissant le Sagemaker - Modèle de déploiement étape et copier le endpoint_name valeur d'artefact de sortie.

Appeler un point de terminaison SageMaker

Le cahier STEP1.1_invoke_sagemaker_endpoint.ipynb appelle le point de terminaison d'inférence SageMaker créé à l'étape précédente. Assurez-vous de mettre à jour le nom du point de terminaison :

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

Nettoyer

Pour nettoyer vos ressources, procédez comme suit:

1. Exécutez les commandes suivantes dans AWS Cloud9 pour supprimer les ressources AWS :

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

2. Supprimer le rôle IAM "sagemakerrole” à l'aide de la commande AWS CLI suivante :

   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. Supprimez le point de terminaison SageMaker à l'aide de la commande AWS CLI suivante :

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

Résumé

Dans cet article, nous avons souligné la valeur que Kubeflow sur AWS 1.6.1 fournit par le biais d'intégrations de services gérés par AWS natifs pour répondre aux besoins des cas d'utilisation d'IA et de ML au niveau de l'entreprise. Vous pouvez choisir parmi plusieurs options de déploiement pour installer Kubeflow sur AWS avec diverses intégrations de services à l'aide de Terraform, Kustomize ou Helm. Le cas d'utilisation de cet article a démontré une intégration de Kubeflow avec SageMaker qui utilise un cluster de formation géré SageMaker pour exécuter une formation distribuée pour un modèle de classification d'images et un point de terminaison SageMaker pour le déploiement du modèle.

Nous avons également mis à disposition un exemple d'exemple de pipeline qui utilise les derniers composants SageMaker ; vous pouvez l'exécuter directement depuis le tableau de bord Kubeflow. Ce pipeline nécessite la Données Amazon S3 ainsi que Rôle IAM d'exécution SageMaker comme entrées requises.

Pour démarrer avec Kubeflow sur AWS, consultez les options de déploiement intégré à AWS disponibles dans Kubeflow sur AWS. Vous pouvez suivre le Référentiel AWS Labs pour suivre toutes les contributions AWS à Kubeflow. Vous pouvez également nous retrouver sur le Chaîne Kubeflow #AWS Slack; vos commentaires nous aideront à prioriser les prochaines fonctionnalités à contribuer au projet Kubeflow.

À propos des auteurs

Kanwaljit Khurmi est architecte de solutions senior chez Amazon Web Services. Il travaille avec les clients AWS pour fournir des conseils et une assistance technique les aidant à améliorer la valeur de leurs solutions lors de l'utilisation d'AWS. Kanwaljit est spécialisé dans l'aide aux clients avec des applications conteneurisées et d'apprentissage automatique.

Kartik Kalamadi est ingénieur en développement logiciel chez Amazon AI. Actuellement axé sur les projets open source Machine Learning Kubernetes tels que Kubeflow et AWS SageMaker Controller pour k8s. Pendant mon temps libre, j'aime jouer à des jeux PC et jouer avec la réalité virtuelle en utilisant le moteur Unity.

Rahul Kharse est ingénieur en développement logiciel chez Amazon Web Services. Son travail se concentre sur l'intégration des services AWS avec des plateformes ML Ops open source conteneurisées pour améliorer leur évolutivité, leur fiabilité et leur sécurité. En plus de se concentrer sur les demandes de fonctionnalités des clients, Rahul aime également expérimenter les derniers développements technologiques dans le domaine.