Ler en inglés

Compartir por

Introducción a la generación del primer modelo de aprendizaje automático en Azure Databricks

  • Artigo

En este artículo se muestra cómo crear un modelo de clasificación de aprendizaje automático mediante la biblioteca scikit-learn en Azure Databricks.

El objetivo es crear un modelo de clasificación para predecir si un vino se considera "de alta calidad". El conjunto de datos consta de 11 características de diferentes vinos (por ejemplo, contenido de alcohol, acidez y azúcar residual) y una clasificación de calidad entre 1 y 10.

Este ejemplo también muestra el uso de MLflow para realizar un seguimiento del proceso de desarrollo del modelo e Hyperopt para automatizar el ajuste de hiperparámetros.

El conjunto de datos procede del repositorio de Machine Learning de UCI, presentado en Preferencias de vino de modelado por minería de datos de propiedades fisicoquímicas [Cortez et al., 2009].

Antes de empezar

  • Su área de trabajo debe estar habilitada para Unity Catalog.
  • Debe tener permisos para crear un clúster o acceder a un clúster.
  • Debe tener el privilegio USE_CATALOG en un catálogo.
  • Dentro de ese catálogo, debe tener los siguientes privilegios en un esquema: USE_SCHEMA, CREATE_TABLE y CREATE_MODEL.

Suxestión

Todo el código de este artículo está disponible en un cuaderno que puede importar directamente en el área de trabajo. Consulte Cuaderno de ejemplo: Creación de un modelo de clasificación.

Paso 1: creación de un cuaderno de Databricks

Para crear un cuaderno en el área de trabajo, haga clic en Nuevo iconoNuevo en la barra lateral y a continuación, haga clic en Cuaderno. Se abre un cuaderno en blanco en el área de trabajo.

Para obtener más información sobre cómo crear y administrar cuadernos, consulte Administración de cuadernos.

Paso 2: conexión a los recursos de proceso

Para realizar análisis exploratorios de datos e ingeniería de datos, debe tener acceso al proceso.

Para obtener instrucciones sobre cómo conectarse a los recursos de proceso existentes, consulte Proceso. Para obtener instrucciones sobre cómo configurar un nuevo recurso de proceso, consulte Referencia de configuración de proceso.

Los pasos de este artículo requieren Databricks Runtime para Machine Learning. Para obtener más información e instrucciones para seleccionar una versión ML de Databricks Runtime, consulte Databricks Runtime for Machine Learning.

Paso 3: configurar el registro de modelos, el catálogo y el esquema

Hay dos pasos importantes necesarios antes de empezar. En primer lugar, debe configurar el cliente de MLflow para que use el catálogo de Unity como registro de modelos. Escriba el siguiente código en una nueva celda del cuaderno.

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

También debe establecer el catálogo y el esquema donde se registrará el modelo. Debe tener privilegios USE CATALOG en el catálogo y privilegios USE_SCHEMA, CREATE_TABLE y CREATE_MODEL en el esquema.

Para obtener más información sobre el uso del catálogo de Unity, consulte ¿Qué es Unity Catalog?

Escriba el siguiente código en una nueva celda del cuaderno.

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"

Paso 4: carga de datos y creación de tablas de catálogo de Unity

En este ejemplo se usan dos archivos CSV integrados en Azure Databricks. Para obtener más información sobre la ingesta de los propios datos, consulte Ingesta de datos en una instancia de Databricks lakehouse.

Escriba el siguiente código en una nueva celda del cuaderno.

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

Paso 5. Preprocesamiento y división de los datos

En este paso, cargará los datos de las tablas del catálogo de Unity que creó en el paso 4 en DataFrames de Pandas y preprocesará los datos. El código de esta sección realiza lo siguiente:

  1. Carga los datos en una trama de datos de Pandas.
  2. Agrega una columna booleana a cada DataFrame para distinguir vinos tintos y blancos y, a continuación, combina los dataframes en un nuevo dataframe, data_df.
  3. El conjunto de datos incluye una columna quality que califica los vinos de 1 a 10, donde 10 indica la mayor calidad. El código transforma esta columna en dos valores de clasificación: "True" para indicar un vino de alta calidad (quality>= 7) y "False" para indicar un vino que no es de alta calidad (quality< 7).
  4. Divide los datos en conjuntos de entrenamiento y de prueba independientes.

En primer lugar, importe las bibliotecas necesarias:

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

Ahora cargue y preprocese los datos:

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
)

Paso 6. Entrenamiento del modelo de clasificación

Este paso entrena un clasificador de potenciación del gradiente mediante la configuración predeterminada del algoritmo. A continuación, aplica el modelo resultante al conjunto de datos de prueba y calcula, registra y muestra el área bajo la curva operativa del receptor para evaluar el rendimiento del modelo.

En primer lugar, habilite el registro automático de MLflow:

Python 
mlflow.autolog()

Ahora inicie la ejecución de entrenamiento del modelo:

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

Los resultados de la celda muestran el área calculada bajo la curva y un trazado de la curva ROC:

Curva ROC para el modelo de clasificación.

Paso 7. Visualización de ejecuciones de experimentos en MLflow

El seguimiento de experimentos de MLflow le ayuda a realizar un seguimiento del desarrollo de modelos mediante el registro de código y los resultados a medida que desarrolla modelos de forma iterativa.

Para ver los resultados registrados de la ejecución de entrenamiento que acaba de ejecutar, haga clic en el vínculo de la salida de la celda, como se muestra en la siguiente imagen.

Vínculo al experimento en los resultados de la celda.

La página del experimento permite comparar ejecuciones y ver detalles de ejecuciones específicas. Consulte Seguimiento de experimentos de MLflow.

Paso 8. Ajuste de hiperparámetros

Un paso importante para desarrollar un modelo de ML es optimizar la precisión del modelo mediante el ajuste de los parámetros que controlan el algoritmo, denominados hiperparámetros.

Databricks Runtime ML incluye Hyperopt, una biblioteca de Python para ajustar hiperparámetros. Puede usar Hyperopt para ejecutar barridos de hiperparámetros y entrenar varios modelos en paralelo, lo que reduce el tiempo necesario para optimizar el rendimiento del modelo. El seguimiento de MLflow se integra con Hyperopt para registrar automáticamente modelos y parámetros. Para obtener más información sobre el uso de Hyperopt en Databricks, consulte Ajuste de hiperparámetros.

En el código siguiente se muestra un ejemplo del uso de 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)

Paso 9. Encuentre el mejor modelo y regístrelo en el catálogo de Unity

El código siguiente identifica la ejecución que produjo los mejores resultados, medidos por el área bajo la 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"]))

Con el run_id que identificó para el mejor modelo, el código siguiente registra ese modelo en el catálogo de Unity.

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

Cuaderno de ejemplo: Creación de un modelo de clasificación

Use el siguiente cuaderno para realizar los pasos descritos en este artículo. Para obtener instrucciones sobre cómo importar un cuaderno a un área de trabajo de Azure Databricks, consulte Importación de un cuaderno.

Compilación del primer modelo de Machine Learning con Databricks

Obtener el cuaderno

Saber más

Databricks proporciona una única plataforma que sirve cada paso del proceso de desarrollo e implementación de ML, desde datos sin procesar hasta tablas de inferencia que guardan todas las solicitudes y respuestas de un modelo servido. Los científicos de datos, los ingenieros de datos, los ingenieros de aprendizaje automático y DevOps pueden realizar su labor con el mismo conjunto de herramientas y una única fuente fiable para los datos.

Para obtener más información, consulte: