Delen via

Aan de slag: Uw eerste Machine Learning-model bouwen in Azure Databricks

  • Artikel

In dit artikel leest u hoe u een machine learning-classificatiemodel bouwt met behulp van de scikit-learn bibliotheek in Azure Databricks.

Het doel is om een classificatiemodel te maken om te voorspellen of een wijn wordt beschouwd als 'hoge kwaliteit'. De gegevensset bestaat uit 11 kenmerken van verschillende wijnen (bijvoorbeeld alcoholgehalte, zuurgehalte en restsuiker) en een kwaliteitsclassificatie tussen 1 en 10.

In dit voorbeeld ziet u ook het gebruik van MLflow om het modelontwikkelingsproces bij te houden en Hyperopt om het afstemmen van hyperparameters te automatiseren.

De gegevensset is afkomstig uit de UCI Machine Learning Repository, gepresenteerd in modellering wijnvoorkeuren door data mining van lichaamschemische eigenschappen [Cortez et al., 2009].

Voordat u begint

  • Uw werkruimte moet zijn ingeschakeld voor Unity Catalog.
  • U moet gemachtigd zijn om een cluster of toegang tot een cluster te maken.
  • U moet de bevoegdheid USE_CATALOG voor een catalogus hebben.
  • In die catalogus moet u de volgende bevoegdheden voor een schema hebben: USE_SCHEMA, CREATE_TABLE en CREATE_MODEL.

Tip

Alle code in dit artikel is beschikbaar in een notebook die u rechtstreeks in uw werkruimte kunt importeren. Zie Voorbeeldnotebook: Een classificatiemodel bouwen.

Stap 1: Een Databricks-notebook maken

Als u een notitieblok in uw werkruimte wilt maken, klikt u op Nieuw pictogramNieuw in de zijbalk en vervolgens op Notitieblok. Er wordt een leeg notitieblok geopend in de werkruimte.

Zie Notitieblokken beheren voor meer informatie over het maken en beheren van notitieblokken.

Stap 2: Verbinding maken met rekenresources

Als u verkennende gegevensanalyse en data engineering wilt uitvoeren, moet u toegang hebben tot berekeningen.

Zie Compute voor instructies over het maken van verbinding met bestaande rekenresources. Zie de referentie voor compute-configuratie voor instructies over het configureren van een nieuwe rekenresource.

Voor de stappen in dit artikel is Databricks Runtime voor Machine Learning vereist. Zie Databricks Runtime voor Machine Learning voor meer informatie en instructies voor het selecteren van een ML-versie van Databricks Runtime.

Stap 3: modelregister, catalogus en schema instellen

Er zijn twee belangrijke stappen vereist voordat u aan de slag gaat. Eerst moet u de MLflow-client configureren voor het gebruik van Unity Catalog als modelregister. Voer de volgende code in een nieuwe cel in uw notebook in.

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

U moet ook de catalogus en het schema instellen waarin het model wordt geregistreerd. U moet beschikken over USE CATALOG bevoegdheden voor de catalogus en USE_SCHEMA, CREATE_TABLE en CREATE_MODEL bevoegdheden voor het schema.

Voor meer informatie over het gebruik van Unity Catalog, zie Wat is Unity Catalog?.

Voer de volgende code in een nieuwe cel in uw notebook in.

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

Stap 4: Gegevens laden en Unity Catalog-tabellen maken

In dit voorbeeld worden twee CSV-bestanden gebruikt die zijn ingebouwd in Azure Databricks. Zie Gegevens opnemen in een Databricks Lakehouse voor meer informatie over het opnemen van uw eigen gegevens.

Voer de volgende code in een nieuwe cel in uw notebook in.

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

Stap 5. De gegevens vooraf verwerken en splitsen

In deze stap laadt u de gegevens uit de Unity Catalog-tabellen die u in stap 4 hebt gemaakt in Pandas DataFrames en verwerkt u de gegevens vooraf. De code in deze sectie doet het volgende:

  1. Laadt de gegevens als Pandas DataFrames.
  2. Voegt een Booleaanse kolom toe aan elk DataFrame om rode en witte wijnen te onderscheiden en combineert vervolgens de DataFrames in een nieuw DataFrame, data_df.
  3. De gegevensset bevat een quality kolom waarmee wijnen van 1 tot en met 10 worden gesorteerd, waarbij 10 de hoogste kwaliteit aangeeft. De code transformeert deze kolom in twee classificatiewaarden: 'Waar' om een wijn van hoge kwaliteit (quality>= 7) en 'Onwaar' aan te geven om een wijn aan te geven die niet van hoge kwaliteit is (quality< 7).
  4. Splitst het DataFrame op in afzonderlijke gegevenssets voor trainen en testen.

Importeer eerst de vereiste 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

Laad en verwerkt de gegevens nu:

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

Stap 6. Het classificatiemodel trainen

In deze stap traint u een classificatie voor kleurovergangsverbetering met behulp van de standaardinstellingen voor algoritmen. Vervolgens wordt het resulterende model toegepast op de testgegevensset en wordt het gebied onder de bedrijfscurve van de ontvanger weergegeven om de prestaties van het model te evalueren.

Schakel eerst automatische aanmelding van MLflow in:

mlflow.autolog()

Start nu de uitvoering van de modeltraining:

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

De celresultaten geven het berekende gebied onder de curve en een plot van de ROC-curve weer:

ROC-curve voor classificatiemodel.

Stap 7. Experimentuitvoeringen weergeven in MLflow

Met het bijhouden van MLflow-experimenten kunt u modelontwikkeling bijhouden door code en resultaten te registreren terwijl u iteratief modellen ontwikkelt.

Als u de vastgelegde resultaten van de trainingsuitvoering wilt bekijken die u zojuist hebt uitgevoerd, klikt u op de koppeling in de celuitvoer, zoals wordt weergegeven in de volgende afbeelding.

Koppeling naar experiment in celresultaten.

Op de experimentpagina kunt u uitvoeringen vergelijken en details voor specifieke uitvoeringen bekijken. Zie het bijhouden van MLflow-experimenten.

Stap 8. Hyperparameters afstemmen

Een belangrijke stap bij het ontwikkelen van een ML-model is het optimaliseren van de nauwkeurigheid van het model door de parameters af te stemmen die het algoritme bepalen, hyperparameters genoemd.

Databricks Runtime ML bevat Hyperopt, een Python-bibliotheek voor het afstemmen van hyperparameters. U kunt Hyperopt gebruiken om hyperparameter-sweeps uit te voeren en meerdere modellen parallel te trainen, waardoor de tijd die nodig is om de modelprestaties te optimaliseren, verkort. MLflow-tracering is geïntegreerd met Hyperopt om automatisch modellen en parameters te registreren. Zie Hyperparameter-afstemming voor meer informatie over het gebruik van Hyperopt in Databricks.

De volgende code toont een voorbeeld van het gebruik van 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)

Stap 9. Zoek het beste model en registreer het bij Unity Catalog

De volgende code identificeert de uitvoering die de beste resultaten heeft opgeleverd, zoals gemeten door het gebied onder de ROC-curve:

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

Met behulp van de run_id die u hebt geïdentificeerd voor het beste model, registreert de volgende code dat model bij 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")

Voorbeeldnotebook: een classificatiemodel bouwen

Gebruik het volgende notebook om de stappen in dit artikel uit te voeren. Zie Een notebook importeren voor instructies over het importeren van een notebook in een Azure Databricks-werkruimte.

Uw eerste machine learning-model bouwen met Databricks

Notitieblok ophalen

Meer informatie

Databricks biedt één platform dat elke stap van ML-ontwikkeling en -implementatie dient, van onbewerkte gegevens tot deductietabellen waarmee elke aanvraag en reactie voor een geleverd model worden opgeslagen. Gegevenswetenschappers, data engineers, ML-technici en DevOps kunnen hun werk doen met behulp van dezelfde set hulpprogramma's en één bron van waarheid voor de gegevens.

Zie het volgende voor meer informatie: