Autor
TL;DR
El entrenamiento de un modelo de ML puede ser a veces complicado de configurar y reproducir:
- Podría hacerse utilizando algún código alojado en un portátil en una VM que tiene que lanzar manualmente y apagar cuando haya terminado
- Es posible que tenga que cargar un dataset de entrenamiento cada vez que desee entrenarlo de nuevo
- Necesita profundizar en su código cuando quiera cambiar un único parámetro
- etc.
En este artículo, veremos cómo automatizamos el proceso de entrenamiento de los clasificadores de texto de FastAI, utilizando Google Cloud AI Platform.
En un segundo artículo, veremos cómo conseguimos desplegar dichos modelos con AI Platform y TorchServe.
¿Para quién?
Si está trabajando en un proyecto que requiere entrenar modelos ML varias veces, y está cansado de tener que ejecutar manualmente sus entrenamientos, ha llegado al lugar adecuado.
Si está cansado de gestionar máquinas virtuales para su formación y quiere dedicar su tiempo a algo más interesante, como leer artículos de Medium, ¡también ha llegado al lugar adecuado!
Este artículo está dedicado a aquellos que quieran saber cómo pueden ganar tiempo y recursos utilizando AI Platform para el entrenamiento de sus modelos ML. Veremos en este artículo cómo aplicamos esto a un proyecto en el que trabajamos, utilizando FastAI.
Este artículo está dedicado a aquellos que quieran saber cómo pueden ganar tiempo y recursos utilizando AI Platform para el entrenamiento de sus modelos ML. Veremos en este artículo cómo aplicamos esto a un proyecto en el que trabajamos, utilizando FastAI.
Requisitos previos si desea reproducir lo que hicimos nosotros
AI Platform forma parte del conjunto Google Cloud Platform, al igual que los demás servicios que utilizamos para automatizar nuestra canalización de formación. Estos son los servicios de GCP que utilizamos:
Es necesario instalar y configurar Google Cloud SDK, Docker y Nvidia-docker en la máquina donde se construya la imagen Docker. El objetivo de instalar Nvidia-docker es poder ejecutar la imagen Docker construida directamente en la GPU de la máquina (si hay una), para garantizar que no hay errores en el código y que el entrenamiento se ejecutará como se espera cuando se ejecute en la plataforma de IA.
Como veremos más adelante en el artículo, la imagen Docker se ha creado a partir de la imagen docker Nvidia-Cuda, por lo que los controladores Nvidia necesarios se instalan automáticamente al construir la imagen.
Contexto
Veremos en este artículo cómo automatizamos el entrenamiento de un clasificador de texto realizado con FastAI, una biblioteca que permite a los usuarios crear potentes modelos gracias al método ULM FiT.
Ya lo presentamos en otro artículo de Medium, Así que le invito a que lo compruebe si quiere saber más sobre el tema.
Dado que lo que veremos en este artículo será aplicable a cualquier marco de trabajo, no es necesario que esté familiarizado con FastAI para continuar leyendo. Todo lo que necesita saber es que utilizamos un modelo preentrenado para entrenar nuestro clasificador de texto además de un conjunto data etiquetado de entrenamiento.
Cómo organizamos la formación con AIPlatform
Para automatizar el entrenamiento de modelos con la Plataforma AI, necesita especificar qué código debe ejecutarse en qué entorno cuando se llame al comando de entrenamiento. La mejor forma de hacerlo es crear una imagen Docker que contenga todo el código de entrenamiento y su entorno, de modo que la Plataforma AI sólo tenga que crear un contenedor a partir de esta imagen cada vez que le pida que entrene un modelo. Veremos en esta parte cómo lo hemos hecho.
Almacene todos los archivos necesarios en un cubo GCS
Antes de crear nuestra imagen Docker que contiene nuestro entrenamiento, tuvimos que pensar en los archivos que se utilizan durante el entrenamiento de un modelo clasificador de texto FastAI. Por lo tanto, decidimos almacenar todos los archivos necesarios para el entrenamiento en un cubo GCS, separados en carpetas para cada idioma, con un nombre específico dado a cada archivo.
A continuación, implementamos en nuestro código de entrenamiento (como veremos más adelante) un método para recuperar esos archivos necesarios de GCS, especificando únicamente el idioma de destino como argumento.
Escriba el código de entrenamiento
Después de cargar los archivos necesarios en GCS, creamos un repo que contiene el código para el entrenamiento de nuestros modelos, destinado a ser almacenado posteriormente en una imagen Docker.
Como puede ver en el repo enlazado, hemos dividido el código para el entrenamiento en archivos separados para manejar adecuadamente todo el pipeline de entrenamiento.
Definimos un archivo que ejecuta todo el flujo de trabajo de formación de la siguiente manera:
fastai_entrenamiento.py es el único archivo que utiliza directamente métodos de FastAI, por lo que si alguien quisiera implementar otro marco para su formación, sólo tendría que modificar este archivo (y el contenido del archivo de configuración, por supuesto).
El siguiente paso fue entonces crear una imagen Docker que contendrá todo lo necesario para que el entrenamiento se ejecute correctamente.
Crear el Dockerfile
Tras preparar el código de entrenamiento, era necesario crear un archivo Docker y enviarlo al Registro de Contenedores de Google, para que la Plataforma de IA pudiera recuperarlo y ejecutarlo en el entorno adecuado.
Dado que el entrenamiento de nuestro modelo debía ejecutarse en la GPU, importamos la imagen Docker Nvidia-cuda para crear la nuestra propia, de modo que todos los controladores necesarios ya estaban instalados.
# Dockerfile
DESDE nvidia/cuda:10.2-devel
EJECUTE apt-get update && apt-get install -y --no-install-recomienda
wget
build-essential
RUN apt-get update && apt-get install -y --no-install-recommends
python3-dev
python3-setuptools
python3-pip
EJECUTE pip3 install pip==20.3.1
directorio de trabajo /root
# Cree directorios para contener el código y el modelo descargado de la GCS
EJECUTE mkdir /root/entrenador
RUN mkdir /root/models
# Copiar requisitos
COPIAR requisitos.txt /root/requisitos.txt
# Instalar pytorch
EJECUTE pip3 install torch==1.8.0
# Instalar requirements
EJECUTE pip3 install -r requisitos.txt
# Instala el sdk de google cloud, esto es principalmente para usar gsutil para exportar el modelo.
EJECUTAR wget -nv
https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz &&
mkdir /root/tools &&
tar xvzf google-cloud-sdk.tar.gz -C /root/tools &&
rm google-cloud-sdk.tar.gz &&
/root/tools/google-cloud-sdk/install.sh --usage-reporting=false
--path-update=false --bash-completion=false
--desactivar-opciones-de-instalación &&
rm -rf /root/.config/* &&
ln -s /root/.config /config &&
# Elimine el directorio de copia de seguridad que crea gcloud
rm -rf /root/tools/google-cloud-sdk/.install/.backup
# Copie los archivos
COPIAR trainer/fastai_train.py /root/trainer/fastai_train.py
COPIAR trainer/fastai_config.py /root/trainer/fastai_config.py
COPIAR trainer/args_getter.py /root/trainer/args_getter.py
COPIAR trainer/gcs_utils.py /root/trainer/gcs_utils.py
COPIAR trainer/training_workflow.py /root/trainer/training_workflow.py
# Configuración de la ruta
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Asegúrese de que gsutil utilizará la cuenta de servicio predeterminada
RUN echo '[GoogleCompute]nservice_account = default' > /etc/boto.cfg
# Autentifíquese en GCP
CMD gcloud auth login
# Establece el punto de entrada para invocar al entrenador.
ENTRYPOINT ["python3", "trainer/training_workflow.py"]
Como puede ver arriba, el Dockerfile ejecuta los siguientes pasos para crear la imagen:
Construya la imagen y envíela al IGC
Tras crear el Dockerfile, fue necesario construir la imagen para empujarla al IGC. Tal y como se especifica en el repo, era necesario definir diversas variables locales, como la variable IMAGE_URI en GCR, el REGIÓN nuestras operaciones en, etc.
La imagen se construyó ejecutando este comando:
docker build -f Dockerfile -t $IMAGE_URI ./
Antes de empujarlo a GCR, queríamos asegurarnos de que todo funcionaría bien al llamar a la formación, así que como nuestra VM tenía una GPU disponible, ejecutamos la imagen antes de empujarla para ver qué pasaba:
docker run --runtime=nvidia $IMAGE_URI --epochs 1 --bucket-name $BUCKET_NAME
Este paso no es necesario pero puede ahorrarle mucho tiempo porque verá directamente si hay errores en su código.
Finalmente empujamos el contenedor al IGC ejecutando el siguiente comando, $IMAGE_URI siendo la variable que hace referencia al URI donde se almacena la imagen en el IGC:
docker push $IMAGE_URI
Ejecute y siga el trabajo
Tras seguir los pasos anteriores, el entrenamiento del modelo estaba listo para ser llamado mediante un simple comando en el terminal. Solo había que habilitar el SDK de Google Cloud y definir las variables locales:
gcloud ai-platform jobs submit training $JOB_NAME -escala-tier BASIC_GPU --region $REGION --master-image-uri $IMAGE_URI -- --lang=fr --epochs=10 --bucket-name=$BUCKET_NAME --model-dir=$MODEL_DIR
Este comando pide a la Plataforma AI que recupere el contenedor en GCR utilizando su IMAGE_URI, y luego ejecute el entrenamiento en la GPU de una máquina alojada en la región REGION.
Especificamos aquí varios argumentos, como el idioma del entrenamiento, el número de epochs, el nombre del bucket para cargar y descargar archivos en GCS y el directorio donde almacenar el modelo entrenado. Esos son los argumentos que recupera el archivo args_getter.py
Tras ejecutar el comando, se inició el entrenamiento y se creó un trabajo en la consola de la Plataforma de IA, lo que nos permitió seguir la evolución del entrenamiento y comprobar los registros de la máquina que lo ejecutaba.
Se puede acceder a mucha información cuando se mira el trabajo en la consola de la Plataforma AI
Una vez finalizado el trabajo, el modelo entrenado se guarda en un cubo GCS como archivo .pth junto con un archivo .json que contiene su rendimiento.
Decidimos considerar los resultados sobre las etiquetas por separado, como si tuviéramos un clasificador binario para cada etiqueta posible.
Dado que utilizamos FastAI, el archivo modelo podría cargarse directamente en cualquier entorno llamando al método load_learner() de FastAI.
Principales conclusiones
Automatizar la formación de nuestros modelos mediante AI Platform nos permitió ahorrar mucho tiempo y nos hizo considerar varios aspectos de la formación de nuestros modelos para ponerlos en producción de forma eficaz.
He aquí algunas conclusiones que sacamos de ello:
¿Y ahora qué?
Ahora que hemos explicado cómo automatizamos el entrenamiento de nuestro modelo, podemos mostrarle cómo conseguimos que se pudiera llamar fácilmente para clasificar archivos bajo demanda.
¡Esté atento a la segunda parte de este artículo que le explicará todo lo que necesita saber para desplegar sus clasificadores entrenados utilizando AI Platform y TorchServe!
¡Gracias por leer!
Esperamos que haya aprendido algo hoy y que le sea útil para sus futuros proyectos de ML. No dude en ponerse en contacto con nosotros si tiene alguna pregunta o comentario sobre este tema.
