Tutorial: Criar seu primeiro modelo de machine learning no Azure Databricks

Este tutorial mostra como criar um modelo de classificação de machine learning usando a scikit-learn biblioteca no Azure Databricks.

A meta é criar um modelo de classificação para prever se um vinho é considerado de "alta qualidade". O conjunto de dados consiste em 11 características de diferentes vinhos (por exemplo, teor alcoólico, acidez e açúcar residual) e uma classificação de qualidade entre 1 e 10.

Este exemplo também ilustra o uso de MLflow para acompanhar o processo de desenvolvimento do modelo e Hyperopt para automatizar o ajuste do hiperparâmetro.

O conjunto de dados é do Repositório de Aprendizado de Máquina da UCI, apresentado em Modeling wine preferences by data mining from physicochemical properties [Cortez et al., 2009].

Antes de começar

• Seu workspace deve estar habilitado para o Catálogo do Unity. Consulte Introdução ao Catálogo do Unity.
• Você deve ter permissão para criar um recurso de computação ou acesso a um recurso de computação que usa o Databricks Runtime para Machine Learning.
• Você deve ter o privilégio USE CATALOG em um catálogo.
• Nesse catálogo, você deve ter os seguintes privilégios em um esquema: USE SCHEMA, CREATE TABLEe CREATE MODEL.

Etapa 1: criar um notebook do Databricks

Para criar um notebook na sua área de trabalho, clique em Novo na barra lateral e, em seguida, clique em Notebook. Um notebook em branco é aberto no workspace.

Para saber mais sobre como criar e gerenciar notebooks, consulte Gerenciar notebooks.

Etapa 2: conectar a recursos de computação

Para fazer análise exploratória de dados e engenharia de dados, você deve ter acesso à computação. As etapas neste artigo exigem o Databricks Runtime para aprendizado de máquina. Para obter mais informações e instruções para a seleção de uma versão de ML para o Databricks Runtime, confira Databricks Runtime para aprendizado de máquina.

No notebook, clique no menu suspenso Conectar no canto superior direito. Se você tiver acesso a um recurso existente que usa o Databricks Runtime para Machine Learning, selecione esse recurso no menu. Caso contrário, clique em Criar novo recurso... para configurar um novo recurso de computação.

Etapa 3: configurar o registro de modelo, o catálogo e o esquema

Há duas etapas importantes necessárias antes de começar. Primeiro, é necessário configurar o cliente do MLflow para usar o Catálogo do Unity como o registro de modelo. Digite o código a seguir em uma nova célula no seu notebook.

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

Você também deve definir o catálogo e o esquema em que o modelo será registrado. Você deve ter o privilégio USE CATALOG no catálogo e os privilégios USE SCHEMA, CREATE TABLE e CREATE MODEL no esquema.

Para obter mais informações sobre como usar o Catálogo do Unity, confira O que é o Catálogo do Unity?.

Digite o código a seguir em uma nova célula no seu notebook.

# If necessary, replace "main" and "default" with a catalog and schema for which you have the required permissions.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"

Etapa 4: carregar dados e criar tabelas do Catálogo do Unity

Este exemplo usa dois arquivos CSV que estão disponíveis em databricks-datasets. Para saber como ingerir seus próprios dados, consulte conectores Standard no Lakeflow Connect.

Digite o código a seguir em uma nova célula no seu notebook. Esse código faz o seguinte:

1. Leia os dados de winequality-white.csv e winequality-red.csv nos DataFrames do Spark.
2. Limpe os dados substituindo espaços em nomes de coluna por sublinhados.
3. Escreva os DataFrames nas tabelas white_wine e red_wine no Catálogo do Unity. Salvar os dados no Catálogo do Unity persiste os dados e permite controlar como compartilhá-los com outras pessoas.

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")

Etapa 5. Pré-processar e dividir os dados

Nesta etapa, você carrega os dados das tabelas do Catálogo do Unity criados na Etapa 4 em Pandas DataFrames e pré-processa os dados. O código nesta seção faz o seguinte:

1. Carrega os dados como Pandas DataFrames.
2. Adiciona uma coluna booliana a cada DataFrame para diferenciar vinhos tintos e brancos e, em seguida, combina os DataFrames em um novo DataFrame, data_df.
3. O conjunto de dados inclui uma coluna quality que classifica os vinhos de 1 a 10, com 10 indicando a mais alta qualidade. O código transforma essa coluna em dois valores de classificação: "Verdadeiro" para indicar um vinho de alta qualidade (quality>= 7) e "Falso" para indicar um vinho que não é de alta qualidade (quality< 7).
4. Divide o DataFrame em conjuntos de dados de treinamento e de teste.

Primeiro, importe as bibliotecas necessárias:

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

Agora carregue e pré-processe os dados:

# 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
)

Etapa 6. Treinar o modelo de classificação

Esta etapa treina um classificador de gradient boosting usando as configurações padrão do algoritmo. Em seguida, ele aplica o modelo resultante ao conjunto de dados de teste e calcula, registra e exibe a área sob a curva operacional do receptor para avaliar o desempenho do modelo.

Primeiro, habilite o registro em log automático do MLflow:

mlflow.autolog()

Agora inicie a execução de treinamento do modelo:

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))

Os resultados da célula mostram a área calculada sob a curva e um gráfico da curva ROC:

Etapa 7. Exibir execuções de experimentos no MLflow

O acompanhamento de experimentos do MLflow ajuda a acompanhar o desenvolvimento do modelo registrando em log o código e os resultados à medida que você desenvolve modelos iterativamente.

Para exibir os resultados registrados em log da execução de treinamento que você acabou de executar, clique no link na saída da célula, conforme mostrado na imagem a seguir.

A página do experimento permite comparar execuções e exibir detalhes de execuções específicas. Clique no nome de uma execução para ver detalhes como valores de parâmetro e métrica para essa execução. Confira Acompanhamento de experimentos do MLflow.

Você também pode ver as execuções do experimento do notebook clicando no ícone de Experiment iconExperimento no canto superior direito do notebook. Isso abre a barra lateral do experimento, que mostra um resumo de cada execução associada ao experimento do notebook, incluindo parâmetros de execução e métricas. Se necessário, clique no ícone de atualização para buscar e monitorar as execuções mais recentes.

Etapa 8. Utilizar Hyperopt para ajuste de hiperparâmetros

Uma etapa importante no desenvolvimento de um modelo de ML é otimizar a precisão do modelo ajustando os parâmetros que controlam o algoritmo, chamados de hiperparâmetros.

O Databricks Runtime ML inclui Hyperopt, uma biblioteca Python para ajuste de hiperparâmetro. Você pode usar o Hyperopt para executar varreduras de hiperparâmetros e treinar vários modelos em paralelo, reduzindo o tempo necessário para otimizar o desempenho do modelo. O acompanhamento do MLflow é integrado ao Hyperopt para registrar em log automaticamente modelos e parâmetros. Para obter informações sobre o ajuste de hiperparâmetro usando Hyperopt no Databricks, confira o Ajuste do Hiperparâmetro.

O código a seguir mostra um exemplo de uso do Hyperopt.

# 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)

Etapa 9. Encontrar o melhor modelo e registrá-lo em log no Catálogo do Unity

O código a seguir identifica a execução que produziu os melhores resultados, conforme medido pela área sob a curva ROC:

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

Usando o run_id que você identificou como melhor modelo, o código a seguir registra esse modelo no Catálogo do Unity.

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")

Etapa 10. Implantar o modelo em produção

Quando estiver pronto para servir e implantar modelos, poderá fazer isso usando a interface de serviço no espaço de trabalho do Azure Databricks.

• Consulte Criar modelo personalizado que serve pontos de extremidade.
• Consulte Pontos de extremidade de consulta para modelos personalizados.

Exemplo de notebook: Criar um modelo de classificação.

Use o notebook a seguir para seguir as etapas desse artigo. Para obter instruções sobre como importar um notebook para um espaço de trabalho do Azure Databricks, confira Importar um notebook.

Crie seu primeiro modelo de aprendizado de máquina no Azure Databricks

Obter notebook

Saiba mais

O Databricks oferece uma única plataforma que atende a todas as etapas do desenvolvimento e implantação de ML, desde os dados brutos até as tabelas de inferência que salvam todas as solicitações e respostas de um modelo servido. Cientistas de dados, engenheiros de dados, engenheiros de ML e DevOps podem fazer seu trabalho usando o mesmo conjunto de ferramentas e uma única fonte de verdade para os dados.

Para saber mais, consulte os seguintes:

• Tutoriais de aprendizado de máquina e IA
• Visão geral de IA e aprendizado de máquina no Databricks
• Visão geral do treinamento de modelos de IA e aprendizado de máquina no Databricks
• MLflow para gerenciamento do ciclo de vida de modelos de ML

Recursos relacionados

• scikit-learn