Comece agora: Crie seu primeiro modelo de machine learning no Databricks

Este exemplo de Notebook ilustra como ensinar um modelo de classificação de machine learning no Databricks. Databricks Runtime for Machine Learning vem com várias bibliotecas pré-instaladas, incluindo scikit-learn para treinamento e pré-processamento de algoritmos, MLflow para acompanhar o processo de desenvolvimento do modelo e Hyperopt com SparkTrials para escalar o ajuste de hiperparâmetros.

Neste Notebook, você criará um modelo de classificação para prever se um vinho é considerado de "alta qualidade". O dataset consiste em 11 recursos de diferentes vinhos (por exemplo, teor alcoólico, acidez e açúcar residual) e uma classificação de qualidade entre 1 e 10.

Este tutorial aborda:

Parte 1: Ensinando um modelo de classificação com acompanhamento MLflow
Parte 2: Ajuste de hiperparâmetros para melhorar o desempenho do modelo
Parte 3: Salvar resultados e modelos no Unity Catalog
Parte 4: implantar o modelo

Para obter mais detalhes sobre como colocar machine learning em produção no Databricks , incluindo o gerenciamento do ciclo de vida do modelo e a inferência do modelo, consulte o Exemplo deML de Ponta a Ponta.

O dataset está disponível no repositório de Aprendizado de Máquina da UCI e é apresentado em Modelagem de preferências de vinho por mineração de dados de propriedades físico-químicas [Cortez et al., 2009].

Requisitos

cluster executando uma das seguintes versões Databricks Runtime : 13.3 LTS ML, 14.3 LTS ML, 15.4 LTS ML ou 16.4 LTS ML. Para Databricks Runtime 17.3 LTS ML ou superior, consulte o tutorial: Crie seu primeiro modelo de machine learning no Databricks.

Configurar

Nesta seção, você fará o seguinte:

Configure o cliente MLflow para usar o Unity Catalog como registro de modelo.
Defina o catálogo e o esquema onde o modelo será registrado.
Leia os dados e salve-os em tabelas no Unity Catalog.
Pré-processar os dados.

Configurar o cliente MLflow

Por default, o cliente Python MLflow cria modelos no workspace Databricks , registro de modelo. Para salvar modelos no Unity Catalog, configure o cliente MLflow conforme mostrado na célula a seguir.

Python
import mlflow
mlflow.set_registry_uri("databricks-uc")

A célula seguinte define o catálogo e o esquema onde o modelo será registrado. Você precisa ter o privilégio USE CATALOG no catálogo e os privilégios USE_SCHEMA, CREATE_TABLE e CREATE_MODEL no esquema. Altere os nomes do catálogo e do esquema na célula seguinte, se necessário.

Para mais informações, consulte a documentaçãoUnity Catalog.

Python
# Specify the catalog and schema to use. You must have USE_CATALOG privilege on the catalog and USE_SCHEMA, CREATE_TABLE, and CREATE_MODEL privileges on the schema.
# Change the catalog and schema here if necessary.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"

Leia os dados e salve-os em tabelas no Unity Catalog

O dataset está disponível em databricks-datasets. Na célula seguinte, você lê os dados dos arquivos .csv para DataFrames do Spark. Em seguida, você grava os DataFrames em tabelas no Unity Catalog. Isso permite tanto a preservação dos dados quanto o controle de como compartilhá-los com outras pessoas.

Python
white_wine = spark.read.csv("/databricks-datasets/wine-quality/winequality-white.csv", sep=';', header=True)
red_wine = spark.read.csv("/databricks-datasets/wine-quality/winequality-red.csv", sep=';', header=True)

# Remove the spaces from the column names
for c in white_wine.columns:
    white_wine = white_wine.withColumnRenamed(c, c.replace(" ", "_"))
for c in red_wine.columns:
    red_wine = red_wine.withColumnRenamed(c, c.replace(" ", "_"))

# Define table names
red_wine_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine"
white_wine_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine"

# Write to tables in Unity Catalog
spark.sql(f"DROP TABLE IF EXISTS {red_wine_table}")
spark.sql(f"DROP TABLE IF EXISTS {white_wine_table}")
white_wine.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine")
red_wine.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine")

Pré-processar dados

Python
# Import required libraries
import numpy as np
import pandas as pd
import sklearn.datasets
import sklearn.metrics
import sklearn.model_selection
import sklearn.ensemble

import matplotlib.pyplot as plt

from hyperopt import fmin, tpe, hp, SparkTrials, Trials, STATUS_OK
from hyperopt.pyll import scope

Python
# Load data from Unity Catalog as Pandas dataframes
white_wine = spark.read.table(f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine").toPandas()
red_wine = spark.read.table(f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine").toPandas()

# Add Boolean fields for red and white wine
white_wine['is_red'] = 0.0
red_wine['is_red'] = 1.0
data_df = pd.concat([white_wine, red_wine], axis=0)

# Define classification labels based on the wine quality
data_labels = data_df['quality'].astype('int') >= 7
data_df = data_df.drop(['quality'], axis=1)

# Split 80/20 train-test
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(
  data_df,
  data_labels,
  test_size=0.2,
  random_state=1
)

Parte 1. Ensinando um modelo de classificação

Python
# Enable MLflow autologging for this notebook
mlflow.autolog()

Em seguida, ensine um classificador no contexto de uma execução MLflow , que logs automaticamente o modelo treinado e muitas métricas e parâmetros associados.

Você pode complementar o registro com métricas adicionais, como a pontuação AUC do modelo no dataset de teste.

Python
with mlflow.start_run(run_name='gradient_boost') as run:
    model = sklearn.ensemble.GradientBoostingClassifier(random_state=0)

    # Models, parameters, and training metrics are tracked automatically
    model.fit(X_train, y_train)

    predicted_probs = model.predict_proba(X_test)
    roc_auc = sklearn.metrics.roc_auc_score(y_test, predicted_probs[:,1])
    roc_curve = sklearn.metrics.RocCurveDisplay.from_estimator(model, X_test, y_test)

    # Save the ROC curve plot to a file
    roc_curve.figure_.savefig("roc_curve.png")

    # The AUC score on test data is not automatically logged, so log it manually
    mlflow.log_metric("test_auc", roc_auc)

    # Log the ROC curve image file as an artifact
    mlflow.log_artifact("roc_curve.png")

    print("Test AUC of: {}".format(roc_auc))

visualizar execução MLflow

Para view os logs de execução do treinamento, clique no ícone Experimento Na parte superior direita do Notebook, para exibir a barra lateral do experimento. Se necessário, clique no ícone refresh para obter e monitorar a execução mais recente.

Experimentos listados na barra lateral direita

Para exibir a página de experimentos do MLflow com mais detalhes, clique no ícone da página de experimentos. Esta página permite comparar a execução e view detalhes de uma execução específica. Consulte o desenvolvimento do modelo Track usando o MLflow.

Carregar modelos

Você também pode acessar os resultados de uma execução específica usando a API do MLflow. O código na célula a seguir ilustra como carregar o modelo treinado em uma determinada execução do MLflow e usá-lo para fazer previsões. Você também pode encontrar trechos de código para carregar modelos específicos na página de execução do MLflow.

Python
# After a model has been logged, you can load it in different notebooks or jobs
# mlflow.pyfunc.load_model makes model prediction available under a common API
model_loaded = mlflow.pyfunc.load_model(
  'runs:/{run_id}/model'.format(
    run_id=run.info.run_id
  )
)

predictions_loaded = model_loaded.predict(X_test)
predictions_original = model.predict(X_test)

# The loaded model should match the original
assert(np.array_equal(predictions_loaded, predictions_original))

Parte 2. Ajuste de hiperparâmetros

Neste ponto, você treinou um modelo simples e utilizou o serviço de acompanhamento MLflow para organizar seu trabalho. Em seguida, você pode realizar ajustes mais sofisticados usando o Hyperopt.

Treinamento paralelo com Hyperopt e SparkTrials

Hyperopt é uma biblioteca Python para ajuste de hiperparâmetros. Para obter mais informações sobre como usar Hyperopt no Databricks, consulte Usar algoritmos de treinamento distribuído com Hyperopt.

Você pode usar Hyperopt com o SparkTrials para executar varreduras de hiperparâmetros e treinar vários modelos em paralelo. Isso reduz o tempo necessário para otimizar o desempenho do modelo. MLflow acompanhamento está integrado ao Hyperopt para logautomaticamente os modelos e parâmetros.

Python
# Define the search space to explore
search_space = {
  'n_estimators': scope.int(hp.quniform('n_estimators', 20, 1000, 1)),
  'learning_rate': hp.loguniform('learning_rate', -3, 0),
  'max_depth': scope.int(hp.quniform('max_depth', 2, 5, 1)),
}

def train_model(params):
  # Enable autologging on each worker
  mlflow.autolog()
  with mlflow.start_run(nested=True):
    model_hp = sklearn.ensemble.GradientBoostingClassifier(
      random_state=0,
      **params
    )
    model_hp.fit(X_train, y_train)
    predicted_probs = model_hp.predict_proba(X_test)
    # Tune based on the test AUC
    # In production, you could use a separate validation set instead
    roc_auc = sklearn.metrics.roc_auc_score(y_test, predicted_probs[:,1])
    mlflow.log_metric('test_auc', roc_auc)

    # Set the loss to -1*auc_score so fmin maximizes the auc_score
    return {'status': STATUS_OK, 'loss': -1*roc_auc}

# SparkTrials distributes the tuning using Spark workers
# Greater parallelism speeds processing, but each hyperparameter trial has less information from other trials
# On smaller clusters try setting parallelism=2
spark_trials = SparkTrials(
  parallelism=1
)

with mlflow.start_run(run_name='gb_hyperopt') as run:
  # Use hyperopt to find the parameters yielding the highest AUC
  best_params = fmin(
    fn=train_model,
    space=search_space,
    algo=tpe.suggest,
    max_evals=32,
    trials=spark_trials)

Execução de busca para recuperar o melhor modelo

Como todas as execuções são rastreadas pelo MLflow, você pode recuperar as métricas e os parâmetros da melhor execução usando a API de busca de execução MLflow para encontrar a execução de ajuste com a maior AUC de teste.

Este modelo ajustado deverá ter um desempenho melhor do que os modelos mais simples treinados na Parte 1.

Python
# Sort runs by their test auc. In case of ties, use the most recent run.
best_run = mlflow.search_runs(
  order_by=['metrics.test_auc DESC', 'start_time DESC'],
  max_results=10,
).iloc[0]
print('Best Run')
print('AUC: {}'.format(best_run["metrics.test_auc"]))
print('Num Estimators: {}'.format(best_run["params.n_estimators"]))
print('Max Depth: {}'.format(best_run["params.max_depth"]))
print('Learning Rate: {}'.format(best_run["params.learning_rate"]))

best_model_pyfunc = mlflow.pyfunc.load_model(
  'runs:/{run_id}/model'.format(
    run_id=best_run.run_id
  )
)

# Make a dataset with all predictions
best_model_predictions = X_test
best_model_predictions["prediction"] = best_model_pyfunc.predict(X_test)

Parte 3. Salvar resultados e modelos no Unity Catalog

Python
predictions_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions"
spark.sql(f"DROP TABLE IF EXISTS {predictions_table}")

results = spark.createDataFrame(best_model_predictions)

# Write results back to Unity Catalog from Python
results.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions")

Python
model_uri = 'runs:/{run_id}/model'.format(
    run_id=best_run.run_id
  )

mlflow.register_model(model_uri, f"{CATALOG_NAME}.{SCHEMA_NAME}.wine_quality_model")

Parte 4. Modelo implantado

Após salvar seu modelo no Unity Catalog, você pode implantá-lo usando a interface de usuário Serving UI. As instruções a seguir fornecem uma breve descrição. Para obter mais informações, consulte Criar endpoint de modelo de navegação personalizado.

Clique em "Servindo" na barra lateral para exibir a interface de usuário de serviço.

servindo modelo UI

Clique em Criar endpoint de serviço .
No campo Nome , forneça um nome para seu endpoint.
Na seção Entidades atendidas
1. Clique no campo Entidade para abrir o formulário Selecionar entidade atendida .
2. Selecione Meus modelos - Unity Catalog . O formulário é atualizado dinamicamente com base na sua seleção.
3. Selecione o wine_quality_model e a versão do modelo que deseja disponibilizar.
4. Selecione 100 como a porcentagem de tráfego que você deseja direcionar para o seu modelo de atendimento.
5. Selecione CPU como o tipo compute para este exemplo.
6. Em "Compute escala-out" , selecione "Small" como o tamanho de compute escala out".
Clique em Criar . A página do endpoint de serviço é exibida com o estado endpoint de serviço como Não pronto .
Quando o seu endpoint estiver pronto , selecione Usar para enviar uma solicitação de inferência ao endpoint.

Exemplo de caderno

Comece agora: Crie seu primeiro modelo de machine learning no Databricks

Abrir notebook em uma nova aba

Requisitos​

Configurar​

Configurar o cliente MLflow​

Leia os dados e salve-os em tabelas no Unity Catalog​

Pré-processar dados​

Parte 1. Ensinando um modelo de classificação​

visualizar execução MLflow​

Carregar modelos​

Parte 2. Ajuste de hiperparâmetros​

Treinamento paralelo com Hyperopt e SparkTrials​

Execução de busca para recuperar o melhor modelo​

Parte 3. Salvar resultados e modelos no Unity Catalog​

Parte 4. Modelo implantado​

Exemplo de caderno​

Comece agora: Crie seu primeiro modelo de machine learning no Databricks

Requisitos

Configurar

Configurar o cliente MLflow

Leia os dados e salve-os em tabelas no Unity Catalog

Pré-processar dados

Parte 1. Ensinando um modelo de classificação

visualizar execução MLflow

Carregar modelos

Parte 2. Ajuste de hiperparâmetros

Treinamento paralelo com Hyperopt e SparkTrials

Execução de busca para recuperar o melhor modelo

Parte 3. Salvar resultados e modelos no Unity Catalog

Parte 4. Modelo implantado

Exemplo de caderno