Habilitación de flujos de trabajo de aprendizaje automático híbrido en Amazon EKS y Amazon SageMaker con Kubeflow con un solo clic en la implementación de AWS

En la actualidad, muchos clientes de AWS crean plataformas de aprendizaje automático (ML) listas para la empresa en Servicio Amazon Elastic Kubernetes (Amazon EKS) usando Kubeflow en AWS (una distribución de Kubeflow específica de AWS) en muchos casos de uso, incluida la visión artificial, la comprensión del lenguaje natural, la traducción de voz y el modelado financiero.

Con la última versión de código abierto Kubeflow v1.6.1, la comunidad de Kubeflow continúa apoyando esta adopción a gran escala de Kubeflow para casos de uso empresarial. La última versión incluye muchas funciones nuevas e interesantes, como compatibilidad con Kubernetes v1.22, SDK de Python combinado para PyTorch, MXNet, MPI, XGBoost en el operador de capacitación distribuido de Kubeflow, nuevos CRD de ClusterServingRuntime y ServingRuntime para el servicio modelo, y muchas más.

Las contribuciones de AWS a Kubeflow con el reciente lanzamiento de Kubeflow en AWS 1.6.1 son compatibles con todas las características de Kubeflow de código abierto ascendente e incluyen muchas integraciones nuevas con los servicios de AWS altamente optimizados, nativos de la nube y listos para la empresa que lo ayudarán a crear servicios altamente confiables, Sistemas de aprendizaje automático seguros, portátiles y escalables.

En esta publicación, analizamos las nuevas funciones de Kubeflow en AWS v1.6.1 y destacamos tres integraciones importantes que se han incluido en una plataforma para ofrecerle:

• Solución de infraestructura como código (IaaC) de un solo clic que automatiza la instalación de extremo a extremo de Kubeflow, incluida la creación de clústeres de EKS
• Soporte para entrenamiento distribuido en Amazon SageMaker usando Operadores de Amazon SageMaker para Kubernetes (ACK) y Componentes de SageMaker para canalizaciones de Kubeflow y localmente en Kubernetes usando Operadores de formación de Kubeflow. Muchos clientes utilizan esta capacidad para crear arquitecturas híbridas de aprendizaje automático en las que aprovechan la computación de Kubernetes para la fase de experimentación y SageMaker para ejecutar cargas de trabajo a escala de producción.
• Monitoreo y observabilidad mejorados para cargas de trabajo de ML, incluidos Amazon EKS, métricas de Kubeflow y registros de aplicaciones con Prometheus, Grafana y Reloj en la nube de Amazon integraciones

El caso de uso de este blog se centrará específicamente en la integración de SageMaker con Kubeflow en AWS, que podría agregarse a sus flujos de trabajo de Kubernetes existentes, permitiéndole crear arquitecturas híbridas de aprendizaje automático.

Kubeflow en AWS

Kubeflow en AWS 1.6.1 proporciona una ruta clara para usar Kubeflow, con la adición de los siguientes servicios de AWS además de las capacidades existentes:

• Integración de SageMaker con Kubeflow para ejecutar flujos de trabajo híbridos de aprendizaje automático mediante operadores de SageMaker para Kubernetes (ACK) y componentes de SageMaker para canalizaciones de Kubeflow.
• Las opciones de implementación automatizada se han mejorado y simplificado mediante secuencias de comandos Kustomize y gráficos de Helm.
• Se agregó soporte para la implementación con un solo clic de Infraestructura como código (IaC) para Kubeflow en AWS usando Terraform para todos los disponibles opciones de despliegue. Este script automatiza la creación de los siguientes recursos de AWS:
• Apoyo a Enlace privado de AWS para Amazon S3, lo que permite a los usuarios de regiones no comerciales conectarse a sus respectivos puntos finales de S3.
• Integración añadida con Servicio administrado de Amazon para Prometheus (amperio) y Grafana gestionado por Amazon para monitorear métricas con Kubeflow en AWS.
• Se actualizaron los contenedores del servidor de notebook Kubeflow con las últimas imágenes de contenedor de aprendizaje profundo basadas en TensorFlow 2.10.0 y PyTorch 1.12.1.
• Integración con AWS DLC para ejecutar distribuido la formación y inferencia cargas de trabajo.

El siguiente diagrama de arquitectura es una instantánea rápida de todas las integraciones de servicios (incluidas las ya mencionadas) que están disponibles para el control de Kubeflow y los componentes del plano de datos en Kubeflow en AWS. El plano de control de Kubeflow se instala sobre Amazon EKS, que es un servicio de contenedor administrado que se utiliza para ejecutar y escalar aplicaciones de Kubernetes en la nube. Estas integraciones de servicios de AWS le permiten desacoplar partes críticas del plano de control de Kubeflow de Kubernetes, proporcionando un diseño seguro, escalable, resistente y rentable. Para obtener más detalles sobre el valor que agregan estas integraciones de servicio sobre Kubeflow de código abierto, consulte Cree e implemente un sistema de aprendizaje automático escalable en Kubernetes con Kubeflow en AWS.

Analicemos con más detalle cómo las características clave de Kubeflow en AWS 1.6.1 podrían ser útiles para su organización.

Detalles de la característica de Kubeflow en AWS

Con el lanzamiento de Kubeflow 1.6.1, intentamos brindar mejores herramientas para diferentes tipos de clientes que facilitan el inicio de Kubeflow sin importar las opciones que elija. Estas herramientas proporcionan un buen punto de partida y pueden modificarse para adaptarse a sus necesidades exactas.

Opciones de implementación

Ofrecemos diferentes opciones de implementación para diferentes casos de uso del cliente. Aquí puede elegir con qué servicios de AWS desea integrar su implementación de Kubeflow. Si decide cambiar las opciones de implementación más adelante, le recomendamos que realice una instalación nueva para la nueva implementación. Las siguientes opciones de implementación están disponibles:

Si desea implementar Kubeflow con cambios mínimos, considere la extracto de vainilla opción de despliegue. Todas las opciones de implementación disponibles se pueden instalar mediante Kustomize, Helm o Terraform.

También tenemos diferentes implementaciones complementarias que se pueden instalar además de cualquiera de estas opciones de implementación:

Opciones de instalación

Una vez que haya decidido qué opción de implementación se adapta mejor a sus necesidades, puede elegir cómo desea instalar estas implementaciones. En un esfuerzo por servir tanto a los expertos como a los recién llegados, tenemos diferentes niveles de automatización y configuración.

Opción 1: Terraform (IaC)

Esto crea un clúster de EKS y todos los recursos de infraestructura de AWS relacionados, y luego implementa Kubeflow todo en un solo comando usando Terraform. Internamente, esto utiliza planos de EKS y gráficos de Helm.

Esta opción tiene las siguientes ventajas:

• Brinda flexibilidad a las empresas para implementar Amazon EKS y Kubeflow con un solo comando sin tener que preocuparse por las configuraciones específicas de los componentes de Kubeflow. Esto ayudará inmensamente a acelerar la evaluación de la tecnología, la creación de prototipos y el ciclo de vida del desarrollo del producto, proporcionando flexibilidad para usar módulos de terraformación y modificarlos para satisfacer las necesidades específicas de cualquier proyecto.
• Muchas organizaciones de hoy en día que tienen a Terraform como el centro de su estrategia en la nube ahora pueden usar Kubeflow en la solución AWS Terraform para alcanzar sus objetivos en la nube.

Opción 2: Customize o Helm Charts:

Esta opción le permite implementar Kubeflow en un proceso de dos pasos:

1. Cree recursos de AWS como Amazon EKS, Amazon RDS, Amazon S3 y Amazon Cognito, ya sea a través de los scripts automatizados incluidos en la distribución de AWS o manualmente siguiendo un Guia paso a paso.
2. Instale implementaciones de Kubeflow utilizando gráficos de Helm o Kustomize.

Esta opción tiene las siguientes ventajas:

• El objetivo principal de esta opción de instalación es proporcionar configuraciones de Kubernetes relacionadas con Kubeflow. Por lo tanto, puede optar por crear o incorporar clústeres de EKS existentes o cualquiera de los recursos de AWS relacionados, como Amazon RDS, Amazon S3 y Amazon Cognito, y configurarlos y administrarlos para que funcionen con Kubeflow en AWS.
• Es más fácil pasar de un manifiesto de Kustomize Kubeflow de código abierto a una distribución de AWS Kubeflow.

El siguiente diagrama ilustra las arquitecturas de ambas opciones.

Integración con SageMaker

SageMaker es un servicio completamente administrado diseñado y optimizado específicamente para administrar flujos de trabajo de ML. Elimina el trabajo pesado no diferenciado de la administración de la infraestructura y elimina la necesidad de invertir en TI y DevOps para administrar clústeres para la creación, capacitación e inferencia de modelos de ML.

Muchos clientes de AWS que tienen requisitos de portabilidad o restricciones estándar locales utilizan Amazon EKS para configurar canalizaciones de aprendizaje automático repetibles que ejecutan cargas de trabajo de capacitación e inferencia. Sin embargo, esto requiere que los desarrolladores escriban código personalizado para optimizar la infraestructura de ML subyacente, brindar alta disponibilidad y confiabilidad, y cumplir con los requisitos reglamentarios y de seguridad adecuados. Por lo tanto, estos clientes quieren usar SageMaker para una infraestructura administrada y optimizada en costos para el entrenamiento y las implementaciones de modelos y continuar usando Kubernetes para la orquestación y las canalizaciones de ML para mantener la estandarización y la portabilidad.

Para abordar esta necesidad, AWS le permite entrenar, ajustar e implementar modelos en SageMaker desde Amazon EKS mediante las siguientes dos opciones:

• Operadores ACK de Amazon SageMaker para Kubernetes, que se basan en el Controladores de AWS para Kubernetes (ACK) marco. ACK es la estrategia de AWS que incorpora la estandarización para crear controladores personalizados de Kubernetes que permiten a los usuarios de Kubernetes aprovisionar recursos de AWS, como bases de datos o colas de mensajes, simplemente mediante el uso de la API de Kubernetes. Los operadores de SageMaker ACK hacen que sea más fácil para los desarrolladores de ML y los científicos de datos que usan Kubernetes como su plano de control para entrenar, ajustar e implementar modelos de ML en SageMaker sin iniciar sesión en la consola de SageMaker.
• El Componentes de SageMaker para tuberías de Kubeflow, que le permiten integrar SageMaker con la portabilidad y orquestación de Kubeflow Pipelines. Con los componentes de SageMaker, cada trabajo en el flujo de trabajo de canalización se ejecuta en SageMaker en lugar del clúster local de Kubernetes. Esto le permite crear y monitorear trabajos nativos de capacitación, ajuste, implementación de punto final y transformación por lotes de SageMaker desde sus canalizaciones de Kubeflow, lo que le permite mover la computación completa, incluido el procesamiento de datos y los trabajos de capacitación del clúster de Kubernetes al servicio administrado optimizado para aprendizaje automático de SageMaker.

A partir de Kubeflow en AWS v1.6.1, todas las opciones de implementación de Kubeflow disponibles reúnen ambas opciones de integración de Amazon SageMaker de forma predeterminada en una plataforma. Eso significa que ahora puede enviar trabajos de SageMaker mediante operadores ACK de SageMaker desde un servidor de Kubeflow Notebook mediante el envío del recurso de SageMaker personalizado o desde el paso de canalización de Kubeflow mediante componentes de SageMaker.

Hay dos versiones de los componentes de SageMaker: boto3 (AWS SDK para AWS SDK para Python) componentes basados ​​en la versión 1 y SageMaker Operator para K8s (ACK) componentes basados ​​en la versión 2. Los nuevos componentes de SageMaker, versión 2, son compatibles con las últimas API de capacitación de SageMaker y continuaremos agregando más funciones de SageMaker a esta versión del componente. Sin embargo, tiene la flexibilidad de combinar la versión 2 de los componentes de Sagemaker para capacitación y la versión 1 para otras funciones de SageMaker, como el ajuste de hiperparámetros, el procesamiento de trabajos, el alojamiento y muchas más.

Integración con Prometheus y Grafana

Prometheus es una herramienta de agregación de métricas de código abierto que puede configurar para ejecutarse en clústeres de Kubernetes. Cuando se ejecuta en clústeres de Kubernetes, un servidor principal de Prometheus extrae periódicamente los puntos finales del pod.

Los componentes de Kubeflow, como Kubeflow Pipelines (KFP) y Notebook, emiten métricas de Prometheus para permitir el monitoreo de los recursos de los componentes, como la cantidad de experimentos en ejecución o el recuento de notebooks.

Un servidor de Prometheus que se ejecuta en el clúster de Kubernetes puede agregar estas métricas y consultarlas mediante Prometheus Query Language (PromQL). Para obtener más detalles sobre las funciones compatibles con Prometheus, consulte el documentación de Prometeo.

La distribución de Kubeflow en AWS brinda soporte para la integración con los siguientes servicios administrados de AWS:

1. Amazon Managed Prometheus (AMP) que es un Prometeo-Servicio de monitoreo compatible para infraestructura de contenedores y métricas de aplicaciones para contenedores que facilita a los clientes monitorear de forma segura los entornos de contenedores a escala. Con AMP, puede visualizar, analizar y generar alarmas sobre sus métricas, registros y seguimientos recopilados de múltiples fuentes de datos en su sistema de observabilidad, incluidos AWS, ISV de terceros y otros recursos en su cartera de TI.
2. Amazon Managed Grafana, un servicio de visualización de datos seguro y totalmente administrado basado en el código abierto Grafana proyecto, que permite a los clientes consultar, correlacionar y visualizar instantáneamente métricas, registros y seguimientos operativos para sus aplicaciones desde múltiples fuentes de datos. Amazon Managed Grafana descarga la gestión operativa de Grafana al escalar automáticamente la infraestructura informática y de la base de datos a medida que aumentan las demandas de uso, con actualizaciones de versión automatizadas y parches de seguridad.

La distribución de Kubeflow en AWS brinda soporte para la integración de Amazon Managed Service for Prometheus y Amazon Managed Grafana para facilitar la ingesta y visualización de métricas de Prometheus de forma segura a escala.

Las siguientes métricas se ingieren y se pueden visualizar:

• Métricas emitidas desde componentes de Kubeflow como Kubeflow Pipelines y el servidor de Notebook
• Kubeflow métricas del plano de control

Para configurar Amazon Managed Service for Prometheus y Amazon Managed Grafana para su clúster de Kubeflow, consulte Utilice Prometheus, Amazon Managed Service for Prometheus y Amazon Managed Grafana para monitorear métricas con Kubeflow en AWS.

Resumen de la solución

En este caso de uso, utilizamos la implementación estándar de Kubeflow mediante la opción de instalación de Terraform. Cuando se completa la instalación, iniciamos sesión en el panel de control de Kubeflow. Desde el tablero, activamos un servidor de notebook Kubeflow Jupyter para crear una canalización de Kubeflow que usa SageMaker para ejecutar capacitación distribuida para un modelo de clasificación de imágenes y un punto final de SageMaker para la implementación del modelo.

Requisitos previos

Asegúrese de cumplir con los siguientes requisitos previos:

• Tienes un Cuenta de AWS.
• Asegúrate de estar en el us-west-2 Región para ejecutar este ejemplo.
• Utilice Google Chrome para interactuar con el Consola de administración de AWS y Kubeflow.
• Asegúrese de que su cuenta tenga un límite de tipo de recurso de capacitación de SageMaker para ml.p3.2xlarge aumentado a 2 mediante la consola Cuotas de servicio.
• Opcionalmente, puede utilizar Nube de AWS9, un entorno de desarrollo integrado (IDE) basado en la nube que permite completar todo el trabajo desde su navegador web. Para obtener instrucciones de configuración, consulte Configurar el IDE de Cloud9. Seleccione Ubuntu Server 18.04 como plataforma en la configuración de AWS Cloud9.Luego, desde su entorno AWS Cloud9, elija el signo más y abra una nueva terminal.

También configuras un Interfaz de línea de comandos de AWS (AWS CLI) perfil. Para ello, necesita un ID de clave de acceso y una clave de acceso secreta de un Gestión de identidades y accesos de AWS (YO SOY) usuario cuenta con privilegios administrativos (adjunte la política administrada existente) y acceso programático. Ver el siguiente código:

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

Verifique los permisos que usará cloud9 para llamar a los recursos de AWS.

aws sts get-caller-identity

Verifique a partir del siguiente resultado que ve un arn del usuario administrador que configuró en el perfil de AWS CLI. En este ejemplo es "kubeflow-user"

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

Instale Amazon EKS y Kubeflow en AWS

Para instalar Amazon EKS y Kubeflow en AWS, complete los siguientes pasos:

1. Configure su entorno para implementar Kubeflow en 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. Implemente la versión estándar de Kubeflow en AWS y los recursos de AWS relacionados, como EKS, mediante Terraform. Tenga en cuenta que los volúmenes de EBS utilizados en el grupo de nodos de EKS no están cifrados de forma predeterminada:

   #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

Configurar los permisos de Kubeflow

1. Agregue permisos al pod de Notebook y al pod de componentes de Pipeline para realizar llamadas a la API de SageMaker, S3 e IAM usando kubeflow_iam_permissions.sh guión.

   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. Cree el rol de ejecución de SageMaker para permitir que el trabajo de entrenamiento de SageMaker acceda al conjunto de datos de entrenamiento desde el servicio S3 usando sagemaker_role.sh guión.

   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

Acceder al panel de control de Kubeflow

Para acceder al panel de control de Kubeflow, complete los siguientes pasos:

1. Puede ejecutar el panel de control de Kubeflow localmente en el entorno Cloud9 sin exponer sus URL a la Internet pública ejecutando los siguientes comandos.

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

2. Elige Vista previa de la aplicación en ejecución.
3. Elija el ícono en la esquina del tablero de Kubeflow para abrirlo como una pestaña separada en Chrome.
4. Introduzca las credenciales predeterminadas (user@example.com/12341234) para iniciar sesión en el panel de control de Kubeflow.

Configurar el entorno de Kubeflow en AWS

Una vez que haya iniciado sesión en el panel de control de Kubeflow, asegúrese de tener el espacio de nombres correcto (kubeflow-user-example-com) elegido. Complete los siguientes pasos para configurar su Kubeflow en el entorno de AWS:

1. En el panel de control de Kubeflow, elija Cuadernos en el panel de navegación.
2. Elige Nuevo cuaderno.
3. Nombre, introduzca aws-nb.
4. Imagen del expediente de Jupyter, elige la imagen jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (el último disponible jupyter-pytorch imagen DLC).
5. CPU, introduzca 1.
6. Salud Cerebral, introduzca 5.
7. GPU, dejar como Ninguna.
8. No realice ningún cambio en el Espacio de trabajo y Volúmenes de datos .
9. Seleccione Permitir el acceso a las canalizaciones de Kubeflow existentes Configuraciones sección y elija Iniciar.
10. Verifique que su cuaderno se haya creado correctamente (puede tardar un par de minutos).
11. Elige CONTACTO para iniciar sesión en JupyterLab.
12. Clona el repositorio ingresando https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git existentes Clonar un repositorio campo.
13. Elige Clon.

Ejecutar un ejemplo de entrenamiento distribuido

Después de configurar el cuaderno Jupyter, puede ejecutar la demostración completa siguiendo los siguientes pasos de alto nivel desde la carpeta eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training en el repositorio clonado:

1. Ejecute el script de entrenamiento de PyTorch Distributed Data Parallel (DDP) – Consulte el script de entrenamiento PyTorch DDP cifar10-distributed-gpu-final.py, que incluye una red neuronal convolucional de muestra y una lógica para distribuir el entrenamiento en un clúster de CPU y GPU de varios nodos.
2. Crear una canalización de Kubeflow – Ejecutar el cuaderno STEP1.0_create_pipeline_k8s_sagemaker.ipynb para crear una canalización que ejecute e implemente modelos en SageMaker. Asegúrese de instalar la biblioteca de SageMaker como parte de la primera celda del cuaderno y reinicie el kernel antes de ejecutar el resto de las celdas del cuaderno.
3. Invocar un punto final de SageMaker – Ejecutar el cuaderno STEP1.1_invoke_sagemaker_endpoint.ipynb para invocar y probar el extremo de inferencia del modelo de SageMaker creado en el cuaderno anterior.

En las secciones siguientes, analizamos cada uno de estos pasos en detalle.

Ejecute el script de entrenamiento PyTorch DDP

Como parte del entrenamiento distribuido, entrenamos un modelo de clasificación creado por una red neuronal convolucional simple que opera en el conjunto de datos CIFAR10. El guion de entrenamiento cifar10-distributed-gpu-final.py contiene solo las bibliotecas de código abierto y es compatible para ejecutarse en clústeres de capacitación de Kubernetes y SageMaker en dispositivos GPU o instancias de CPU. Veamos algunos aspectos importantes del script de entrenamiento antes de ejecutar los ejemplos de nuestro cuaderno.

Usamos la torch.distributed módulo, que contiene compatibilidad con PyTorch y primitivas de comunicación para el paralelismo multiproceso entre los nodos del clúster:

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

Creamos un modelo de clasificación de imágenes simple utilizando una combinación de capas convolucionales, de agrupación máxima y lineales a las que se relu La función de activación se aplica en el pase hacia adelante del entrenamiento del modelo:

# 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 el clúster de entrenamiento tiene GPU, el script ejecuta el entrenamiento en dispositivos CUDA y la variable del dispositivo contiene el dispositivo CUDA predeterminado:

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

Antes de ejecutar el entrenamiento distribuido con PyTorch DistributedDataParallel para ejecutar el procesamiento distribuido en varios nodos, debe inicializar el entorno distribuido llamando init_process_group. Esto se inicializa en cada máquina del clúster de entrenamiento.

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

Creamos una instancia del modelo clasificador y copiamos el modelo en el dispositivo de destino. Si el entrenamiento distribuido está habilitado para ejecutarse en múltiples nodos, el DistributedDataParallel La clase se usa como un objeto contenedor alrededor del objeto modelo, lo que permite un entrenamiento distribuido síncrono en varias máquinas. Los datos de entrada se dividen en la dimensión del lote y se coloca una réplica del modelo en cada máquina y cada dispositivo. Ver el siguiente código:

model = Net().to(device)

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

...

Crear una canalización de Kubeflow

El cuaderno utiliza el SDK de Kubeflow Pipelines y su conjunto proporcionado de paquetes de Python para especificar y ejecutar las canalizaciones de flujo de trabajo de ML. Como parte de este SDK, utilizamos el decorador de paquetes de idioma específico del dominio (DSL) dsl.pipeline, que decora las funciones de Python para devolver una canalización.

La canalización de Kubeflow usa el componente V2 de SageMaker para enviar capacitación a SageMaker mediante los operadores ACK de SageMaker. La creación y la implementación de modelos de SageMaker utilizan el componente V1 de SageMaker, que son componentes de SageMaker basados ​​en Boto3. Usamos una combinación de ambos componentes en este ejemplo para demostrar la flexibilidad que tiene en la elección.

1. Cargue los componentes de SageMaker con el siguiente código:

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

   En el siguiente código, creamos la canalización de Kubeflow donde ejecutamos el entrenamiento distribuido de SageMaker usando dos ml.p3.2xlarge instancias:

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

   Una vez definida la canalización, puede compilar la canalización en una especificación YAML de Argo mediante los SDK de canalizaciones de Kubeflow. kfp.compiler paquete. Puede ejecutar esta canalización con el cliente del SDK de Kubeflow Pipelines, que llama al extremo del servicio de Pipelines y pasa los encabezados de autenticación apropiados directamente desde el cuaderno. Ver el siguiente código:

   # 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. Elija el Ejecutar detalles enlace debajo de la última celda para ver la canalización de Kubeflow. La siguiente captura de pantalla muestra los detalles de nuestra canalización para el componente de capacitación e implementación de SageMaker.
3. Elija el paso del trabajo de entrenamiento y en el Troncos pestaña, elija el enlace de registros de CloudWatch para acceder a los registros de SageMaker.
   La siguiente captura de pantalla muestra los registros de CloudWatch para cada una de las dos instancias ml.p3.2xlarge.
4. Elija cualquiera de los grupos para ver los registros.
5. Capture el punto final de SageMaker eligiendo el Sagemaker: modelo de implementación paso y copiando el endpoint_name valor del artefacto de salida.

Invocar un punto final de SageMaker

El cuaderno STEP1.1_invoke_sagemaker_endpoint.ipynb invoca el extremo de inferencia de SageMaker creado en el paso anterior. Asegúrese de actualizar el nombre del punto final:

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

Limpiar

Para limpiar sus recursos, complete los siguientes pasos:

1. Ejecute los siguientes comandos en AWS Cloud9 para eliminar los recursos de AWS:

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

2. Eliminar rol de IAM “sagemakerrole” usando el siguiente comando de AWS CLI:

   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. Elimine el punto de enlace de SageMaker con el siguiente comando de la CLI de AWS:

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

Resumen

En esta publicación, destacamos el valor que proporciona Kubeflow en AWS 1.6.1 a través de integraciones de servicios nativos administrados por AWS para abordar la necesidad de casos de uso de IA y ML de nivel empresarial. Puede elegir entre varias opciones de implementación para instalar Kubeflow en AWS con varias integraciones de servicios mediante Terraform, Kustomize o Helm. El caso de uso de esta publicación demostró una integración de Kubeflow con SageMaker que utiliza un clúster de capacitación administrado de SageMaker para ejecutar una capacitación distribuida para un modelo de clasificación de imágenes y un punto final de SageMaker para la implementación del modelo.

También hemos puesto a disposición un ejemplo de canalización de muestra que utiliza los últimos componentes de SageMaker; puede ejecutar esto directamente desde el panel de control de Kubeflow. Este oleoducto requiere la Datos de Amazon S3 y Rol de IAM de ejecución de SageMaker como las entradas requeridas.

Para comenzar con Kubeflow en AWS, consulte las opciones de implementación integradas en AWS disponibles en Kubeflow en AWS. Puedes seguir el Repositorio de laboratorios de AWS para realizar un seguimiento de todas las contribuciones de AWS a Kubeflow. También puede encontrarnos en el Kubeflow #AWS Canal flojo; sus comentarios allí nos ayudarán a priorizar las próximas funciones para contribuir al proyecto Kubeflow.

Sobre los autores

Kanwaljit Khurmi es un arquitecto de soluciones sénior en Amazon Web Services. Trabaja con los clientes de AWS para proporcionar orientación y asistencia técnica, ayudándoles a mejorar el valor de sus soluciones cuando utilizan AWS. Kanwaljit se especializa en ayudar a los clientes con aplicaciones de aprendizaje automático y en contenedores.

Kartik Kalamadi es ingeniero de desarrollo de software en Amazon AI. Actualmente enfocado en proyectos de código abierto de Machine Learning Kubernetes como Kubeflow y AWS SageMaker Controller para k8s. En mi tiempo libre, me gusta jugar juegos de PC y jugar con la realidad virtual usando el motor Unity.

Raul Kharse es ingeniero de desarrollo de software en Amazon Web Services. Su trabajo se centra en la integración de los servicios de AWS con plataformas de operaciones de aprendizaje automático en contenedores de código abierto para mejorar su escalabilidad, confiabilidad y seguridad. Además de centrarse en las solicitudes de características de los clientes, a Rahul también le gusta experimentar con los últimos avances tecnológicos en el campo.