Get começar: Construa seu primeiro modelo do machine learning no Databricks

Este artigo mostra aos senhores como criar um modelo de classificação machine learning 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 acompanhar o processo de desenvolvimento do modelo e do Hyperopt para automatizar o ajuste de hiperparâmetros.

O site dataset é do repositório UCI Machine Learning, 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 Unity Catalog.

• O senhor deve ter permissão para criar um cluster ou acesso a um cluster.

• 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.

o passo 1: Criar um Databricks Notebook

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

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

o passo 2: Conecte-se ao site compute recurso

Para fazer análise exploratória de dados e engenharia de dados, o senhor precisa ter acesso ao site compute.

Para obter instruções sobre como se conectar ao recurso compute existente, consulte compute. Para obter instruções sobre como configurar um novo recurso compute, consulte a referência de configuração de computação.

Os passos deste artigo requerem Databricks Runtime para Machine Learning. Para obter mais informações e instruções para selecionar uma versão ML de Databricks Runtime, consulte Databricks Runtime for Machine Learning.

o passo 3: Configurar registro de modelo, catálogo e esquema

Há dois passos importantes necessários 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.

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.

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

o passo 4: Carregar dados e criar tabelas Unity Catalog

Este exemplo usa dois arquivos CSV que são incorporados ao Databricks. 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.

white_wine = spark.read.csv("dbfs:/databricks-datasets/wine-quality/winequality-white.csv", sep=';', header=True)
red_wine = spark.read.csv("dbfs:/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")

Passo 5: Pré-processar e dividir os dados

Neste passo, o senhor carrega os dados das tabelas Unity Catalog que criou no passo 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 um conjunto de dados de ensino e teste separado.

Primeiro, importe a biblioteca necessária:

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
)

o passo 6. ensinar o modelo de classificação

Este passo ensina 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:

mlflow.autolog()

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

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:

o passo 7. view experiment execution in MLflow

MLflow O acompanhamento de experimentos ajuda a acompanhar o desenvolvimento do modelo, registrando o código e os resultados à medida que os modelos são desenvolvidos 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.

A página de experimentos permite que o senhor compare a execução e view detalhes de uma execução específica. Consulte MLflow experiment acompanhamento.

o passo 8. ajuste de hiperparâmetros

Um passo importante no desenvolvimento de um modelo 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 ensinar 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.

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

o passo 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:

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

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 os passos deste artigo. Para obter instruções sobre como importar um Notebook para um Databricks workspace, consulte Importar um Notebook.

Construa seu primeiro modelo do machine learning com o Databricks

Abra o bloco de anotações em outra guia Copiar link para importação

Saiba mais

Databricks oferece uma plataforma única que atende a todos os passos do desenvolvimento e da implementação do ML, desde dados brutos até 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:

• Tutorial de aprendizado de máquina e IA

• Visão geral de machine learning e IA sobre Databricks

• Visão geral do treinamento machine learning e modelos de IA sobre Databricks

• Gerenciamento do ciclo de vida do ML usando o MLflow

Recurso relacionado

• scikit-learn