Implementación de modelos generativos convolucionales y basados en transformadores como microservicios en Kubernetes

¿Interesado en la IA? Estoy agregando el toque de IA a LHB con este tutorial sobre la implementación de modelos generativos convolucionales y basados en transformadores como microservicios en Kubernetes, con servicio de modelos en contenedores y reentrenamiento periódico.

Aprenderá lo siguiente en este tutorial:

Contenedor de modelos PyTorch y TensorFlow para inferencia acelerada por GPU
Implementar implementaciones canary para actualizaciones graduales del modelo generativo
Reentrenamiento continuo automatizado de modelos generativos con nuevos datos.
Integre microservicios generativos en flujos de trabajo de recuperación ante desastres

Al final de este artículo, podrá crear e implementar sus microservicios generativos que pueden producir contenido de imágenes, texto, audio o video de alta calidad a pedido y mantenerlos actualizados con los datos y comentarios más recientes.

¿Qué son los modelos generativos?

Los modelos generativos son un tipo de modelo de aprendizaje automático que puede aprender a generar nuevos datos que se asemejen a los datos con los que están entrenados. Por ejemplo, un modelo generativo puede aprender a crear imágenes realistas de rostros, animales, paisajes u obras de arte basadas en un gran conjunto de datos de imágenes existentes. Los modelos generativos también pueden aprender a generar contenido de texto, audio o video, como subtítulos, historias, canciones o animaciones.

Existen diferentes tipos de modelos generativos, como los codificadores automáticos variacionales (VAE), las redes generativas adversarias (GAN) y los transformadores.

En este artículo, me centraré en los modelos generativos basados en transformadores y convolucionales.

Modelos generativos convolucionalesUtilice capas convolucionales para procesar información espacial en imágenes o vídeos.

Modelos generativos basados en transformadoresUtilice capas transformadoras para procesar información secuencial en texto o audio.

¿Por qué implementar modelos generativos como microservicios?

Los microservicios son servicios pequeños, independientes y poco acoplados que se comunican entre sí a través de API bien definidas. Los microservicios ofrecen varios beneficios al implementar modelos de aprendizaje automático en producción, como:

Escalabilidad: Puedes escalar cada microservicio de forma independiente según la demanda y la disponibilidad de recursos.
Disponibilidad: puede garantizar una alta disponibilidad y tolerancia a fallos replicando y equilibrando la carga de cada microservicio en varios nodos o regiones.
Modularidad: puede desarrollar, probar, implementar y actualizar cada microservicio por separado sin afectar al resto del sistema.
Diversidad: puede utilizar diferentes tecnologías, marcos, lenguajes y herramientas para cada microservicio según los requisitos y preferencias específicos.

Contenedor de modelos PyTorch y TensorFlow para inferencia acelerada por GPU

Uno de los desafíos de implementar modelos de aprendizaje automático como microservicios es garantizar que se ejecuten de manera consistente y eficiente en diferentes entornos.

Una solución común es utilizar contenedores, que son unidades de software aisladas y portátiles que contienen todo lo necesario para ejecutar una aplicación: código, bibliotecas, dependencias, configuración, etc.

Para contener su modelo PyTorch o TensorFlow para la inferencia acelerada por GPU, debe seguir estos pasos:

Elija una imagen base que contenga el sistema operativo y la versión del marco que necesita. Por ejemplo, puede utilizar las imágenes oficiales de PyTorch o TensorFlow de Docker Hub o NVIDIA NGC.
Instale cualquier dependencia o paquete adicional que necesite para su modelo o aplicación. Es posible que necesite instalar torchvision o tensorflow_datasets para cargar y procesar datos.
Copie su archivo de modelo (p. ej., .pt o .h5) y cualquier otro archivo (p. ej., .json o .txt) que necesite para su aplicación en la imagen del contenedor.
Defina un script de punto de entrada que cargue su modelo desde el archivo y ejecute su lógica de inferencia. Preprocese los datos de entrada, introdúzcalos en su modelo, posprocese los datos de salida y devuélvalos como respuesta.
Exponga un puerto para que su aplicación se comunique con otros servicios. Puede utilizar Flask o FastAPI para crear una API RESTful para la inferencia de su modelo.
Cree la imagen de su contenedor usando los comandos de compilación de Docker o Podman. Por ejemplo:

# Use PyTorch base image from NVIDIA NGC
FROM nvcr.io/nvidia/pytorch:21.03-py3

# Install torchvision for data loading
RUN pip install torchvision

# Copy model file and entrypoint script
COPY model.pt /app/model.pt
COPY app.py /app/app.py

# Expose port 5000 for Flask API
EXPOSE 5000

# Run entrypoint script
CMD ["python", "/app/app.py"]

docker build -t generative-model:v2 .

Debería ver algo como esto:

Inserte la imagen de su contenedor en un registro mediante comandos push de Docker. Por ejemplo:

docker push myregistry/generative-model:v2

Implementar implementaciones canary para actualizaciones graduales del modelo generativo

Una de las ventajas de los microservicios es que puedes actualizar cada servicio de forma independiente sin afectar al resto del sistema.

Sin embargo, actualizar un modelo de aprendizaje automático puede ser arriesgado, ya que puede introducir errores o degradación del rendimiento.

Por lo tanto, es recomendable utilizar una estrategia de implementación canary, que le permita probar una nueva versión de su modelo en un subconjunto de usuarios o tráfico antes de implementarla por completo.

Una estrategia de implementación canary implica los siguientes pasos:

Implemente una nueva versión de su modelo como un microservicio independiente, junto con la versión existente. Por ejemplo, puede utilizar diferentes etiquetas o etiquetas para las imágenes e implementaciones de su contenedor para distinguir entre las versiones.
Divida el tráfico entre las dos versiones utilizando un equilibrador de carga o una malla de servicios. Por ejemplo, puede utilizar Istio o Linkerd para crear reglas de enrutamiento y distribución basada en el peso para sus servicios.
Supervise y compare el rendimiento y el comportamiento de las dos versiones mediante métricas, registros y alertas. Por ejemplo, puede utilizar Prometheus o Grafana para recopilar y visualizar métricas como latencia, rendimiento, tasa de error, precisión, etc.
Aumente gradualmente el tráfico hacia la nueva versión si cumple con sus expectativas y criterios. Por ejemplo, puedes empezar con el 10% del tráfico y aumentarlo un 10% cada hora hasta llegar al 100%.
Vuelva a la versión anterior si detecta algún problema o anomalía con la nueva versión. Por ejemplo, puede utilizar comandos de Kubernetes o gráficos de Helm para revertir sus implementaciones y servicios.

A continuación se muestra un ejemplo de un gráfico de Helm para implementar un modelo generativo basado en transformador TensorFlow como canario:

# Define values for deployment name, image tag, and traffic weight
name: generative-model
imageTag: v2
weight: 10

# Define deployment template
deployment:
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: {{ .Values.name }}-{{ .Values.imageTag }}
    labels:
      app: {{ .Values.name }}
      version: {{ .Values.imageTag }}
  spec:
    replicas: 1
    selector:
      matchLabels:
        app: {{ .Values.name }}
        version: {{ .Values.imageTag }}
    template:
      metadata:
        labels:
          app: {{ .Values.name }}
          version: {{ .Values.imageTag }}
      spec:
        containers:
        - name: {{ .Values.name }}
          image: myregistry/{{ .Values.name }}:{{ .Values.imageTag }}
          ports:
          - containerPort: 5000

# Define service template
service:
  apiVersion: v1
  kind: Service
  metadata:
    name: {{ .Values.name }}
    labels:
      app: {{ .Values.name }}
  spec:
    selector:
      app: {{ .Values.name }}
    ports:
    - port: 80
      targetPort: 5000

# Define virtual service template for Istio routing
virtualService:
  apiVersion: networking.istio.io/v1alpha3
  kind: VirtualService
  metadata:
    name: {{ .Values.name }}
  spec:
    hosts:
    - {{ .Values.name }}
    https:
    - route:
      - destination:
          host: {{ .Values.name }}
          subset: v1
        weight: {{ sub 100 .Values.weight }}
      - destination:
          host: {{ .Values.name }}
          subset: v2
        weight: {{ .Values.weight }}

# Define destination rule template for Istio subsets
destinationRule:
  apiVersion: networking.istio.io/v1alpha3
  kind: DestinationRule
  metadata:
    name: {{ .Values.name }}
  spec:
    host: {{ .Values.name }}
    subsets:
    - name: v1
      labels:
        version: v1
    - name: v2
      labels:
        version: v2

Para implementar el modelo generativo como un canario usando este gráfico de Helm, puede ejecutar este comando:

helm upgrade generative-model generative-model-chart --set imageTag=v2 --set weight=10

Debería ver algo como esto:

Automatice el reentrenamiento continuo de modelos generativos con nuevos datos

Otro desafío de implementar modelos de aprendizaje automático como microservicios es mantenerlos actualizados con los datos y comentarios más recientes. Un modelo estático que se entrena una vez y nunca se actualiza puede volverse obsoleto o inexacto con el tiempo debido a cambios en la distribución de datos, el comportamiento del usuario o los requisitos comerciales. Por tanto, es recomendable automatizar el reentrenamiento continuo de modelos generativos con nuevos datos.

La automatización del reentrenamiento continuo de modelos generativos implica los siguientes pasos:

Recopile y almacene nuevos datos de diversas fuentes, como comentarios de los usuarios, registros, sensores, etc. Por ejemplo, puede usar Kafka o Azure Event Hubs para transmitir datos a un lago de datos o un almacén de datos.
Preprocesar y transformar los nuevos datos en un formato adecuado para el entrenamiento. Por ejemplo, puede utilizar Spark o Databricks para realizar limpieza de datos, ingeniería de funciones y aumento de datos.
Entrene una nueva versión de su modelo generativo utilizando los nuevos datos y el modelo existente como punto de partida. Por ejemplo, puede utilizar PyTorch Lightning o TensorFlow Extended para crear un canal de capacitación que se ejecute en un clúster distribuido o una plataforma en la nube.
Evalúe y valide la nueva versión de su modelo generativo utilizando diversas métricas y pruebas. Por ejemplo, puedes usar TensorBoard o MLflow para rastrear y comparar el rendimiento de diferentes versiones de tu modelo en diferentes conjuntos de datos y tareas.
Implemente la nueva versión de su modelo generativo como un microservicio utilizando una estrategia de implementación canary. Por ejemplo, puede utilizar Helm o Kustomize para crear y actualizar sus implementaciones y servicios de Kubernetes.

Para automatizar estos pasos, puede utilizar herramientas como Airflow o Kubeflow para crear y organizar flujos de trabajo que se ejecuten periódicamente o se activen mediante eventos. También puede utilizar herramientas como Argo CD o Flux para implementar GitOps, que es una práctica de utilizar Git como fuente única de verdad para su código y configuración.

A continuación se muestra un ejemplo de un DAG Airflow para automatizar el reentrenamiento continuo de un modelo generativo convolucional de PyTorch:

# Import modules
from airflow import DAG
from airflow.operators.bash import BashOperator
from airflow.operators.python import PythonOperator
from airflow.utils.dates import days_ago

# Define DAG parameters
dag = DAG(
    dag_id='generative_model_retraining',
    schedule_interval="@daily",
    start_date=days_ago(1),
    catchup=False
)

# Define tasks
collect_data = BashOperator(
    task_id='collect_data',
    bash_command='python collect_data.py',
    dag=dag
)

preprocess_data = BashOperator(
    task_id='preprocess_data',
    bash_command='python preprocess_data.py',
    dag=dag
)

train_model = BashOperator(
    task_id='train_model',
    bash_command='python train_model.py',
    dag=dag
)

evaluate_model = BashOperator(
    task_id='evaluate_model',
    bash_command='python evaluate_model.py',
    dag=dag
)

deploy_model = BashOperator(
    task_id='deploy_model',
    bash_command='helm upgrade generative-model generative-model-chart --set imageTag=v2 --set weight=10',
    dag=dag
)

# Define dependencies
collect_data >> preprocess_data >> train_model >> evaluate_model >> deploy_model

Integre microservicios generativos en flujos de trabajo de recuperación ante desastres

El último paso para implementar modelos generativos como microservicios es garantizar que sean resilientes y confiables en caso de desastres o fallas.

Para integrar microservicios generativos en flujos de trabajo de recuperación ante desastres, debe seguir estos pasos:

Haga una copia de seguridad de sus datos y modelos con regularidad y guárdelos en una ubicación segura y accesible. Por ejemplo, puede utilizar Azure Blob Storage o Amazon S3 para almacenar sus datos y modelos en la nube.
Implemente procedimientos de copia de seguridad y restauración de sus datos y modelos utilizando herramientas como Velero o KubeDB. Por ejemplo, puede utilizar Velero para realizar copias de seguridad y restaurar el estado y los recursos de su clúster de Kubernetes, incluidas sus implementaciones, servicios, volúmenes, etc.
Implemente controles de salud y sondas de vida para sus microservicios utilizando herramientas como Kubernetes o Istio. Por ejemplo, puede utilizar sondas de actividad de Kubernetes para comprobar si su microservicio se está ejecutando y reiniciarlo si falla.
Implemente sondas de preparación y disyuntores para sus microservicios utilizando herramientas como Kubernetes o Istio. Por ejemplo, puede utilizar sondas de preparación de Kubernetes para comprobar si su microservicio está listo para recibir tráfico y eliminarlo del equilibrador de carga si no lo está.
Implemente políticas de reintento y tiempo de espera para sus microservicios utilizando herramientas como Istio o Resilience4j. Por ejemplo, puede utilizar la política de reintento de Istio para reintentar solicitudes fallidas a su microservicio hasta una determinada cantidad de veces o hasta que se alcance un determinado tiempo de espera.
Implemente estrategias de respaldo y recuperación para sus microservicios utilizando herramientas como Istio o Hystrix. Por ejemplo, puede utilizar la política alternativa de Istio para enrutar solicitudes a un servicio alternativo si su servicio principal no está disponible.

A continuación se muestra un ejemplo de una regla de destino de Istio para implementar políticas de disyuntor y respaldo para un modelo generativo basado en transformador de TensorFlow:

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: generative-model
spec:
  host: generative-model
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
  trafficPolicy:
    connectionPool:
      https:
        http1MaxPendingRequests: 100
        maxRequestsPerConnection: 10
    outlierDetection:
      consecutiveErrors: 5
      interval: 10s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
    loadBalancer:
      simple: LEAST_CONN
    mirror:
      host: generative-model-fallback
      subset: v1
    mirrorPercent: 10

Conclusión

En este tutorial, aprendió a implementar modelos generativos convolucionales y basados en transformadores como microservicios en Kubernetes, con servicio de modelos en contenedores y reentrenamiento periódico.

También aprendió a implementar implementaciones canary, procedimientos de copia de seguridad y restauración, comprobaciones de estado, sondas de actividad y preparación, políticas de reintento y tiempo de espera, disyuntores y estrategias de recuperación y respaldo para sus microservicios generativos. También vio algunos ejemplos de código y archivos de configuración para cada paso.

Espero que hayas aprendido algo nuevo y útil. Si tiene alguna pregunta o comentario, no dude en dejar un comentario a continuación.

¿Qué son los modelos generativos?

¿Por qué implementar modelos generativos como microservicios?

Contenedor de modelos PyTorch y TensorFlow para inferencia acelerada por GPU

Implementar implementaciones canary para actualizaciones graduales del modelo generativo

Automatice el reentrenamiento continuo de modelos generativos con nuevos datos

Integre microservicios generativos en flujos de trabajo de recuperación ante desastres

Conclusión

Actualizaciones del boletín

Leer también