Freigeben über

Lernprogramm: Erstellen Ihres ersten Machine Learning-Modells auf Azure Databricks

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

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

Dieses Beispiel illustriert auch die Nutzung von MLflow, um den Modellentwicklungsprozess nachzuverfolgen, und Hyperopt, um die Automatisierung der Hyperparametertuning zu ermöglichen.

Das Dataset stammt aus dem UCI Machine Learning Repository, präsentiert in Modellierung von Weineinstellungen durch Data Mining aus physikochemischen Eigenschaften [Cortez et al., 2009].

Vorbereitung

  • Ihr Arbeitsbereich muss für Unity Catalog aktiviert sein. Weitere Informationen finden Sie unter "Erste Schritte mit Unity-Katalog".
  • Sie müssen über die Berechtigung zum Erstellen einer Computeressource oder des Zugriffs auf eine Computeressource verfügen, die Databricks Runtime für Maschinelles Lernen verwendet.
  • Um einen Katalog verwenden zu können, benötigen Sie die USE CATALOG Berechtigung.
  • Innerhalb dieses Katalogs müssen Sie über die folgenden Berechtigungen für ein Schema verfügen: USE SCHEMA, , CREATE TABLEund CREATE MODEL.

Tipp

Der gesamte Code in diesem Artikel ist in einem Notizbuch verfügbar, das Sie direkt in Ihren Arbeitsbereich importieren können. Siehe Beispielanleitung: Erstellen Sie ein Klassifizierungsmodell.

Schritt 1: Erstellen Sie ein Databricks-Notizbuch

Um ein Notizbuch in Ihrem Arbeitsbereich zu erstellen, klicken Sie in der Randleiste auf Neues SymbolNeu und dann auf Notizbuch. Im Arbeitsbereich wird ein leeres Notebook geöffnet.

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

Schritt 2: Verbinden mit Compute-Ressourcen

Um explorative Datenanalysen und Data Engineering durchzuführen, müssen Sie Zugriff auf die Berechnung haben. Die Schritte in diesem Artikel erfordern Databricks Runtime für Machine Learning. Weitere Informationen und Anweisungen zur Auswahl einer ML-Version von Databricks Runtime finden Sie unter Databricks Runtime für Machine Learning.

Klicken Sie in Ihrem Notizbuch oben rechts auf das Dropdownmenü "Verbinden ". Wenn Sie Zugriff auf eine vorhandene Ressource haben, die Databricks Runtime für Maschinelles Lernen verwendet, wählen Sie diese Ressource aus dem Menü aus. Klicken Sie andernfalls auf " Neue Ressource erstellen", um eine neue Computeressource zu konfigurieren.

Schritt 3: Setup von Modellregistrierung, Katalog und Schema

Es sind zwei wichtige Schritte erforderlich, bevor Sie loslegen. Zuerst müssen Sie den MLflow-Client konfigurieren, um den Unity-Katalog als Modellregistrierung zu nutzen. Geben Sie den folgenden Code in eine neue Zelle in Ihrem Notizbuch ein.

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 USE CATALOG-Berechtigungen für den Katalog sowie USE SCHEMA-, CREATE TABLE- und CREATE MODEL-Berechtigungen für das Schema verfügen.

Weitere Informationen zur Nutzung von Unity Catalog finden Sie unter Was ist Unity Catalog?.

Geben Sie den folgenden Code in eine neue Zelle in Ihrem Notizbuch ein.

# 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: Auslastung von Daten und Erstellen von Unity Katalog Tabellen

In diesem Beispiel werden zwei CSV-Dateien verwendet, die in databricks-datasets verfügbar sind. Um zu erfahren, wie Sie Ihre eigenen Daten einspeisen, sehen Sie unter Standard-Connectors in Lakeflow Connect nach.

Geben Sie den folgenden Code in eine neue Zelle in Ihrem Notizbuch ein. Dieser Code bewirkt Folgendes:

  1. Daten aus winequality-white.csv und winequality-red.csv in Spark DataFrames lesen.
  2. Bereinigen Sie die Daten, indem Sie Leerzeichen in Spaltennamen durch Unterstriche ersetzen.
  3. Schreiben Sie die Datenrahmen in die Tabellen „white_wine“ und „red_wine“ im Unity-Katalog. Durch das Speichern der Daten im Unity-Katalog bleiben die Daten erhalten, und Sie können steuern, wie sie für andere Personen freigegeben werden.
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")

Schritt 5. Vorverarbeiten und teilen Sie die Daten

In diesem Schritt laden Sie die Daten aus den Unity-Katalogtabellen, die Sie in Schritt 4 erstellt haben, in Pandas DataFrames und vorverarbeiten die Daten. Der Code in diesem Abschnitt macht Folgendes:

  1. Lädt die Daten als Pandas DataFrames.
  2. Fügt jeder Datenrahmen eine boolesche Spalte hinzu, um rote und weiße Weine zu unterscheiden, und vereint dann die Datenrahmen in einem neuen Datenrahmen, „data_df“.
  3. Das Dataset enthält eine quality Spalte, die Weine von 1 bis 10 bewertet, wobei 10 die höchste Qualität anzeigt. Der Code transformiert diese Spalte in zwei Klassifizierungswerte: „True“ zur Angabe eines Weins von hoher Qualität (quality>= 7) und „False“ zur Angabe eines Weins, der nicht von hoher Qualität ist (quality< 7).
  4. Teilt den DataFrame in separate Trainings- und Testdatasets auf.

Zuerst die erforderlichen Bibliotheken importieren:

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 die Daten laden und vorverarbeiten:

# 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. Das Klassifizierungsmodell trainieren

Dieser Schritt trainiert einen Gradient Boosting Klassifizierer mit den Standardalgorithmus-Einstellungen. Anschließend wird das resultierende Modell auf das Testdatenset angewendet und berechnet, protokolliert und zeigt den Bereich unter der Empfängerbetriebskurve an, um die Leistung des Modells zu bewerten.

Aktivieren Sie zuerst die MLflow automatische Protokollierung:

mlflow.autolog()

Jetzt das Modelltraining ausführen:

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 Zelle Ergebnisse zeigen den berechneten Bereich unter der Kurve und ein Zeichnen der ROC-Kurve:

ROC-Kurve für Klassifizierungsmodell.

Schritt 7. Sicht von Experimentausführungen in MLflow

MLflow-Experimentnachverfolgung hilft Ihnen, die Modellentwicklung nachzuverfolgen, indem Sie Code und Ergebnisse protokollieren, während Sie Modelle iterativ entwickeln.

Um die protokollierten Ergebnisse des gerade ausgeführten Trainingslaufs anzusehen, klicken Sie auf die Verknüpfung in der Zelle, wie im folgenden Bild gezeigt.

Verknüpfung zu Experiment in Zelle Ergebnisse.

Die Experiment-Seite erlaubt es Ihnen, Ausführungen zu vergleichen und Details für spezifische Ausführungen anzusehen. Klicken Sie auf den Namen einer Ausführung, um Details wie Parameter und Metrikwerte für diese Ausführung anzuzeigen. Siehe MLflow-Experiment-Nachverfolgung.

Sie können auch die Experimentdurchläufe Ihres Notizbuchs anzeigen, indem Sie auf das Symbol "Experiment" oben rechts im Notizbuch klicken. Dadurch wird die Seitenleiste des Experiments geöffnet, die eine Zusammenfassung jeder Ausführung anzeigt, die dem Notizbuchexperiment zugeordnet ist, einschließlich der Ausführungsparameter und Metriken. Klicken Sie bei Bedarf auf das Aktualisierungssymbol, um die neuesten Ausführungen abzurufen und zu überwachen.

Die Experiment-Randleiste im Notizbuch zeigt die neuesten MLflow-Ausführungen.

Schritt 8: Verwenden von Hyperopt für die 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, die als Hyperparameter bezeichnet werden.

Databricks Runtime ML umfasst Hyperopt, eine Python-Bibliothek zur Hyperparameter-Abstimmung. Sie können Hyperopt nutzen, um Hyperparameter-Sweeps auszuführen und mehrere Modelle parallel zu trainieren, wodurch die Zeit zur Optimierung der Modellleistung reduziert wird. MLflow-Nachverfolgung ist mit Hyperopt integriert, um Modelle und Parameter automatisch zu protokollieren. Weitere Informationen zur Verwendung von Hyperopt in Databricks finden Sie unter Hyperparameter-Tuning.

Der folgende Code zeigt ein Codebeispiel zur 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 Suchen Sie das Bestleistungsmodell und registrieren Sie es im Unity-Katalog

Der folgende Code identifiziert den Lauf, der die Bestleistung erzielte, gemessen durch den 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"]))

Unter Verwendung des von Ihnen für das Bestleistungsmodell identifizierten run_id registriert der folgende Code dieses Modell im Unity-Katalog.

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

Schritt 10. Bereitstellen des Modells in der Produktion

Wenn Sie bereit sind, Ihre Modelle bereitzustellen und bereitzustellen, können Sie dies mithilfe der Benutzeroberfläche "Serve" in Ihrem Azure Databricks-Arbeitsbereich tun.

Beispielnotizbuch: Ein Klassifizierungsmodell erstellen

Verwenden Sie das folgende Notizbuch, um die Schritte in diesem Artikel auszuführen. Für Anweisungen zum Importieren eines Notizbuchs in einen Azure Databricks-Arbeitsbereich, siehe Notizbuch importieren.

Erstellen Sie Ihr erstes Machine Learning-Modell mit Azure Databricks

Notebook abrufen

Weitere Informationen

Databricks bietet eine EINZEL-Plattform, die jeden Schritt der ML-Entwicklung und Bereitstellung abdeckt, von Rohdaten bis hin zu Inferenztabellen, die jede Anforderung und Antwort für ein bereitgestelltes Modell speichern. Data Scientists, Datentechniker, ML-Ingenieure UND DevOps können ihre Aufträge mit derselben Menge an Werkzeugen UND einer EINZELEN Quelle der Datenwahrheit erledigen.

Weitere Informationen finden Sie in den folgenden Artikeln:

  • Last updated on