Dela via

Självstudie: Skapa din första maskininlärningsmodell i Azure Databricks

Den här självstudien visar hur du skapar en klassificeringsmodell för maskininlärning med hjälp av scikit-learn biblioteket i Azure Databricks.

Målet är att skapa en klassificeringsmodell för att förutsäga om ett vin anses vara av "hög kvalitet". Datamängden består av 11 funktioner i olika viner (till exempel alkoholhalt, surhet och restsocker) och en kvalitetsrankning mellan 1 och 10.

Det här exemplet illustrerar också användningen av MLflow för att spåra modellutvecklingsprocessen och Hyperopt för att automatisera justering av hyperparametrar.

Datamängden kommer från UCI Machine Learning-lagringsplatsen, som presenteras i Modellering av vinpreferenser genom datautvinning från fysikaliska egenskaper [Cortez et al., 2009].

Innan du börjar

  • Arbetsytan måste vara aktiverad för Unity Catalog. Se Kom igång med Unity Catalog.
  • Du måste ha behörighet att skapa en beräkningsresurs eller åtkomst till en beräkningsresurs som använder Databricks Runtime för Machine Learning.
  • Du måste ha USE CATALOG behörighet i en katalog.
  • I katalogen måste du ha följande behörigheter för ett schema: USE SCHEMA, CREATE TABLEoch CREATE MODEL.

Dricks

All kod i den här artikeln är tillgänglig i en notebook-fil som du kan importera direkt till din arbetsyta. Se Exempelanteckningsbok: Skapa en klassificeringsmodell.

Steg 1: Skapa en Databricks-notebook-fil

Om du vill skapa en notebook-fil på arbetsytan klickar du på Ny ikonNytt i sidofältet och klickar sedan på Notebook. En tom anteckningsbok öppnas på arbetsytan.

Mer information om hur du skapar och hanterar notebook-filer finns i Hantera notebook-filer.

Steg 2: Ansluta till beräkningsresurser

För att kunna utföra undersökande dataanalys och datateknik måste du ha åtkomst till beräkning. Stegen i den här artikeln kräver Databricks Runtime för Machine Learning. Mer information och instruktioner för att välja en ML-version av Databricks Runtime finns i Databricks Runtime for Machine Learning.

I anteckningsboken klickar du på den nedrullningsbara menyn Anslut längst upp till höger. Om du har åtkomst till en befintlig resurs som använder Databricks Runtime för Machine Learning väljer du den resursen på menyn. Annars klickar du på Skapa ny resurs... för att konfigurera en ny beräkningsresurs.

Steg 3: Konfigurera modellregister, katalog och schema

Det finns två viktiga steg som krävs innan du kommer igång. Först måste du konfigurera MLflow-klienten så att den använder Unity Catalog som modellregister. Ange följande kod i en ny cell i anteckningsboken.

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

Du måste också ange katalogen och schemat där modellen ska registreras. Du måste ha USE CATALOG behörighet för katalogen, och USE SCHEMA, CREATE TABLEoch CREATE MODEL-behörigheter i schemat.

Mer information om hur du använder Unity Catalog finns i Vad är Unity Catalog?.

Ange följande kod i en ny cell i anteckningsboken.

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

Steg 4: Läsa in data och skapa Unity Catalog-tabeller

I det här exemplet används två CSV-filer som är tillgängliga i databricks-datasets. För att lära dig hur du kan mata in dina egna data, se Standardkopplingar i Lakeflow Connect.

Ange följande kod i en ny cell i anteckningsboken. Den här koden gör följande:

  1. Läs data från winequality-white.csv och winequality-red.csv till Spark DataFrames.
  2. Rensa data genom att ersätta blanksteg i kolumnnamn med understreck.
  3. Skriv DataFrames till tabellerna white_wine och red_wine i Unity Catalog. Om du sparar data i Unity Catalog sparas både data och du kan styra hur du delar dem med andra.
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")

Steg 5. Förbearbeta och dela upp data

I det här steget läser du in data från Unity Catalog-tabellerna som du skapade i steg 4 till Pandas DataFrames och förbearbetar data. Koden i det här avsnittet gör följande:

  1. Läser in data som Pandas DataFrames.
  2. Lägger till en boolesk kolumn i varje DataFrame för att särskilja röda och vita viner och kombinerar sedan DataFrames till en ny DataFrame data_df.
  3. Datamängden innehåller en quality kolumn som betygsätter viner från 1 till 10, med 10 som anger högsta kvalitet. Koden omvandlar den här kolumnen till två klassificeringsvärden: "True" för att indikera ett högkvalitativt vin (quality>= 7) och "False" för att indikera ett vin som inte är av hög kvalitet (quality< 7).
  4. Delar upp DataFrame i separata tränings- och testdatauppsättningar.

Importera först de bibliotek som krävs:

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

Läs nu in och förbearbeta data:

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

Steg 6. Träna klassificeringsmodellen

Det här steget tränar en toningshöjande klassificerare med standardinställningarna för algoritmer. Den tillämpar sedan den resulterande modellen på testdatauppsättningen och beräknar, loggar och visar området under mottagarens driftkurva för att utvärdera modellens prestanda.

Aktivera först automatisk MLflow-loggning:

mlflow.autolog()

Starta nu modellträningskörningen:

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

Cellresultatet visar det beräknade området under kurvan och ett diagram i ROC-kurvan:

ROC-kurva för klassificeringsmodell.

Steg 7. Visa experimentkörningar i MLflow

MLflow-experimentspårning hjälper dig att hålla reda på modellutveckling genom att logga kod och resultat när du iterativt utvecklar modeller.

Om du vill visa de loggade resultaten från träningskörningen som du precis körde klickar du på länken i cellutdata, som du ser i följande bild.

Länka till experiment i cellresultat.

På experimentsidan kan du jämföra körningar och visa information för specifika körningar. Klicka på namnet på en session för att se detaljer som parameter- och metrikvärden för den sessionen. Se Spårning av MLflow-experiment.

Du kan också visa experimentkörningar i din anteckningsbok genom att klicka på experimentikonen längst upp till höger i anteckningsboksgränssnittet.Experiment icon Då öppnas sidofältet för experimentet, som visar en sammanfattning av varje körning som är associerad med notebook-eperimentet, inklusive körningsparametrar och mått. Om det behövs klickar du på uppdateringsikonen för att hämta och övervaka de senaste körningarna.

I sidofältet för experimentkörningar i anteckningsboken visas de senaste MLflow-körningarna.

Steg 8. Använda Hyperopt för justering av hyperparametrar

Ett viktigt steg i utvecklingen av en ML-modell är att optimera modellens noggrannhet genom att justera parametrarna som styr algoritmen, så kallade hyperparametrar.

Databricks Runtime ML innehåller Hyperopt, ett Python-bibliotek för hyperparameterjustering. Du kan använda Hyperopt för att utföra hyperparametreringssvep och träna flera modeller parallellt, vilket minskar tiden som krävs för att optimera modellens prestanda. MLflow-spårning är integrerat med Hyperopt för att automatiskt logga modeller och parametrar. Mer information om hur du använder Hyperopt i Databricks finns i Hyperparameterjustering.

Följande kod visar ett exempel på hur du använder 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)

Steg 9. Hitta den bästa modellen och registrera den i Unity Catalog

Följande kod identifierar körningen som gav bästa resultat, mätt med området under ROC-kurvan:

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

Med hjälp av run_id som du har identifierat för den bästa modellen registrerar följande kod modellen till 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")

Steg 10. Distribuera modellen till produktion

När du är redo att hantera och distribuera dina modeller kan du göra det med hjälp av användargränssnittet för servering i Azure Databricks-arbetsytan.

Exempelanteckningsbok: Skapa en klassificeringsmodell

Använd följande notebook-fil för att utföra stegen i den här artikeln. Anvisningar om hur du importerar en notebook-fil till en Azure Databricks-arbetsyta finns i Importera en notebook-fil.

Skapa din första maskininlärningsmodell med Databricks

Hämta anteckningsbok

Läs mer

Databricks tillhandahåller en enda plattform som hanterar varje steg i ML-utveckling och distribution, från rådata till slutsatsdragningstabeller som sparar varje begäran och svar för en hanterad modell. Dataforskare, datatekniker, ML-tekniker och DevOps kan utföra sina jobb med samma uppsättning verktyg och en enda sanningskälla för data.

Läs mer i: