Freigeben über

Erste Schritte mit dem Machine Learning-Modell in Azure Databricks

  • Artikel

In diesem Artikel erfahren Sie, wie Sie ein Machine Learning-Klassifizierungsmodell mithilfe der scikit-learn Bibliothek in Azure Databricks erstellen.

Ziel ist es, ein Klassifizierungsmodell zu erstellen, um vorherzusagen, ob ein Wein als "qualitativ hochwertig" gilt. Das Dataset besteht aus 11 Features verschiedener Weine (z.B. Alkoholgehalt, Säure und Restzucker) und einer Qualitätsbewertung zwischen 1 und 10.

Zudem veranschaulicht es die Verwendung von MLflow zum Nachverfolgen des Modell-Entwicklungsprozesses und Hyperopt zum Automatisieren der Hyperparameteroptimierung.

Das Dataset stammt aus dem UCI Machine Learning Repository, das in der Studie Modeling wine preferences by data mining from physicochemical properties [Cortez et al., 2009] vorgestellt wird.

Voraussetzungen

  • Ihr Arbeitsbereich muss für Unity Catalog aktiviert sein.
  • Sie haben die Berechtigung, einen Cluster zu erstellen oder auf einen Cluster zuzugreifen.
  • Sie müssen über die Berechtigung USE_CATALOG für einen Katalog verfügen.
  • Innerhalb dieses Katalogs müssen Sie über die folgenden Berechtigungen für ein Schema verfügen: USE_SCHEMA, CREATE_TABLE und CREATE_MODEL.

Tipp

Der gesamte Code in diesem Artikel steht in einem Notebook zur Verfügung, das Sie direkt in Ihren Arbeitsbereich importieren können. Siehe Beispiel-Notebook: Erstellen eines Klassifizierungsmodells.

Schritt 1: Erstellen eines Databricks-Notebooks

Wenn Sie ein Notebook in Ihrem Arbeitsbereich erstellen möchten, wählen Sie in der Randleiste Neues SymbolNeu aus, und wählen Sie dann Notebook aus. Im Arbeitsbereich wird ein leeres Notebook geöffnet.

Weitere Informationen zum Erstellen und Verwalten von Notebooks finden Sie unter Verwalten von Notebooks.

Schritt 2: Verbindung zu Rechenressourcen

Für die explorative Datenanalyse und die Datentechnik benötigen Sie Zugang zu Compute.

Anweisungen zum Herstellen einer Verbindung mit vorhandenen Compute-Ressourcen finden Sie unter Compute. Anweisungen zum Konfigurieren einer neuen Compute-Ressource finden Sie in der Compute-Konfigurationsreferenz.

Die Schritte in diesem Artikel erfordern Databricks Runtime für Maschinelles Lernen. Weitere Informationen, einschließlich Anweisungen zum Erstellen eines Databricks Runtime ML-Clusters, finden Sie unter Databricks Runtime für Maschinelles Lernen.

Schritt 3: Einrichten der Modell-Registrierung, des Katalogs und des Schemas

Es sind zwei wichtige Schritte erforderlich, bevor Sie beginnen. Zunächst müssen Sie den MLflow-Client so konfigurieren, dass Unity Catalog als Modellregistrierung verwendet wird. Fügen Sie den folgenden Code in einer neuen Zelle in Ihrem Notebook hinzu.

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

Sie müssen auch den Katalog und das Schema festlegen, in dem das Modell registriert wird. Sie müssen über die USE CATALOG-Berechtigung für den Katalog und USE_SCHEMA, CREATE_TABLE und CREATE_MODEL Berechtigungen für das Schema verfügen.

Weitere Informationen zu Unity Catalog finden Sie unter Unity Catalog.

Fügen Sie den folgenden Code in einer neuen Zelle in Ihrem Notebook hinzu.

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

Schritt 4: Laden von Daten und Erstellen von Unity Catalog–Tabellen

In diesem Beispiel werden zwei CSV-Dateien verwendet, die in Azure Databricks integriert sind. Wie Sie Ihre eigenen Daten übernehmen können, erfahren Sie unter Übernahme von Daten in ein Databricks Lakehouse.

Fügen Sie den folgenden Code in einer neuen Zelle in Ihrem Notebook hinzu.

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

Schritt 5. Vorverarbeitung und Aufteilen der Daten

In diesem Schritt laden Sie die Daten aus den Unity Catalog-Tabellen, die Sie in Schritt 4 erstellt haben, in Pandas DataFrames und führen eine Vor-Verarbeitung der Daten durch. Das Codebeispiel in diesem Abschnitt erfüllt die Folgendes:

  1. Laden der Daten in ein Pandas-DataFrames.
  2. Fügt jedem DataFrame eine bool'sche Spalte hinzu, um zwischen Rot- und Weißwein zu unterscheiden, und kombiniert dann die DataFrames zu einem neuen DataFrame, data_df.
  3. Das Dataset enthält eine quality Spalte, die Weine von 1 bis 10 bewertet, wobei 10 die höchste Qualität angibt. Der Code wandelt diese Spalte in zwei Klassifizierungswerte um: "True", um einen qualitativ hochwertigen Wein (quality>= 7) anzugeben und "False", um einen Wein anzugeben, der nicht qualitativ hochwertig (quality< 7) ist.
  4. Teilt den DataFrame in separate Trainings- und Testdatensätze auf.

Zuerst importieren Sie die erforderlichen Bibliotheken:

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

Jetzt laden Sie die Daten und führen eine Vorverarbeitung derselben aus:

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

Schritt 6. Trainieren eines Klassifizierungsmodells

In diesem Schritt wird ein Gradient Boosting-Klassifizierer mit den Standardeinstellungen des Algorithmus trainiert. Anschließend wendet es das resultierende Modell auf den Testdatensatz an und berechnet, protokolliert und zeigt den Bereich unter der Empfängerleistungskurve an, um die Leistung des Modells zu bewerten.

Zuerst aktivieren Sie die automatische MLflow-Protokollierung:

mlflow.autolog()

Starten Sie nun die Modell-Trainings-Ausführung:

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

Die Zellergebnisse zeigen den berechneten Bereich unter der Kurve und eine Plot der ROC-Kurve an:

ROC-Kurve für Klassifizierungsmodell.

Schritt 7. Ansicht der Experiment-Ausführungen in MLflow

Mithilfe der MLflow-Experimentverfolgung können Sie die Modellentwicklung nachverfolgen, indem Sie Code und Ergebnisse protokollieren, während Sie Modelle iterativ entwickeln.

Um die protokollierten Ergebnisse des soeben durchgeführten Trainingslaufs anzuzeigen, klicken Sie auf den Link in der Zelle Ausgabe, wie in der folgenden Abbildung dargestellt.

Verknüpfung mit Experimenten in Zellergebnissen.

Auf der Experiment-Seite können Sie Ausführungsläufe vergleichen und Details für bestimmte Läufe anzeigen. Nachverfolgung von MLflow Experimenten.

Schritt 8: Hyperparameteroptimierung

Ein wichtiger Schritt bei der Entwicklung eines ML-Modells besteht darin, die Genauigkeit des Modells zu optimieren, indem die Parameter optimiert werden, die den Algorithmus steuern und die als Hyperparameter bezeichnet werden.

Databricks Runtime ML beinhaltet Hyperopt, Python-Bibliothek, für die Optimierung von Hyperparametern. Mit Hyperopt können Sie Hyperparameter-Sweeps durchführen und mehrere Modelle parallel trainieren, wodurch sich die erforderliche Zeit für die Optimierung der Modellleistung verkürzt. Die MLflow-Nachverfolgung ist in Hyperopt integriert, um automatisch Modelle und Parameter zu protokollieren. Allgemeine Informationen zur Hyperparameter-Optimierung in Azure Databricks finden Sie unter Hyperparameter-Optimierung.

Der folgende Code zeigt ein Beispiel für die Verwendung von 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)

Schritt 9 Wählen Sie das beste Modell und registrieren Sie es in Unity Catalog

Der folgende Code identifiziert den Testlauf, der die besten Ergebnisse liefert, gemessen am Bereich unter der ROC-Kurve:

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

Mit dem run_id von Ihnen ermittelten besten Modell registriert der folgende Code dieses Modell in 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")

Beispiel-Notebook: Build eines Klassifizierungsmodells

Verwenden Sie das folgende Notebook, um die Schritte in diesem Artikel auszuführen. Anweisungen zum Importieren eines Notebooks in einen Azure Databricks-Arbeitsbereich finden Sie unter Importieren eines Notebooks.

Erstellen Ihres ersten Machine Learning-Modells mit Databricks

Notebook abrufen

Weitere Informationen

Mit Databricks kann eine einzige Plattform für jeden Schritt des Modellentwicklungs- und Bereitstellungsprozesses verwendet werden. Dies von Rohdaten bis hin zu Rückschlusstabellen, die alle Anforderungen und Antworten für ein bereitgestelltes Modell speichern. Datenwissenschaftler, Dateningenieure, ML-Ingenieure und DevOps können ihre Aufgaben mit denselben Tools und einer Single Source of Truth für die Daten erledigen.

Weitere Informationen finden Sie in den folgenden Artikeln: