![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-laribi.jpeg\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/04\/Medium-Blog.png\" "\\"Mediano")
<\/span><\/div>Parte 1 - \u00bfC\u00f3mo desplegar la instancia de seguimiento de Mlflow en Kubernetes?<\/h1><\/div>Introducci\u00f3n<\/h2><\/div>Mlflow es una herramienta muy utilizada en la comunidad cient\u00edfica\/ML de data para hacer un seguimiento de los experimentos y gestionar los modelos de aprendizaje autom\u00e1tico en diferentes etapas. Utiliz\u00e1ndola, podemos almacenar m\u00e9tricas, modelos y artefactos para comparar f\u00e1cilmente el rendimiento de los modelos y gestionar sus ciclos de vida. Adem\u00e1s, Mlflow proporciona un m\u00f3dulo para servir modelos como un punto final API que facilita su integraci\u00f3n en cualquier producto o aplicaci\u00f3n web.<\/p>\n<\/div>
Dicho esto, utilizar el aprendizaje autom\u00e1tico en productos en l\u00ednea es genial, pero dependiendo del tama\u00f1o del modelo, la naturaleza (ML, aprendizaje profundo,... ) y la carga (solicitudes de los usuarios) podr\u00eda ser un reto dimensionar los recursos necesarios y garantizar un tiempo de respuesta razonable. Por lo tanto, utilizar una infraestructura escalable como los cl\u00fasteres Kubernetes es clave para mantener la disponibilidad y el rendimiento del servicio en la fase de inferencia.<\/p>\n
En este contexto, publicamos una serie de tres art\u00edculos en los que respondemos a las siguientes preguntas:<\/p>\n<\/div>
- <\/i><\/span>\u00bfC\u00f3mo desplegar y utilizar la instancia de seguimiento de Mlflow en Kubernetes?<\/div><\/li>
- <\/i><\/span>\u00bfC\u00f3mo servir modelos de aprendizaje autom\u00e1tico como API utilizando Mlflow?<\/div><\/li>
- <\/i><\/span>\u00bfC\u00f3mo manejar un elevado n\u00famero de solicitudes y hacer que nuestra tarea de inferencia sea escalable para productos industrializados?<\/div><\/li><\/ul>
As\u00ed que empecemos este primer art\u00edculo introduciendo Kubernetes y sus componentes y pasemos por el despliegue de una instancia de rastreo a modelos de registro.<\/p>\n<\/div>
Visi\u00f3n general sobre Kubernetes<\/h2><\/div>Kubernetes es un proyecto de c\u00f3digo abierto, lanzado por Google en 2014. Es un sistema de control y orquestaci\u00f3n de contenedores que permite el despliegue, escalado y programaci\u00f3n autom\u00e1ticos de aplicaciones. Tiene la siguiente arquitectura:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27705%27%20height%3D%270%27%20viewBox%3D%270%200%20705%200%27%3E%3Crect%20width%3D%27705%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Maestro<\/strong>: Se encarga de las configuraciones de entrada, programa las aplicaciones en contenedores en los distintos nodos y supervisa sus estados. El maestro se compone de:<\/p>\n<\/div>- <\/i><\/span>Servidor API:\u00a0<\/strong>permite la interacci\u00f3n con el cluster y valida los comandos enviados por el desarrollador para actualizar el cluster o el estado de la app.<\/div><\/li>
- <\/i><\/span>Programador<\/strong>: decide\u00a0<\/strong>en qu\u00e9 nodos deben ejecutarse los nuevos objetos para garantizar la estabilidad y el equilibrio de la carga.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0una base clave-valor data que almacena las diferentes configuraciones y estados de los recursos<\/div><\/li>
- <\/i><\/span>Director del Controlador:<\/strong>supervisa el estado del cluster y los diferentes recursos y se asegura de que el estado actual coincide con el deseado.<\/div><\/li><\/ul>
Nodos:<\/strong> Son los nodos de ejecuci\u00f3n en los que viven los contenedores desplegados. Sus componentes principales son:<\/p>\n<\/div>- <\/i><\/span>Vainas:\u00a0<\/strong>son la unidad b\u00e1sica fundamental de ejecuci\u00f3n en Kubernetes. Un Pod encapsula una aplicaci\u00f3n, ya sea como un \u00fanico contenedor o como varios contenedores que funcionan juntos con vol\u00famenes de almacenamiento y redes compartidos.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>es\u00a0<\/strong>un\u00a0<\/strong>agente para inspeccionar el estado del contenedor y comunicarse con el maestro Kubernetes.<\/p>\n<\/div><\/li><\/ul>Es la mejor opci\u00f3n cuando una aplicaci\u00f3n tiene varios servicios que se comunican entre s\u00ed, ya que garantiza que cada servicio tenga su propio entorno en contenedores con un conjunto de reglas para interactuar con los dem\u00e1s. Adem\u00e1s, ofrece la interesante capacidad de escalar una aplicaci\u00f3n sin preocuparse de gestionar o sincronizar nuevos servicios y de equilibrar los recursos entre diferentes m\u00e1quinas.<\/p>\n
Desde una perspectiva de alto nivel, como cient\u00edficos data o ingenieros ML, interactuaremos con Kubernetes a trav\u00e9s de su API de servidor utilizando comandos CLI o archivos de configuraci\u00f3n YAML para desplegar y exponer aplicaciones u obtener los estados de nuestros recursos.<\/p>\n<\/div>
Prerrequisitos pr\u00e1cticos<\/h2><\/div>Para esta pr\u00e1ctica, utilizaremos GCP como proveedor de cloud. En primer lugar, necesitamos :<\/p>\n<\/div>
1. Crear los elementos infraestructurales<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> un cubo para almacenar archivos, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: un cl\u00faster GKE de tres nodos (e2-highcpu-4) para desplegar tanto el m\u00f3dulo de seguimiento como el modelo de aprendizaje autom\u00e1tico.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
pruebas de carga:\u00a0<\/strong>un cl\u00faster GKE de tres nodos (e2-standard-2) para realizar pruebas de carga. Se utilizar\u00e1 en el tercer art\u00edculo de esta serie.<\/p>\n<\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27659%27%20height%3D%270%27%20viewBox%3D%270%200%20659%200%27%3E%3Crect%20width%3D%27659%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. Configure la estaci\u00f3n de trabajo local<\/h3><\/div>- <\/i><\/span>\n
Instale los requisitos de python para interactuar con GCP y mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Tenga\u00a0gcloud<\/a>\u00a0y\u00a0kubectl<\/a>\u00a0configurado con las credenciales para acceder al proyecto GCP y a los clusters<\/div><\/li>
- <\/i><\/span>Tenga el Helm CLI instalado e inicializado. Por favor\u00a0encuentre aqu\u00ed las instrucciones<\/a>\u00a0en caso de que a\u00fan no tenga el cliente.<\/div><\/li><\/ul>
3. Clone el repositorio del proyecto pr\u00e1ctico para obtener el c\u00f3digo<\/h3><\/div>git clone https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Despliegue de la instancia Mlflow Tracking<\/h2><\/div>1. Configure el entorno del cl\u00faster<\/h3><\/div>- <\/i><\/span>Crear una cuenta de servicio para permitir la interacci\u00f3n con GCS
\n<\/strong>Esto podr\u00eda hacerse a trav\u00e9s de la consola google cloud, en la secci\u00f3n\u00a0secci\u00f3n iam<\/a>. Necesitamos crear una cuenta de servicio con permiso de administrador de objetos de almacenamiento, generar una clave de autenticaci\u00f3n y descargarla como keyfile.json<\/div><\/li>- <\/i><\/span>Montar el archivo de autenticaci\u00f3n como secreto<\/strong>
\n<\/strong>Los secretos nos permiten manejar de forma segura las credenciales para que s\u00f3lo sean visibles para los recursos pertinentes.\u00a0<\/strong>Para ello, crearemos un volumen secreto y expondremos el archivo de autenticaci\u00f3n s\u00f3lo a los contenedores necesarios.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27634%27%20height%3D%270%27%20viewBox%3D%270%200%20634%200%27%3E%3Crect%20width%3D%27634%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. Seguimiento del despliegue del servidor<\/h3><\/div>- <\/i><\/span>Almac\u00e9n Postgres<\/strong>
\n<\/strong>Postgre sirve como elemento de almacenamiento backend para que mlflow guarde los modelos metadata y las m\u00e9tricas.
\nPara desplegarlo utilizaremos Helm: un gestor de recursos para Kubernetes en el que muchas aplicaciones est\u00e1n disponibles en formato de tablas o plantillas que pueden configurarse con sencillos comandos.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Instancia de seguimiento<\/strong>
\n<\/strong>Tambi\u00e9n utilizaremos gr\u00e1ficos Helm para desplegar el servidor de seguimiento, pero primero, necesitamos construir una imagen docker con la versi\u00f3n que queremos para que pueda ser descargada y desplegada por Helm. Observe que para Postgres, la imagen ya estaba en un repositorio p\u00fablico, sin embargo aqu\u00ed crearemos nuestra propia imagen.<\/p>\ncd mlflow-serving-ejemplo<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Una vez que la imagen es empujada al registro de im\u00e1genes podemos desplegarla en el cluster a trav\u00e9s de helm utilizando los siguientes comandos.<\/p>\n
helm repo add mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--set env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n--set env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nAhora, Mlflow deber\u00eda estar en funcionamiento y la interfaz de usuario deber\u00eda ser accesible a trav\u00e9s de la IP del equilibrador de carga. Podemos comprobar la IP asignada utilizando\u00a0k<\/em>ubectl obtener servicios<\/em>.<\/em><\/strong>A<\/em>Adem\u00e1s, podemos depurar el despliegue accediendo a los registros\u00a0v\u00eda\u00a0<\/em>kubectl describe pods<\/strong>.<\/em>
Hasta ahora, nuestra arquitectura actual tiene el siguiente aspecto:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27621%27%20height%3D%270%27%20viewBox%3D%270%200%20621%200%27%3E%3Crect%20width%3D%27621%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Tenga en cuenta que los equilibradores de carga son accesibles a cualquier persona en Internet, por lo que es esencial pensar en asegurar nuestra instancia de seguimiento a\u00f1adiendo una capa de autenticaci\u00f3n. Esto podr\u00eda hacerse con el\u00a0proxy consciente de la identidad<\/a>\u00a0en GCP, pero no se abordar\u00e1 en este art\u00edculo.<\/p>\n<\/div>3. Creaci\u00f3n de modelos b\u00e1sicos<\/h3><\/div>Ahora que nuestra infraestructura y nuestra instancia de Mlflow est\u00e1n listas, podemos intentar ejecutar un modelo ML sencillo y guardarlo en el registro de modelos para su uso posterior.
\nUtilizaremos el conjunto data de calidad del vino, compuesto por unas 4900 muestras y 11 caracter\u00edsticas que reflejan las caracter\u00edsticas del vino. La etiqueta oscila entre 3 y 9 y podr\u00eda considerarse como una calificaci\u00f3n.
\nSe trata de un ejemplo cl\u00e1sico, en el que entrenamos un modelo de regresi\u00f3n Xgboost y lo almacenamos junto con sus par\u00e1metros y m\u00e9tricas. El c\u00f3digo completo puede encontrarse en\u00a0cuaderno<\/a>.
\nSe habr\u00e1 dado cuenta de que la integraci\u00f3n de Mlflow es sencilla y podr\u00eda resumirse en el siguiente fragmento de c\u00f3digo que invoca a\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() y mlflow.xgboost.log_model()<\/strong><\/em>para crear respectivamente un nuevo experimento, almacenar los par\u00e1metros de entrenamiento, las m\u00e9tricas de evaluaci\u00f3n y el propio modelo entrenado.<\/p>\n<\/div>con mlflow.start_run() como ejecutar:\n \n # Iniciar sesi\u00f3n mlflow\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimadores\", estimadores)\n\n # Crear y ajustar el modelo\n modelo = xgb.XGBRegressor(\n profundidad_m\u00e1x=profundidad_m\u00e1x,\n peso_infantil_min=peso_infantil_min,\n n_estimadores=estimadores\n random_state=42)\n model.fit(X_entrenamiento, y_entrenamiento)\n\n # M\u00e9tricas MLflow\n predicciones = model.predict(X_prueba)\n rmse = np.sqrt(error_medio_cuadrado(y_prueba, predicciones))\n mlflow.log_metric(\"rmse\", rmse)\n\n Modelo log #\n mlflow.xgboost.log_model(modelo, \"xgboost-modelo\", nombre_modelo_registrado = nombre_modelo)\nAl ejecutar el cuaderno proporcionado, se a\u00f1adir\u00e1 una nueva fila en la interfaz de la instancia de seguimiento que corresponder\u00e1 al nuevo experimento.<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27642%27%20height%3D%270%27%20viewBox%3D%270%200%20642%200%27%3E%3Crect%20width%3D%27642%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Por \u00faltimo, suponiendo que estemos satisfechos con el rendimiento del modelo, podemos cargarlo desde la instancia de seguimiento y utilizarlo para la inferencia en python. Esto podr\u00eda hacerse tambi\u00e9n con el cuaderno compartido anteriormente. Observe que en este ejemplo, cargamos el modelo utilizando el ID de ejecuci\u00f3n, pero tenga en cuenta que Mlflow ofrece tambi\u00e9n otras formas interesantes de identificar modelos por etiquetas, versiones o etapas. Para m\u00e1s detalles, consulte la documentaci\u00f3n del registro de modelos\u00a0aqu\u00ed<\/a>.<\/p>\n<\/div>Conclusi\u00f3n<\/h2><\/div>A lo largo de este art\u00edculo, hemos conseguido desplegar la instancia de seguimiento de Mlflow para gestionar nuestros experimentos cient\u00edficos data y hemos realizado un ejemplo r\u00e1pido que muestra c\u00f3mo registrar un modelo y guardarlo para futuras inferencias en python. En el pr\u00f3ximo art\u00edculo de esta serie, aprenderemos a servir este modelo como una API. Esto tiene una gran importancia, ya que facilita la interacci\u00f3n con el modelo y su integraci\u00f3n en un producto o una aplicaci\u00f3n. Adem\u00e1s, hacerlo sobre Kubernetes garantiza que siga siendo f\u00e1cilmente escalable y capaz de manejar diferentes niveles de carga.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Introducci\u00f3n<\/h2><\/div>Mlflow es una herramienta muy utilizada en la comunidad cient\u00edfica\/ML de data para hacer un seguimiento de los experimentos y gestionar los modelos de aprendizaje autom\u00e1tico en diferentes etapas. Utiliz\u00e1ndola, podemos almacenar m\u00e9tricas, modelos y artefactos para comparar f\u00e1cilmente el rendimiento de los modelos y gestionar sus ciclos de vida. Adem\u00e1s, Mlflow proporciona un m\u00f3dulo para servir modelos como un punto final API que facilita su integraci\u00f3n en cualquier producto o aplicaci\u00f3n web.<\/p>\n<\/div>
Dicho esto, utilizar el aprendizaje autom\u00e1tico en productos en l\u00ednea es genial, pero dependiendo del tama\u00f1o del modelo, la naturaleza (ML, aprendizaje profundo,... ) y la carga (solicitudes de los usuarios) podr\u00eda ser un reto dimensionar los recursos necesarios y garantizar un tiempo de respuesta razonable. Por lo tanto, utilizar una infraestructura escalable como los cl\u00fasteres Kubernetes es clave para mantener la disponibilidad y el rendimiento del servicio en la fase de inferencia.<\/p>\n
En este contexto, publicamos una serie de tres art\u00edculos en los que respondemos a las siguientes preguntas:<\/p>\n<\/div>
- <\/i><\/span>\u00bfC\u00f3mo desplegar y utilizar la instancia de seguimiento de Mlflow en Kubernetes?<\/div><\/li>
- <\/i><\/span>\u00bfC\u00f3mo servir modelos de aprendizaje autom\u00e1tico como API utilizando Mlflow?<\/div><\/li>
- <\/i><\/span>\u00bfC\u00f3mo manejar un elevado n\u00famero de solicitudes y hacer que nuestra tarea de inferencia sea escalable para productos industrializados?<\/div><\/li><\/ul>
As\u00ed que empecemos este primer art\u00edculo introduciendo Kubernetes y sus componentes y pasemos por el despliegue de una instancia de rastreo a modelos de registro.<\/p>\n<\/div>
Visi\u00f3n general sobre Kubernetes<\/h2><\/div>Kubernetes es un proyecto de c\u00f3digo abierto, lanzado por Google en 2014. Es un sistema de control y orquestaci\u00f3n de contenedores que permite el despliegue, escalado y programaci\u00f3n autom\u00e1ticos de aplicaciones. Tiene la siguiente arquitectura:<\/p>\n<\/div>
Maestro<\/strong>: Se encarga de las configuraciones de entrada, programa las aplicaciones en contenedores en los distintos nodos y supervisa sus estados. El maestro se compone de:<\/p>\n<\/div>- <\/i><\/span>Servidor API:\u00a0<\/strong>permite la interacci\u00f3n con el cluster y valida los comandos enviados por el desarrollador para actualizar el cluster o el estado de la app.<\/div><\/li>
- <\/i><\/span>Programador<\/strong>: decide\u00a0<\/strong>en qu\u00e9 nodos deben ejecutarse los nuevos objetos para garantizar la estabilidad y el equilibrio de la carga.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0una base clave-valor data que almacena las diferentes configuraciones y estados de los recursos<\/div><\/li>
- <\/i><\/span>Director del Controlador:<\/strong>supervisa el estado del cluster y los diferentes recursos y se asegura de que el estado actual coincide con el deseado.<\/div><\/li><\/ul>
Nodos:<\/strong> Son los nodos de ejecuci\u00f3n en los que viven los contenedores desplegados. Sus componentes principales son:<\/p>\n<\/div>- <\/i><\/span>Vainas:\u00a0<\/strong>son la unidad b\u00e1sica fundamental de ejecuci\u00f3n en Kubernetes. Un Pod encapsula una aplicaci\u00f3n, ya sea como un \u00fanico contenedor o como varios contenedores que funcionan juntos con vol\u00famenes de almacenamiento y redes compartidos.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>es\u00a0<\/strong>un\u00a0<\/strong>agente para inspeccionar el estado del contenedor y comunicarse con el maestro Kubernetes.<\/p>\n<\/div><\/li><\/ul>Es la mejor opci\u00f3n cuando una aplicaci\u00f3n tiene varios servicios que se comunican entre s\u00ed, ya que garantiza que cada servicio tenga su propio entorno en contenedores con un conjunto de reglas para interactuar con los dem\u00e1s. Adem\u00e1s, ofrece la interesante capacidad de escalar una aplicaci\u00f3n sin preocuparse de gestionar o sincronizar nuevos servicios y de equilibrar los recursos entre diferentes m\u00e1quinas.<\/p>\n
Desde una perspectiva de alto nivel, como cient\u00edficos data o ingenieros ML, interactuaremos con Kubernetes a trav\u00e9s de su API de servidor utilizando comandos CLI o archivos de configuraci\u00f3n YAML para desplegar y exponer aplicaciones u obtener los estados de nuestros recursos.<\/p>\n<\/div>
Prerrequisitos pr\u00e1cticos<\/h2><\/div>Para esta pr\u00e1ctica, utilizaremos GCP como proveedor de cloud. En primer lugar, necesitamos :<\/p>\n<\/div>
1. Crear los elementos infraestructurales<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> un cubo para almacenar archivos, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: un cl\u00faster GKE de tres nodos (e2-highcpu-4) para desplegar tanto el m\u00f3dulo de seguimiento como el modelo de aprendizaje autom\u00e1tico.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
pruebas de carga:\u00a0<\/strong>un cl\u00faster GKE de tres nodos (e2-standard-2) para realizar pruebas de carga. Se utilizar\u00e1 en el tercer art\u00edculo de esta serie.<\/p>\n<\/div><\/li><\/ul>2. Configure la estaci\u00f3n de trabajo local<\/h3><\/div>- <\/i><\/span>\n
Instale los requisitos de python para interactuar con GCP y mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Tenga\u00a0gcloud<\/a>\u00a0y\u00a0kubectl<\/a>\u00a0configurado con las credenciales para acceder al proyecto GCP y a los clusters<\/div><\/li>
- <\/i><\/span>Tenga el Helm CLI instalado e inicializado. Por favor\u00a0encuentre aqu\u00ed las instrucciones<\/a>\u00a0en caso de que a\u00fan no tenga el cliente.<\/div><\/li><\/ul>
3. Clone el repositorio del proyecto pr\u00e1ctico para obtener el c\u00f3digo<\/h3><\/div>git clone https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Despliegue de la instancia Mlflow Tracking<\/h2><\/div>1. Configure el entorno del cl\u00faster<\/h3><\/div>- <\/i><\/span>Crear una cuenta de servicio para permitir la interacci\u00f3n con GCS
\n<\/strong>Esto podr\u00eda hacerse a trav\u00e9s de la consola google cloud, en la secci\u00f3n\u00a0secci\u00f3n iam<\/a>. Necesitamos crear una cuenta de servicio con permiso de administrador de objetos de almacenamiento, generar una clave de autenticaci\u00f3n y descargarla como keyfile.json<\/div><\/li>- <\/i><\/span>Montar el archivo de autenticaci\u00f3n como secreto<\/strong>
\n<\/strong>Los secretos nos permiten manejar de forma segura las credenciales para que s\u00f3lo sean visibles para los recursos pertinentes.\u00a0<\/strong>Para ello, crearemos un volumen secreto y expondremos el archivo de autenticaci\u00f3n s\u00f3lo a los contenedores necesarios.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. Seguimiento del despliegue del servidor<\/h3><\/div>- <\/i><\/span>Almac\u00e9n Postgres<\/strong>
\n<\/strong>Postgre sirve como elemento de almacenamiento backend para que mlflow guarde los modelos metadata y las m\u00e9tricas.
\nPara desplegarlo utilizaremos Helm: un gestor de recursos para Kubernetes en el que muchas aplicaciones est\u00e1n disponibles en formato de tablas o plantillas que pueden configurarse con sencillos comandos.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Instancia de seguimiento<\/strong>
\n<\/strong>Tambi\u00e9n utilizaremos gr\u00e1ficos Helm para desplegar el servidor de seguimiento, pero primero, necesitamos construir una imagen docker con la versi\u00f3n que queremos para que pueda ser descargada y desplegada por Helm. Observe que para Postgres, la imagen ya estaba en un repositorio p\u00fablico, sin embargo aqu\u00ed crearemos nuestra propia imagen.<\/p>\ncd mlflow-serving-ejemplo<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Una vez que la imagen es empujada al registro de im\u00e1genes podemos desplegarla en el cluster a trav\u00e9s de helm utilizando los siguientes comandos.<\/p>\n
helm repo add mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--set env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n--set env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nAhora, Mlflow deber\u00eda estar en funcionamiento y la interfaz de usuario deber\u00eda ser accesible a trav\u00e9s de la IP del equilibrador de carga. Podemos comprobar la IP asignada utilizando\u00a0k<\/em>ubectl obtener servicios<\/em>.<\/em><\/strong>A<\/em>Adem\u00e1s, podemos depurar el despliegue accediendo a los registros\u00a0v\u00eda\u00a0<\/em>kubectl describe pods<\/strong>.<\/em>
Hasta ahora, nuestra arquitectura actual tiene el siguiente aspecto:<\/p>\n<\/div>Tenga en cuenta que los equilibradores de carga son accesibles a cualquier persona en Internet, por lo que es esencial pensar en asegurar nuestra instancia de seguimiento a\u00f1adiendo una capa de autenticaci\u00f3n. Esto podr\u00eda hacerse con el\u00a0proxy consciente de la identidad<\/a>\u00a0en GCP, pero no se abordar\u00e1 en este art\u00edculo.<\/p>\n<\/div>3. Creaci\u00f3n de modelos b\u00e1sicos<\/h3><\/div>Ahora que nuestra infraestructura y nuestra instancia de Mlflow est\u00e1n listas, podemos intentar ejecutar un modelo ML sencillo y guardarlo en el registro de modelos para su uso posterior.
\nUtilizaremos el conjunto data de calidad del vino, compuesto por unas 4900 muestras y 11 caracter\u00edsticas que reflejan las caracter\u00edsticas del vino. La etiqueta oscila entre 3 y 9 y podr\u00eda considerarse como una calificaci\u00f3n.
\nSe trata de un ejemplo cl\u00e1sico, en el que entrenamos un modelo de regresi\u00f3n Xgboost y lo almacenamos junto con sus par\u00e1metros y m\u00e9tricas. El c\u00f3digo completo puede encontrarse en\u00a0cuaderno<\/a>.
\nSe habr\u00e1 dado cuenta de que la integraci\u00f3n de Mlflow es sencilla y podr\u00eda resumirse en el siguiente fragmento de c\u00f3digo que invoca a\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() y mlflow.xgboost.log_model()<\/strong><\/em>para crear respectivamente un nuevo experimento, almacenar los par\u00e1metros de entrenamiento, las m\u00e9tricas de evaluaci\u00f3n y el propio modelo entrenado.<\/p>\n<\/div>con mlflow.start_run() como ejecutar:\n \n # Iniciar sesi\u00f3n mlflow\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimadores\", estimadores)\n\n # Crear y ajustar el modelo\n modelo = xgb.XGBRegressor(\n profundidad_m\u00e1x=profundidad_m\u00e1x,\n peso_infantil_min=peso_infantil_min,\n n_estimadores=estimadores\n random_state=42)\n model.fit(X_entrenamiento, y_entrenamiento)\n\n # M\u00e9tricas MLflow\n predicciones = model.predict(X_prueba)\n rmse = np.sqrt(error_medio_cuadrado(y_prueba, predicciones))\n mlflow.log_metric(\"rmse\", rmse)\n\n Modelo log #\n mlflow.xgboost.log_model(modelo, \"xgboost-modelo\", nombre_modelo_registrado = nombre_modelo)\nAl ejecutar el cuaderno proporcionado, se a\u00f1adir\u00e1 una nueva fila en la interfaz de la instancia de seguimiento que corresponder\u00e1 al nuevo experimento.<\/p>\n<\/div>
Por \u00faltimo, suponiendo que estemos satisfechos con el rendimiento del modelo, podemos cargarlo desde la instancia de seguimiento y utilizarlo para la inferencia en python. Esto podr\u00eda hacerse tambi\u00e9n con el cuaderno compartido anteriormente. Observe que en este ejemplo, cargamos el modelo utilizando el ID de ejecuci\u00f3n, pero tenga en cuenta que Mlflow ofrece tambi\u00e9n otras formas interesantes de identificar modelos por etiquetas, versiones o etapas. Para m\u00e1s detalles, consulte la documentaci\u00f3n del registro de modelos\u00a0aqu\u00ed<\/a>.<\/p>\n<\/div>Conclusi\u00f3n<\/h2><\/div>A lo largo de este art\u00edculo, hemos conseguido desplegar la instancia de seguimiento de Mlflow para gestionar nuestros experimentos cient\u00edficos data y hemos realizado un ejemplo r\u00e1pido que muestra c\u00f3mo registrar un modelo y guardarlo para futuras inferencias en python. En el pr\u00f3ximo art\u00edculo de esta serie, aprenderemos a servir este modelo como una API. Esto tiene una gran importancia, ya que facilita la interacci\u00f3n con el modelo y su integraci\u00f3n en un producto o una aplicaci\u00f3n. Adem\u00e1s, hacerlo sobre Kubernetes garantiza que siga siendo f\u00e1cilmente escalable y capaz de manejar diferentes niveles de carga.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Mlflow es una herramienta muy utilizada en la comunidad cient\u00edfica\/ML de data para hacer un seguimiento de los experimentos y gestionar los modelos de aprendizaje autom\u00e1tico en diferentes etapas. Utiliz\u00e1ndola, podemos almacenar m\u00e9tricas, modelos y artefactos para comparar f\u00e1cilmente el rendimiento de los modelos y gestionar sus ciclos de vida. Adem\u00e1s, Mlflow proporciona un m\u00f3dulo para servir modelos como un punto final API que facilita su integraci\u00f3n en cualquier producto o aplicaci\u00f3n web.<\/p>\n<\/div>
Dicho esto, utilizar el aprendizaje autom\u00e1tico en productos en l\u00ednea es genial, pero dependiendo del tama\u00f1o del modelo, la naturaleza (ML, aprendizaje profundo,... ) y la carga (solicitudes de los usuarios) podr\u00eda ser un reto dimensionar los recursos necesarios y garantizar un tiempo de respuesta razonable. Por lo tanto, utilizar una infraestructura escalable como los cl\u00fasteres Kubernetes es clave para mantener la disponibilidad y el rendimiento del servicio en la fase de inferencia.<\/p>\n
En este contexto, publicamos una serie de tres art\u00edculos en los que respondemos a las siguientes preguntas:<\/p>\n<\/div>
- <\/i><\/span>\u00bfC\u00f3mo desplegar y utilizar la instancia de seguimiento de Mlflow en Kubernetes?<\/div><\/li>
- <\/i><\/span>
\u00bfC\u00f3mo servir modelos de aprendizaje autom\u00e1tico como API utilizando Mlflow?<\/div><\/li>- <\/i><\/span>
\u00bfC\u00f3mo manejar un elevado n\u00famero de solicitudes y hacer que nuestra tarea de inferencia sea escalable para productos industrializados?<\/div><\/li><\/ul>As\u00ed que empecemos este primer art\u00edculo introduciendo Kubernetes y sus componentes y pasemos por el despliegue de una instancia de rastreo a modelos de registro.<\/p>\n<\/div>
Visi\u00f3n general sobre Kubernetes<\/h2><\/div>
Kubernetes es un proyecto de c\u00f3digo abierto, lanzado por Google en 2014. Es un sistema de control y orquestaci\u00f3n de contenedores que permite el despliegue, escalado y programaci\u00f3n autom\u00e1ticos de aplicaciones. Tiene la siguiente arquitectura:<\/p>\n<\/div>
Maestro<\/strong>: Se encarga de las configuraciones de entrada, programa las aplicaciones en contenedores en los distintos nodos y supervisa sus estados. El maestro se compone de:<\/p>\n<\/div>
- <\/i><\/span>Servidor API:\u00a0<\/strong>permite la interacci\u00f3n con el cluster y valida los comandos enviados por el desarrollador para actualizar el cluster o el estado de la app.<\/div><\/li>
- <\/i><\/span>
Programador<\/strong>: decide\u00a0<\/strong>en qu\u00e9 nodos deben ejecutarse los nuevos objetos para garantizar la estabilidad y el equilibrio de la carga.<\/div><\/li>- <\/i><\/span>
Etcd:<\/strong>\u00a0una base clave-valor data que almacena las diferentes configuraciones y estados de los recursos<\/div><\/li>- <\/i><\/span>
Director del Controlador:<\/strong>supervisa el estado del cluster y los diferentes recursos y se asegura de que el estado actual coincide con el deseado.<\/div><\/li><\/ul>Nodos:<\/strong> Son los nodos de ejecuci\u00f3n en los que viven los contenedores desplegados. Sus componentes principales son:<\/p>\n<\/div>
- <\/i><\/span>Vainas:\u00a0<\/strong>son la unidad b\u00e1sica fundamental de ejecuci\u00f3n en Kubernetes. Un Pod encapsula una aplicaci\u00f3n, ya sea como un \u00fanico contenedor o como varios contenedores que funcionan juntos con vol\u00famenes de almacenamiento y redes compartidos.<\/div><\/li>
- <\/i><\/span>
\nKubelet:<\/strong>es\u00a0<\/strong>un\u00a0<\/strong>agente para inspeccionar el estado del contenedor y comunicarse con el maestro Kubernetes.<\/p>\n<\/div><\/li><\/ul>
Es la mejor opci\u00f3n cuando una aplicaci\u00f3n tiene varios servicios que se comunican entre s\u00ed, ya que garantiza que cada servicio tenga su propio entorno en contenedores con un conjunto de reglas para interactuar con los dem\u00e1s. Adem\u00e1s, ofrece la interesante capacidad de escalar una aplicaci\u00f3n sin preocuparse de gestionar o sincronizar nuevos servicios y de equilibrar los recursos entre diferentes m\u00e1quinas.<\/p>\n
Desde una perspectiva de alto nivel, como cient\u00edficos data o ingenieros ML, interactuaremos con Kubernetes a trav\u00e9s de su API de servidor utilizando comandos CLI o archivos de configuraci\u00f3n YAML para desplegar y exponer aplicaciones u obtener los estados de nuestros recursos.<\/p>\n<\/div>
Prerrequisitos pr\u00e1cticos<\/h2><\/div>
Para esta pr\u00e1ctica, utilizaremos GCP como proveedor de cloud. En primer lugar, necesitamos :<\/p>\n<\/div>
1. Crear los elementos infraestructurales<\/h3><\/div>
- <\/i><\/span>mlflow_gke:<\/strong> un cubo para almacenar archivos, datasets...<\/div><\/li>
- <\/i><\/span>
\nmlflow-k8s<\/strong>: un cl\u00faster GKE de tres nodos (e2-highcpu-4) para desplegar tanto el m\u00f3dulo de seguimiento como el modelo de aprendizaje autom\u00e1tico.<\/p>\n<\/div><\/li>
- <\/i><\/span>
\npruebas de carga:\u00a0<\/strong>un cl\u00faster GKE de tres nodos (e2-standard-2) para realizar pruebas de carga. Se utilizar\u00e1 en el tercer art\u00edculo de esta serie.<\/p>\n<\/div><\/li><\/ul>
2. Configure la estaci\u00f3n de trabajo local<\/h3><\/div>
- <\/i><\/span>\n
Instale los requisitos de python para interactuar con GCP y mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Tenga\u00a0gcloud<\/a>\u00a0y\u00a0kubectl<\/a>\u00a0configurado con las credenciales para acceder al proyecto GCP y a los clusters<\/div><\/li>- <\/i><\/span>
Tenga el Helm CLI instalado e inicializado. Por favor\u00a0encuentre aqu\u00ed las instrucciones<\/a>\u00a0en caso de que a\u00fan no tenga el cliente.<\/div><\/li><\/ul>3. Clone el repositorio del proyecto pr\u00e1ctico para obtener el c\u00f3digo<\/h3><\/div>
git clone https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>
Despliegue de la instancia Mlflow Tracking<\/h2><\/div>
1. Configure el entorno del cl\u00faster<\/h3><\/div>
- <\/i><\/span>Crear una cuenta de servicio para permitir la interacci\u00f3n con GCS
\n<\/strong>Esto podr\u00eda hacerse a trav\u00e9s de la consola google cloud, en la secci\u00f3n\u00a0secci\u00f3n iam<\/a>. Necesitamos crear una cuenta de servicio con permiso de administrador de objetos de almacenamiento, generar una clave de autenticaci\u00f3n y descargarla como keyfile.json<\/div><\/li>- <\/i><\/span>
Montar el archivo de autenticaci\u00f3n como secreto<\/strong>
\n<\/strong>Los secretos nos permiten manejar de forma segura las credenciales para que s\u00f3lo sean visibles para los recursos pertinentes.\u00a0<\/strong>Para ello, crearemos un volumen secreto y expondremos el archivo de autenticaci\u00f3n s\u00f3lo a los contenedores necesarios.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. Seguimiento del despliegue del servidor<\/h3><\/div>
- <\/i><\/span>Almac\u00e9n Postgres<\/strong>
\n<\/strong>Postgre sirve como elemento de almacenamiento backend para que mlflow guarde los modelos metadata y las m\u00e9tricas.
\nPara desplegarlo utilizaremos Helm: un gestor de recursos para Kubernetes en el que muchas aplicaciones est\u00e1n disponibles en formato de tablas o plantillas que pueden configurarse con sencillos comandos.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Instancia de seguimiento<\/strong>
\n<\/strong>Tambi\u00e9n utilizaremos gr\u00e1ficos Helm para desplegar el servidor de seguimiento, pero primero, necesitamos construir una imagen docker con la versi\u00f3n que queremos para que pueda ser descargada y desplegada por Helm. Observe que para Postgres, la imagen ya estaba en un repositorio p\u00fablico, sin embargo aqu\u00ed crearemos nuestra propia imagen.<\/p>\ncd mlflow-serving-ejemplo<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Una vez que la imagen es empujada al registro de im\u00e1genes podemos desplegarla en el cluster a trav\u00e9s de helm utilizando los siguientes comandos.<\/p>\n
helm repo add mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--set env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n--set env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nAhora, Mlflow deber\u00eda estar en funcionamiento y la interfaz de usuario deber\u00eda ser accesible a trav\u00e9s de la IP del equilibrador de carga. Podemos comprobar la IP asignada utilizando\u00a0k<\/em>ubectl obtener servicios<\/em>.<\/em><\/strong>A<\/em>Adem\u00e1s, podemos depurar el despliegue accediendo a los registros\u00a0v\u00eda\u00a0<\/em>kubectl describe pods<\/strong>.<\/em>
Hasta ahora, nuestra arquitectura actual tiene el siguiente aspecto:<\/p>\n<\/div>Tenga en cuenta que los equilibradores de carga son accesibles a cualquier persona en Internet, por lo que es esencial pensar en asegurar nuestra instancia de seguimiento a\u00f1adiendo una capa de autenticaci\u00f3n. Esto podr\u00eda hacerse con el\u00a0proxy consciente de la identidad<\/a>\u00a0en GCP, pero no se abordar\u00e1 en este art\u00edculo.<\/p>\n<\/div>
3. Creaci\u00f3n de modelos b\u00e1sicos<\/h3><\/div>
Ahora que nuestra infraestructura y nuestra instancia de Mlflow est\u00e1n listas, podemos intentar ejecutar un modelo ML sencillo y guardarlo en el registro de modelos para su uso posterior.
\nUtilizaremos el conjunto data de calidad del vino, compuesto por unas 4900 muestras y 11 caracter\u00edsticas que reflejan las caracter\u00edsticas del vino. La etiqueta oscila entre 3 y 9 y podr\u00eda considerarse como una calificaci\u00f3n.
\nSe trata de un ejemplo cl\u00e1sico, en el que entrenamos un modelo de regresi\u00f3n Xgboost y lo almacenamos junto con sus par\u00e1metros y m\u00e9tricas. El c\u00f3digo completo puede encontrarse en\u00a0cuaderno<\/a>.
\nSe habr\u00e1 dado cuenta de que la integraci\u00f3n de Mlflow es sencilla y podr\u00eda resumirse en el siguiente fragmento de c\u00f3digo que invoca a\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() y mlflow.xgboost.log_model()<\/strong><\/em>para crear respectivamente un nuevo experimento, almacenar los par\u00e1metros de entrenamiento, las m\u00e9tricas de evaluaci\u00f3n y el propio modelo entrenado.<\/p>\n<\/div>con mlflow.start_run() como ejecutar:\n \n # Iniciar sesi\u00f3n mlflow\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimadores\", estimadores)\n\n # Crear y ajustar el modelo\n modelo = xgb.XGBRegressor(\n profundidad_m\u00e1x=profundidad_m\u00e1x,\n peso_infantil_min=peso_infantil_min,\n n_estimadores=estimadores\n random_state=42)\n model.fit(X_entrenamiento, y_entrenamiento)\n\n # M\u00e9tricas MLflow\n predicciones = model.predict(X_prueba)\n rmse = np.sqrt(error_medio_cuadrado(y_prueba, predicciones))\n mlflow.log_metric(\"rmse\", rmse)\n\n Modelo log #\n mlflow.xgboost.log_model(modelo, \"xgboost-modelo\", nombre_modelo_registrado = nombre_modelo)\nAl ejecutar el cuaderno proporcionado, se a\u00f1adir\u00e1 una nueva fila en la interfaz de la instancia de seguimiento que corresponder\u00e1 al nuevo experimento.<\/p>\n<\/div>
Por \u00faltimo, suponiendo que estemos satisfechos con el rendimiento del modelo, podemos cargarlo desde la instancia de seguimiento y utilizarlo para la inferencia en python. Esto podr\u00eda hacerse tambi\u00e9n con el cuaderno compartido anteriormente. Observe que en este ejemplo, cargamos el modelo utilizando el ID de ejecuci\u00f3n, pero tenga en cuenta que Mlflow ofrece tambi\u00e9n otras formas interesantes de identificar modelos por etiquetas, versiones o etapas. Para m\u00e1s detalles, consulte la documentaci\u00f3n del registro de modelos\u00a0aqu\u00ed<\/a>.<\/p>\n<\/div>
Conclusi\u00f3n<\/h2><\/div>
A lo largo de este art\u00edculo, hemos conseguido desplegar la instancia de seguimiento de Mlflow para gestionar nuestros experimentos cient\u00edficos data y hemos realizado un ejemplo r\u00e1pido que muestra c\u00f3mo registrar un modelo y guardarlo para futuras inferencias en python. En el pr\u00f3ximo art\u00edculo de esta serie, aprenderemos a servir este modelo como una API. Esto tiene una gran importancia, ya que facilita la interacci\u00f3n con el modelo y su integraci\u00f3n en un producto o una aplicaci\u00f3n. Adem\u00e1s, hacerlo sobre Kubernetes garantiza que siga siendo f\u00e1cilmente escalable y capaz de manejar diferentes niveles de carga.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article2.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article3.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais-4.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais5.png\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/03\/medium.png\" "\\"medio\\"")
<\/span><\/div>