Pular para o conteúdo principal

Começar: Crie seu primeiro modelo de aprendizado de máquina em Databricks

Este artigo mostra aos senhores como criar um modelo de classificação de aprendizado de máquina usando a biblioteca scikit-learn em Databricks.

O objetivo é criar um modelo de classificação para prever se um vinho é considerado de “alta qualidade”. O site dataset consiste em 11 critérios de diferentes vinhos (por exemplo, teor alcoólico, acidez e açúcar residual) e uma classificação de qualidade de 1 a 10.

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

O site dataset é do UCI Machine Learning Repository, apresentado em Modeling wine preferences by data mining from physicochemical properties [Cortez et al., 2009].

Antes de começar​

  • Seu site workspace deve estar habilitado para Unity Catalog. Consulte Configurar e gerenciar o Unity Catalog.
  • O senhor deve ter permissão para criar um recurso compute ou acesso a um recurso compute que use 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_TABLE e CREATE_MODEL.
dica

Todo o código deste artigo está disponível em um Notebook que o senhor pode importar diretamente para o site workspace. Consulte o Example Notebook: Criar um modelo de classificação.

Etapa 1: Criar um notebook Databricks​

Para criar um notebook no seu workspace, clique em Novo ícone Novo na barra lateral e clique em Notebook . Um notebook em branco será aberto no workspace.

Para saber mais sobre como criar e gerenciar o Notebook, consulte gerenciar o Notebook.

Etapa 2: Conecte-se ao site compute recurso​

Para fazer análise exploratória de dados e engenharia de dados, o senhor deve ter acesso a compute. As etapas deste artigo exigem o site Databricks Runtime para aprendizado de máquina. Para obter mais informações e instruções para selecionar uma versão ML de Databricks Runtime, consulte Databricks Runtime for Machine Learning.

Em seu Notebook, clique no menu suspenso Connect (Conectar ) no canto superior direito. Se o senhor tiver acesso a um recurso existente que usa o Databricks Runtime for Machine Learning, selecione esse recurso no menu. Caso contrário, clique em Create new recurso... para configurar um novo recurso compute.

Etapa 3: Configurar registro de modelo, catálogo e esquema​

Há duas etapas importantes necessárias antes de o senhor começar. Primeiro, é preciso configurar o cliente MLflow para usar o Unity Catalog como registro de modelo. Digite o código a seguir em uma nova célula do Notebook.

Python
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. O senhor 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 Unity Catalog, consulte O que é Unity Catalog?

Digite o código a seguir em uma nova célula do Notebook.

Python
# 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 Unity Catalog​

Este exemplo usa dois arquivos CSV que estão disponíveis em databricks-datasets. Para saber como ingerir seus próprios dados, consulte Ingerir dados em um lakehouse da Databricks.

Digite o código a seguir em uma nova célula do Notebook. Esse código faz o seguinte:

  1. Ler dados de winequality-white.csv e winequality-red.csv em Spark DataFrames.
  2. Limpe os dados substituindo os espaços nos nomes das colunas por sublinhados.
  3. Escreva os DataFrames nas tabelas white_wine e red_wine no Unity Catalog. Salvar os dados no Unity Catalog persiste os dados e permite que o senhor controle 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")

Etapa 5. Pré-processe e divida os dados​

Nesta etapa, o senhor carrega os dados das tabelas do Unity Catalog que criou 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 Boolean a cada DataFrame para distinguir vinhos tintos e brancos e, em seguida, combina o DataFrames em um novo DataFrame, data_df.
  3. O site dataset inclui uma coluna quality que classifica os vinhos de 1 a 10, sendo que 10 indica 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 site DataFrame em conjuntos de dados de treinamento e teste separados.

Primeiro, importe a biblioteca necessária:

Python
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:

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
)

Etapa 6. Treine o modelo de classificação​

Essa etapa treina um classificador de aumento de gradiente usando as configurações do algoritmo default. Em seguida, ele aplica o modelo resultante ao teste dataset e calcula, logs, e exibe a área sob a curva operacional do receptor para avaliar o desempenho do modelo.

Primeiro, ative o MLflow autologging:

Python
mlflow.autolog()

Agora o senhor começa o modelo de treinamento execução:

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

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

Curva ROC para o modelo de classificação.

Etapa 7. visualizar a execução do experimento em MLflow​

MLflow O acompanhamento de experimentos ajuda a acompanhar o desenvolvimento do modelo, registrando o código e os resultados à medida que o usuário desenvolve modelos iterativamente.

Para view os resultados dos registros da execução do treinamento que o senhor acabou de executar, clique no link na saída da célula, conforme mostrado na imagem a seguir.

Link para experimentar os resultados das células.

A página de experimentos permite que o senhor compare a execução e view detalhes de uma execução específica. Clique no nome de uma execução para ver detalhes, como valores de parâmetros e métricas para essa execução. Consulte MLflow experiment acompanhamento.

O senhor também pode view a execução do experimento do Notebook clicando no ícone do experimento Ícone Experimentar 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 refresh para buscar e monitorar a execução mais recente.

A barra lateral de execução de experimentos no Notebook mostra a última execução do MLflow.

Etapa 8. Usar o 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 o Hyperopt, uma biblioteca Python para ajuste de hiperparâmetros. O senhor pode usar o site 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. MLflow O acompanhamento é integrado com o site Hyperopt para modelos logged e parâmetros automaticamente. Para obter mais informações sobre o uso do Hyperopt em Databricks, consulte Hyperparameter tuning (Ajuste de hiperparâmetros).

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

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)

Etapa 9. Encontre o melhor modelo e registre-o no Unity Catalog​

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

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

Usando o run_id que o senhor identificou como o melhor modelo, o código a seguir registra esse modelo em Unity Catalog.

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

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

Use o Notebook a seguir para executar as etapas deste artigo. Para obter instruções sobre como importar um Notebook para um Databricks workspace, consulte Importar um Notebook.

Crie seu primeiro modelo de aprendizado de máquina com Databricks

Open notebook in new tab

Saiba mais​

A Databricks oferece uma plataforma única que atende a todas as etapas de 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 atendido. data scientistsO senhor pode usar o mesmo conjunto de ferramentas e uma única fonte de verdade para os dados, os engenheiros de dados, os engenheiros do ML e o DevOps.

Para saber mais, consulte o seguinte:

Recurso relacionado​

Última atualização em