Gerenciamento de modelos com MLflow, Azure e Docker | …

Grupo Shoslh
setembro 16, 2024
10:32 pm
Sem comentários

Você pode clonar isso pasta para encontrar todos os scripts necessários para oriente tutorial.

Para hospedar o servidor MLflow, começamos criando um contêiner Docker usando um Dockerfile. Cá está um exemplo de feitio:

# 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"]

Oriente Dockerfile cria um contêiner que executa um servidor MLflow. Ele instala as ferramentas necessárias, incluindo o driver ODBC do Microsoft SQL Server, configura o envolvente e instala as dependências do Python. Em seguida, ele copia nossos arquivos na pasta do aplicativo para o contêiner, expõe a porta 5000 (obrigatória para o MlFlow) e executa um launch.sh script para iniciar o servidor MLflow.

O launch.sh contém exclusivamente o comando que inicia o servidor mlflow.

Crie a imagem do Docker no mesmo diretório onde está seu Dockerfile:

docker build . -t mlflowserver
# if your are on mac, use :
# docker build - platform=linux/amd64 -t mlflowserver:latest .

Execute o contêiner Docker:

docker run -it -p 5000:5000 mlflowserver

Depois de executar esses comandos, o servidor MLflow inicia localmente e você pode acessar a IU do MLflow navegando até http://localhost:5000. Isso confirma que o servidor foi implantado com sucesso na sua máquina sítio. No entanto, neste estágio, embora você possa registrar experimentos no MLflow, nenhum dos resultados, artefatos ou metadados será salvo no banco de dados SQL ou no armazenamento de artefatos, pois eles ainda não foram configurados. Aliás, a URL só pode ser acessada localmente, o que significa que sua equipe de ciência de dados não pode acessá-la remotamente.

Comece criando uma conta do Azure e pegando sua ID da assinatura do Portal do Azure.

Sua visita nos ajuda a continuar oferecendo o melhor para você! oe of og hv oh oi oj ok ol om on oo op oq or os ot ou ov ow gn bk">Para implantar seu servidor MLflow e torná-lo atingível à sua equipe, siga estas etapas simplificadas:

Clonar o Repositório: Clone isto pasta para sua máquina sítio.
Execute o script de implantação: Execute o deploy.sh script porquê um script de shell. Certifique-se de atualizar a variável Subscription ID no script antes de executá-lo.

Embora o Azure ofereça uma interface gráfica para configurar recursos, oriente guia simplifica o processo usando o deploy.sh script para automatizar tudo com um único comando.

Cá está uma estudo do que deploy.sh script faz passo a passo:

1. Faça login e defina a assinatura: Primeiro, faça login na sua conta do Azure e defina a assinatura correta onde todos os seus recursos serão implantados (recupere a ID da assinatura do Portal do Azure).

az login az account set --subscription $SUBSCRIPTION_ID

2. Crie um grupo de recursos: Crie um Grupo de Recursos para organizar todos os recursos que você implantará para o MLflow.

az group create --name $RG_NAME --location

3. Configurar o Banco de Dados SQL do Azure: Crie um Azure SQL Server e um banco de dados SQL onde o MLflow armazenará todos os metadados do 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 o Firewall do SQL Server: Permita o aproximação ao SQL Server de outros serviços do Azure criando uma regra 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. Crie uma conta de armazenamento do Azure: Configurar um Azure Armazenar Conta e um Contêiner de Blobs para armazenar artefatos (por exemplo, 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.Produzir o Registro de Contêiner do Azure (ACR): Crie um Registro de Contêiner do Azure (ACR) para armazenar a imagem do Docker do seu servidor MLflow.

az acr create 
--name $ACR_NAME 
--resource-group $RG_NAME 
--sku Basic 
--admin-enabled true

7.Erigir e enviar imagem do Docker para o ACR: Crie sua imagem Docker para o servidor MLflow e envie-a para o Azure Container Registry. Para isso, você precisa primeiro restaurar o ACR Username e Password e fazer login no 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.Produzir projecto de serviço de aplicativo: Configure um Projecto de Serviço de Aplicativo para hospedar seu servidor MLflow no Azure.

az appservice plan create 
--name $ASP_NAME 
--resource-group $RG_NAME 
--sku B1 
--is-linux 
--location $RG_LOCATION

9. Implantar aplicativo da Web com contêiner MLflow: Crie um Aplicativo da Web que usa sua imagem Docker do ACR para implantar o 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 o aplicativo da Web para usar o Container Registry: Configure seu aplicativo Web para extrair a imagem do MLflow Docker do ACR e configure variáveis de envolvente.

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. Defina as variáveis de envolvente do aplicativo da Web: Defina as variáveis de envolvente necessárias para o MLflow, porquê aproximação ao armazenamento, backend SQL e configurações de porta.


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

Uma vez que o deploy.sh o script foi concluído, você pode verificar se todos os seus serviços do Azure foram criados verificando o portal do Azure.

Acesse a seção Serviços de aplicativo para restaurar a URL do seu aplicativo web MLflow.

Seu URL de rastreamento do MLflow agora deve estar ativo e pronto para receber experimentos da sua equipe de ciência de dados.

Cá está um script Python demonstrando porquê registrar um experimento usando MLflow com um padrão scikit-learn simples, porquê retrocesso logística. Certifique-se de atualizar o script com seu URI de rastreamento do 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')

Ao executar oriente script, você deve conseguir registrar seus modelos, métricas e artefatos no MLflow. Os artefatos serão armazenados no Azure Blob Storage, enquanto os metadados serão salvos no Azure SQL Database.

1Verifique o rastreamento do MLflow: Visite o URL de rastreamento do MLflow para encontrar seu experimento, nomes de realização e todas as métricas e parâmetros de padrão associados

Verifique os artefatos do MLflow: Acesse os artefatos na interface do usuário do MLflow e verifique sua presença no Azure Blob Storage

Agora você e sua equipe podem enviar experimentos para o MLflow, rastreá-los por meio do URI de rastreamento e restaurar informações de padrão ou arquivos do Azure Storage. No próximo tutorial, exploraremos porquê fabricar uma API para ler modelos armazenados no Azure Storage.

Você configurou com sucesso o MLflow com o Azure para rastrear e gerenciar seus experimentos de machine learning. Tenha em mente que, dependendo do seu computador e sistema operacional, você pode encontrar alguns problemas com os serviços Docker, MLflow ou Azure. Se você tiver problemas, não hesite em pedir ajuda.

Sua visita nos ajuda a continuar oferecendo o melhor para você! hs oe of og hv oh oi oj ok ol om on oo op oq or os ot ou ov ow gn bk">Em seguida, exploraremos porquê usar modelos MLflow armazenados no Azure Blob Storage para fabricar uma API, concluindo o fluxo de trabalho de automação.

Sua visita nos ajuda a continuar oferecendo o melhor para você! ov ow gn bk">Obrigado pela leitura!