MLflow: Guia Completo para começar a usar em Machine Learning

Se você é um cientista de dados começando a desenvolver modelos de Machine Learning, precisa conhecer o MLflow: uma poderosa ferramenta open source que permite rastrear experimentos, gerenciar modelos e muito mais. Neste tutorial completo, você descobrirá como utilizar as principais funcionalidades como MLflow Tracking para registrar métricas e parâmetros, MLflow AutoLog para logging automático e MLflow Log Model para armazenar modelos no model registry.

O que é MLflow e para que serve?

O MLflow é uma plataforma open-source que facilita a gestão do ciclo de vida de modelos de Machine Learning. Com ela, você pode acompanhar experimentos, reproduzir execuções e implantar facilmente modelos. Possui quatro componentes principais:

1. Tracking: Permite registrar sessões de treinamento de modelos e executar consultas usando APIs Java, Python, R e REST.

2. Models: Fornece uma unidade padrão para empacotar e reutilizar modelos de machine learning.

3. Model registry: Centraliza a gestão dos modelos e seu ciclo de vida.

4. Projects: Empacota o código usado em projetos de ciência de dados, garantindo que possa ser facilmente reutilizado e que os experimentos possam ser reproduzidos.

Passo 1: Como instalar o MLflow

Para começar a usar o MLflow, primeiro você precisa instalá-lo. O MLflow está disponível no PyPI e pode ser instalado com o seguinte comando:

pip install mlflow

Passo 2: Iniciando um servidor de rastreamento

Para iniciar um servidor de rastreamento local, execute o comando abaixo em um terminal:

mlflow server --host 127.0.0.1 --port 8080

Isso irá iniciar um servidor no seu computador, que pode ser acessado pela porta 8080. Mas, logo logo vamos falar sobre a interface do servidor. Para começar a usar o MLflow no Python, primeiro comece importando a biblioteca e definindo o URI do servidor, assim:

import mlflow
mlflow.set_tracking_uri(uri="http://127.0.0.1:8080")

Passo 3: treinando um modelo e preparando metadados para registro

Nesta etapa, vamos treinar um modelo de regressão logística e avaliar seu desempenho. Em seguida, vamos preparar os hiperparâmetros do modelo e calcular métricas para registro.

import mlflow
from mlflow.models import infer_signature
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Carregando dataset de Iris
X, y = datasets.load_iris(return_X_y=True)
# Dividindo os dados em conjuntos de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Definindo os hiperparâmetros do modelo
params = {"solver": "lbfgs", "max_iter": 1000, "multi_class": "auto", "random_state": 8888}
# Treinando o modelo
lr = LogisticRegression(**params)
lr.fit(X_train, y_train)
# Realizando inferência no conjunto de teste
y_pred = lr.predict(X_test)
# Calcular métricas
accuracy = accuracy_score(y_test, y_pred)

Passo 4: Registrando o modelo e seus metadados no MLflow

Vamos iniciar um contexto de execução do MLflow para começar uma nova execução onde registraremos o modelo e metadados. Isso vai lhe permitir gerar um histórico das métricas de treinamento, que poderão ser usadas para análise e comparação futuras. Além disso, vamos também registrar o modelo no Model Registry usando o log_model, permitindo a você utilizar esse modelo em qualquer lugar facilmente.

# Configurar o URI do servidor de rastreamento  
mlflow.set_tracking_uri(uri="http://127.0.0.1:8080")
# Criar um novo experimento MLflow
mlflow.set_experiment("MLflow Quickstart")
# Iniciar uma execução MLflow
with mlflow.start_run():
    # Registrar os hiperparâmetros
    mlflow.log_params(params)
    # Registrar a métrica de acurácia
    mlflow.log_metric("accuracy", accuracy)
    # Definir uma tag para facilitar a recuperação
    mlflow.set_tag("Training Info", "Basic LR model for iris data")
    # Inferir a assinatura do modelo
    signature = infer_signature(X_train, lr.predict(X_train))
    # Registrar o modelo para usarmos depois
    model_info = mlflow.sklearn.log_model(
        sk_model=lr, artifact_path="iris_model", signature=signature,
        input_example=X_train, registered_model_name="tracking-quickstart"
    )

Passo 5: Carregando o modelo para inferência

Após registrar o modelo, podemos realizar inferências carregando-o usando o pyfunc do MLflow.

# Carregar o modelo para predições como uma função Python genérica
loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
predictions = loaded_model.predict(X_test)
iris_feature_names = datasets.load_iris().feature_names
result = pd.DataFrame(X_test, columns=iris_feature_names)
result["actual_class"] = y_test
result["predicted_class"] = predictions
result[:4]

Visualizando a execução na interface do usuário do MLflow

Lembra do servidor que iniciamos lá trás? Agora você pode conferir suas métricas de modelo diretamente nele. Para ver os resultados da nossa execução, abra a UI em http://localhost:8080.

Clique no nome do experimento criado ("MLflow Quickstart") para ver a lista de execuções associadas ao experimento. Clique no nome da execução para ver os detalhes do que foi registrado. Agora é um excelente momento pra se ambientar com a ferramenta.

MLflow Autolog: registre seus experimentos automaticamente

O MLflow possui um recurso de autolog permite que você registre métricas, parâmetros e modelos sem a necessidade de inserir declarações de log explicitamente. Você só precisa chamar mlflow.autolog() antes do seu código de treinamento. Isso habilitará o MLflow para registrar automaticamente várias informações sobre sua execução, incluindo:

• Métricas: MLflow pré-seleciona um conjunto de métricas para registrar, com base no modelo e na biblioteca que você usa.

• Parâmetros: parâmetros de hiperparâmetros especificados para o treinamento.

• Model registry: logs de instância de assinatura do modelo, que descreve o esquema de entrada e saída do modelo.

• Artefatos: como checkpoints de modelo.

• Dataset: objeto de dataset usado para o treinamento (se aplicável).

Para começar a usar o autologging, basta inserir mlflow.autolog() em seu código. Por exemplo:

import mlflow
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_diabetes
from sklearn.ensemble import RandomForestRegressor

mlflow.autolog()

db = load_diabetes()
X_train, X_test, y_train, y_test = train_test_split(db.data, db.target)
rf = RandomForestRegressor(n_estimators=100, max_depth=6, max_features=3)

rf.fit(X_train, y_train)

Você também pode controlar o comportamento do autologging passando argumentos para a função mlflow.autolog(). Por exemplo, você pode desativar o registro de checkpoints de modelo e associar tags à sua execução:

import mlflow

mlflow.autolog(
    log_model_signatures=False,
    extra_tags={"SUA_TAG": "SEU_VALOR"},
)

Conclusão

Agora você deve ter uma boa compreensão de como usar as principais funcionalidades do MLflow para registrar e gerenciar modelos de Machine Learning. O MLflow é uma ferramenta poderosa que facilita a gestão do ciclo de vida de modelos de ML. Com recursos como autologging, você pode economizar tempo e esforço, permitindo que você se concentre no desenvolvimento e melhoria de seus modelos.