El concepto de MLOps está tomando cada vez más tracción en el ámbito empresarial. Esta práctica intenta agilizar la creación de modelos analíticos, facilitar el iterar su desarrollo y gobernar el número creciente de estos.
Este post intenta ser un tutorial de cómo montar una pequeña plataforma de desarrollo de modelos analíticos, en la que se busca automatizar la generación de los modelos para poder tener una trazabilidad entre el modelo, el código y los datos que se han usado para entrenarlo, utilizando componentes existentes en las arquitecturas tradicionales de
desarrollo de software.
La plataforma tendrá un entorno de desarrollo y un entorno de integración/entrega continua.
Lo primero que tenemos que hacer es construir el entorno de desarrollo de los modelos con un flujo de trabajo básico con los siguientes requisitos:
Con este flujo, necesitaremos las siguientes herramientas:
Para montar el entorno, seguiremos los pasos descritos a continuación. En este caso se pueden ejecutar sobre una distribución de Linux o sobre Windows con WSL:
Lo primero será instalar una distribución Python. En este caso concreto utilizaremos conda, ya que es portable a los distintos sistemas operativos:
https://conda.io/docs/user-guide/install/index.html#
Una vez tengamos el entorno python, instalamos MLflow:
pip install mlflow
Para poder probar el entorno que vamos a montar, utilizaremos un proyecto de prueba:
git clone https://github.com/anllogui/python_mlops.git
A tener en cuenta de este proyecto de ejemplo:
Una vez descargado el proyecto, toca configurar el entorno. Para ello, ejecutamos los siguientes comandos:
conda env create -f environment.yml
conda activate pythonCI
El primer comando creará un entorno de python con las librerías necesarias para ejecutar el notebook (como si fuese una nueva instalación de python). El segundo activará el entorno para que cualquier comando que ejecutemos a partir de aquí utilice este entorno.
Ahora vamos a entrenar el modelo en local. para ello ejecutaremos Jupyter (entorno de desarrollo para python) y ejecutaremos el notebook de entrenamiento desde éste:
Como hemos visto antes, para registrar el entrenamiento, vamos a utilizar Mlflow. Para ello simplemente hay que instalar la librería necesaria y añadir en el código de nuestro proyecto las líneas para almacenar los datos que queramos (variables, resultados, modelo, etc.). Aquí tienes un pequeño ejemplo para empezar a utilizarlo en tu código.
Para revisar la ejecución hemos de ir a la interfaz de Mlflow. Para ello ejecutaremos el siguiente comando en el mismo directorio donde hemos ejecutado Jupyter:
mlflow ui
Esto nos lanzará la aplicación y podremos acceder vía navegador con la url http://127.0.0.1:5000
A la hora de generar el modelo candidato de ser promocionado a producción, montaremos un sistema para que no haya ninguna acción manual. De esa manera aseguraremos la trazabilidad entre el código utilizado, los datos utilizados para entrenarlo y el artefacto generado (en este caso el modelo). Para ello, implementaremos el siguiente flujo:
Para poder implementar este flujo, necesitaremos las siguientes herramientas:
Como herramienta de integración contínua, utilizaremos Jenkins para orquestar los pasos a seguir y Papermill para lanzar de manera parametrizada el notebook. En la documentación del proyecto se explica fácilmente cómo hacerlo. En nuestro caso parametrizaremos la versión de los datos a utilizar y la versión del modelo generado:
Para probar que todo está configurado correctamente, basta con lanzar la siguiente línea de comandos:
papermill Simple_Regression.ipynb output.ipynb -p data_ver 1 -p model_ver 1
Este comando utilizará el fichero de datos SalaryData1.csv y generará el modelo linear_regression_model_v1.pkl.
Para que estos parámetros no vayan embebidos en el código, en este caso utilizaremos el fichero build.properties. De esta manera, tenemos más flexibilidad a la hora de reutilizar el mismo código para entrar distintas versiones de modelos con distintos sets de datos.
Para registrar los entrenamientos en un servidor centralizado, arrancaremos Mlflow en modo servidor:
mlflow server
Esto arrancará mlflow en modo servidor y
Para poder guardar de manera versionada los modelos que generemos, utilizaremos Nexus, una herramienta de versionado de artefactos ampliamente utilizada en el mundo de desarrollo de software.
Una vez instalado Jenkins y arrancado (aquí tenéis cómo hacerlo en Ubuntu) configuramos una tarea para lanzar la ejecución desatendida. Las acciones que realizaremos serán las siguientes:
- Crearemos el entorno de python desde el fichero environment.yml y lo Activaremos.
- Entrenaremos el modelo ejecutando el notebook parametrizado.
- Guardaremos el modelo generado y versionado en Nexus.
Para crear esta tarea realizaremos los siguientes pasos:
- Marcaremos que es un proyecto Github y meteremos la url
- Configuraremos el origen del código fuente con los datos del repositorio de código
- En “Ejecutar”, añadiremos un paso del tipo “Ejecutar línea de comandos (shell)” y añadiremos el siguiente código, sustituyendo “
#!/bin/bash
echo "---- SETING ENVS ---- "
export PATH=$PATH:<PATH_INSTALACION_CONDA>/anaconda3/bin
PYENV_HOME=$WORKSPACE/venv/
export LC_ALL=es_ES.utf-8
export LANG=es_ES.utf-8
export MLFLOW_TRACKING_URI="http://127.0.0.1:5000"
echo "---- GETING PROPERTIES ----"
file="./build.properties"
if [ -f "$file" ]
then
echo "$file found."
while IFS='=' read -r key value
do
key=$(echo $key | tr '.' '_')
eval ${key}=\${value}
done < "$file"
echo "Model Version = " ${model_version}
echo "Data Version = " ${data_version}
else
echo "$file not found."
fi
echo "---- CLEANING ENVIRONMENT ----"
if [ -d $PYENV_HOME ]; then
echo "- Project exists: cleanning.."
rm -Rf $PYENV_HOME
fi
source <PATH_INSTALACION_CONDA>/anaconda3/etc/profile.d/conda.sh
echo "*** creating env ***"
echo $PYENV_HOME
conda env create -f environment.yml --prefix $PYENV_HOME
conda activate pythonCI
cd nb
papermill Simple_Regression.ipynb output.ipynb -p data_ver ${data_version}
-p model_ver ${model_version}
ls -la ../models
curl -v -u admin:admin -X POST
'http://localhost:8081/service/rest/v1/components?repository=maven-releases' -F "maven2.groupId=models"
-F "maven2.artifactId=simple_regresion" -F "maven2.version=${data_version}.${model_version}"
-F "maven2.asset1=../models/linear_regression_model_v${model_version}.pkl"
-F "maven2.asset1.extension=pkl"
Esto nos entrenará el modelo registrando los parámetros que hemos definido:
Y también nos versionará el modelo en el repositorio de artefactos:
En este caso hemos utilizado la siguiente nomenclatura para almacenar los modelos:
nombre_de_modelo.version_dato.version_modelo
A partir de aquí el modelo quedará disponible para poder ser embebido en una aplicación.
Hemos montado una arquitectura básica que nos da las siguientes características:
Siguiendo estos mismos patrones,este tipo de plataforma se puede implementar con otras tecnologías o en cloud, facilitando su adopción en arquitecturas ya existentes empresariales y permitiendo el escalado de su uso.
En este ejemplo cubrimos una parte del ciclo de vida del desarrollo de modelos analíticos, en concreto el entrenamiento, pero existen otras fases como la exploración y ejecución de los modelos que no están cubiertas. En NTT Data hemos desarrollado un marco de trabajo y una arquitectura de referencia empresarial para cubrir el ciclo de vida completo en grandes compañías. Si te gusta este ámbito, no dudes en contactar con nosotros!.