Puedes clonar esto carpeta para encontrar todos los scripts necesarios para este tutorial.
Para alojar el servidor MLflow, comenzamos por crear un contenedor Docker mediante un Dockerfile. A continuación, se muestra un ejemplo de configuración:
# Use Miniconda as the base image
FROM continuumio/miniconda3# Set environment variables
ENV DEBIAN_FRONTEND=noninteractive
# Install necessary packages
RUN apt-get update -y && \
apt-get install -y --no-install-recommends curl apt-transport-https gnupg2 unixodbc-dev
# Add Microsoft SQL Server ODBC Driver 18 repository and install
RUN curl https://packages.microsoft.com/keys/microsoft.asc | apt-key add - && \
curl https://packages.microsoft.com/config/debian/11/prod.list > /etc/apt/sources.list.d/mssql-release.list && \
apt-get update && \
ACCEPT_EULA=Y apt-get install -y msodbcsql18 mssql-tools18
# Add mssql-tools to PATH
RUN echo 'export PATH="$PATH:/opt/mssql-tools18/bin"' >> ~/.bash_profile && \
echo 'export PATH="$PATH:/opt/mssql-tools18/bin"' >> ~/.bashrc
# define default server env variables
ENV MLFLOW_SERVER_HOST 0.0.0.0
ENV MLFLOW_SERVER_PORT 5000
ENV MLFLOW_SERVER_WORKERS 1
# Set the working directory
WORKDIR /app
# Copy the current directory contents into the container at /app
COPY . /app
# Install Python dependencies specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
# Make sure the launch.sh script is executable
RUN chmod +x /app/launch.sh
# Expose port 5000 for MLflow
EXPOSE 5000
# Set the entrypoint to run the launch.sh script
ENTRYPOINT ["/app/launch.sh"]
Este Dockerfile crea un contenedor que ejecuta un servidor MLflow. Instala las herramientas necesarias, incluido el controlador ODBC de Microsoft SQL Server, configura el entorno e instala las dependencias de Python. Luego, copia nuestros archivos en la carpeta de la aplicación en el contenedor, expone el puerto 5000 (obligatorio para MlFlow) y ejecuta un launch.sh script para iniciar el servidor MLflow.
El launch.sh contiene solo el comando que inicia el servidor mlflow.
- Cree la imagen Docker en el mismo directorio donde se encuentra su Dockerfile:
docker build . -t mlflowserver
# if your are on mac, use :
# docker build - platform=linux/amd64 -t mlflowserver:latest .
Ejecute el contenedor Docker:
docker run -it -p 5000:5000 mlflowserver
Después de ejecutar estos comandos, el servidor MLflow se inicia localmente y puede acceder a la interfaz de usuario de MLflow navegando a http://localhost:5000Esto confirma que el servidor se implementó correctamente en su máquina local. Sin embargo, en esta etapa, si bien puede registrar experimentos en MLflow, ninguno de los resultados, artefactos o metadatos se guardarán en la base de datos SQL o en el almacén de artefactos, ya que aún no se han configurado. Además, la URL solo es accesible de forma local, lo que significa que su equipo de ciencia de datos no puede acceder a ella de forma remota.
Comience por crear una cuenta de Azure y obtener su ID de suscripción desde el Portal de Azure.
Para implementar su servidor MLflow y hacerlo accesible para su equipo, siga estos pasos simplificados:
- Clonar el repositorio:Clonar esto carpeta a su máquina local.
- Ejecutar el script de implementación:Ejecutar el
deploy.shScript como un script de shell. Asegúrese de actualizar la variable de ID de suscripción en el script antes de ejecutarlo.
Si bien Azure ofrece una interfaz gráfica para configurar recursos, esta guía simplifica el proceso mediante el uso de deploy.sh Script para automatizar todo con un solo comando.
Aquí hay un desglose de lo que deploy.sh El script lo hace paso a paso:
1. Iniciar sesión y configurar suscripción:Primero, inicie sesión en su cuenta de Azure y configure la suscripción correcta donde se implementarán todos sus recursos (recupere el ID de suscripción del Portal de Azure).
az login az account set --subscription $SUBSCRIPTION_ID
2. Crear un grupo de recursos:Crear un Grupo de recursos para organizar todos los recursos que implementará para MLflow.
az group create --name $RG_NAME --location <location>
3. Configurar la base de datos SQL de Azure:Cree un servidor SQL de Azure y una base de datos SQL donde MLflow almacenará todos los metadatos del experimento.
az sql server create \
--name $SQL_SERVER_NAME \
--resource-group $RG_NAME \
--location $RG_LOCATION \
--admin-user $SQL_ADMIN_USER \
--admin-password $SQL_ADMIN_PASSWORDaz sql db create \
--resource-group $RG_NAME \
--server $SQL_SERVER_NAME \
--name $SQL_DATABASE_NAME \
--service-objective S0
4. Configurar el firewall de SQL Server:Permitir el acceso a SQL Server desde otros servicios de Azure mediante la creación de una regla de firewall.
az sql server firewall-rule create \
--resource-group $RG_NAME \
--server $SQL_SERVER_NAME \
--name AllowAllAzureIPs \
--start-ip-address 0.0.0.0 \
--end-ip-address 0.0.0.0
5. Crear una cuenta de almacenamiento de Azure:Configurar una instancia de Azure Almacenamiento Cuenta y un contenedor de blobs para almacenar artefactos (por ejemplo, modelos, resultados de experimentos).
az storage account create \
--resource-group $RG_NAME \
--location $RG_LOCATION \
--name $STORAGE_ACCOUNT_NAME \
--sku Standard_LRSaz storage container create \
--name $STORAGE_CONTAINER_NAME \
--account-name $STORAGE_ACCOUNT_NAME
6. Crear Azure Container Registry (ACR):Cree un Azure Container Registry (ACR) para almacenar la imagen de Docker de su servidor MLflow.
az acr create \
--name $ACR_NAME \
--resource-group $RG_NAME \
--sku Basic \
--admin-enabled true
7. Cree y envíe la imagen de Docker a ACR: Cree su imagen de Docker para el servidor MLflow y envíela a Azure Container Registry. Para ello, primero debe recuperar el nombre de usuario y la contraseña de ACR e iniciar sesión en ACR.
export ACR_USERNAME=$(az acr credential show --name $ACR_NAME --query "username" --output tsv)
export ACR_PASSWORD=$(az acr credential show --name $ACR_NAME --query "passwords[0].value" --output tsv)docker login $ACR_NAME.azurecr.io \
--username "$ACR_USERNAME" \
--password "$ACR_PASSWORD"
# Push the images
docker tag $DOCKER_IMAGE_NAME $ACR_NAME.azurecr.io/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
docker push $ACR_NAME.azurecr.io/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
8. Crear un plan de servicio de aplicaciones:Configure un plan de App Service para alojar su servidor MLflow en Azure.
az appservice plan create \
--name $ASP_NAME \
--resource-group $RG_NAME \
--sku B1 \
--is-linux \
--location $RG_LOCATION
9. Implementar una aplicación web con un contenedor MLflow:Crear un Aplicación web que utiliza su imagen Docker de ACR para implementar el servidor MLflow.
az webapp create \
--resource-group $RG_NAME \
--plan $ASP_NAME \
--name $WEB_APP_NAME \
--deployment-container-image-name $ACR_NAME.azurecr.io/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
10. Configurar la aplicación web para utilizar el registro de contenedores:Configure su aplicación web para extraer la imagen Docker de MLflow desde ACR y configure las variables de entorno.
az webapp config container set \
--name $WEB_APP_NAME \
--resource-group $RG_NAME \
--docker-custom-image-name $ACR_NAME.azurecr.io/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG \
--docker-registry-server-url https://$ACR_NAME.azurecr.io \
--docker-registry-server-user $ACR_USERNAME \
--docker-registry-server-password $ACR_PASSWORD \
--enable-app-service-storage trueaz webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings WEBSITES_PORT=$MLFLOW_PORT
az webapp log config \
--name $WEB_APP_NAME \
--resource-group $RG_NAME \
--docker-container-logging filesystem
11. Establecer variables de entorno de la aplicación web:Establezca las variables de entorno necesarias para MLflow, como el acceso al almacenamiento, el backend SQL y la configuración del puerto.
echo "Retrive artifact, access key, connection string"
export STORAGE_ACCESS_KEY=$(az storage account keys list --resource-group $RG_NAME --account-name $STORAGE_ACCOUNT_NAME --query "[0].value" --output tsv)
export STORAGE_CONNECTION_STRING=`az storage account show-connection-string --resource-group $RG_NAME --name $STORAGE_ACCOUNT_NAME --output tsv`
export STORAGE_ARTIFACT_ROOT="https://$STORAGE_ACCOUNT_NAME.blob.core.windows.net/$STORAGE_CONTAINER_NAME"#Setting environment variables for artifacts and database
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings AZURE_STORAGE_CONNECTION_STRING=$STORAGE_CONNECTION_STRING
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings BACKEND_STORE_URI=$BACKEND_STORE_URI
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings MLFLOW_SERVER_DEFAULT_ARTIFACT_ROOT=$STORAGE_ARTIFACT_ROOT
#Setting environment variables for the general context
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings MLFLOW_SERVER_PORT=$MLFLOW_PORT
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings MLFLOW_SERVER_HOST=$MLFLOW_HOST
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings MLFLOW_SERVER_FILE_STORE=$MLFLOW_FILESTORE
az webapp config appsettings set \
--resource-group $RG_NAME \
--name $WEB_APP_NAME \
--settings MLFLOW_SERVER_WORKERS=$MLFLOW_WORKERS
Una vez que el deploy.sh Una vez completado el script, puede verificar que se hayan creado todos los servicios de Azure consultando el portal de Azure.
Vaya a la sección Servicios de aplicaciones para recuperar la URL de su aplicación web MLflow.
Su URL de seguimiento de MLflow ahora debería estar activa y lista para recibir experimentos de su equipo de ciencia de datos.
Aquí hay un script de Python que demuestra cómo registrar un experimento usando MLflow con un modelo simple de scikit-learn, como la regresión logística. Asegúrese de actualizar el script con su URI de seguimiento de MLflow:
import os
import mlflow
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import joblib# Load Iris dataset
iris = load_iris()
# Split dataset into X features and Target variable
X = pd.DataFrame(data = iris["data"], columns= iris["feature_names"])
y = pd.Series(data = iris["target"], name="target")
# Split our training set and our test set
X_train, X_test, y_train, y_test = train_test_split(X, y)
# Set your variables for your environment
EXPERIMENT_NAME="experiment1"
# Set tracking URI to your Heroku application
mlflow.set_tracking_uri("set your mlflow tracking URI")
# mlflow.set_tracking_uri("http://localhost:5000")
# Set experiment's info
mlflow.set_experiment(EXPERIMENT_NAME)
# Get our experiment info
experiment = mlflow.get_experiment_by_name(EXPERIMENT_NAME)
# Call mlflow autolog
mlflow.sklearn.autolog()
with open("test.txt", "w") as f:
f.write("hello world!")
with mlflow.start_run(experiment_id = experiment.experiment_id):
# Specified Parameters
c = 0.1
# Instanciate and fit the model
lr = LogisticRegression(C=c)
lr.fit(X_train.values, y_train.values)
# Store metrics
predicted_qualities = lr.predict(X_test.values)
accuracy = lr.score(X_test.values, y_test.values)
# Print results
print("LogisticRegression model")
print("Accuracy: {}".format(accuracy))
# Log Metric
mlflow.log_metric("Accuracy", accuracy)
# Log Param
mlflow.log_param("C", c)
mlflow.log_artifact('test.txt')
Al ejecutar este script, debería poder registrar sus modelos, métricas y artefactos en MLflow. Los artefactos se almacenarán en Azure Blob Storage, mientras que los metadatos se guardarán en Azure SQL Database.
1. Compruebe el seguimiento de MLflow:Visite la URL de seguimiento de MLflow para encontrar su experimento, los nombres de las ejecuciones y todas las métricas y parámetros del modelo asociados.
Comprobar artefactos de MLflow:Acceda a los artefactos en la interfaz de usuario de MLflow y verifique su presencia en Azure Blob Storage
Ahora, usted y su equipo pueden enviar experimentos a MLflow, realizar un seguimiento de ellos mediante el URI de seguimiento y recuperar información o archivos de modelos de Azure Storage. En el próximo tutorial, exploraremos cómo crear una API para leer modelos almacenados en Azure Storage.
Ha configurado correctamente MLflow con Azure para realizar el seguimiento y administrar sus experimentos de aprendizaje automático. Tenga en cuenta que, según su computadora y sistema operativo, puede tener algunos problemas con Docker, MLflow o los servicios de Azure. Si tiene algún problema, no dude en solicitar ayuda.
A continuación, exploraremos cómo usar los modelos MLflow almacenados en Azure Blob Storage para crear una API y completar el flujo de trabajo de automatización.
¡Gracias por leer!
Nota: Algunas partes de este artículo fueron escritas inicialmente en francés y traducidas al inglés con la ayuda de ChatGPT.
Si este artículo te resultó informativo y útil, no dudes en darme un 👏 y seguirme en Medio | LinkedIn.