Kurz: Vytvoření prvního modelu strojového učení v Azure Databricks

V tomto kurzu se dozvíte, jak vytvořit model klasifikace strojového učení pomocí scikit-learn knihovny v Azure Databricks.

Cílem je vytvořit klasifikační model, který předpovídá, jestli se víno považuje za "vysoce kvalitní". Datová sada se skládá z 11 vlastností různých vín (například obsah alkoholu, kyselinu a zbytkový cukr) a hodnocení kvality mezi 1 až 10.

Tento příklad také ukazuje použití MLflow ke sledování procesu vývoje modelu a Hyperopt k automatizaci ladění hyperparametrů.

Datová sada pochází z úložiště strojového učení UCI, které se prezentuje v předvolbách modelování vín při těžbě dat z physicochemických vlastností [Cortez et al., 2009].

Než začnete

• Pro katalog Unity musí být povolený váš pracovní prostor. Viz Začínáme s katalogem Unity.
• Musíte mít oprávnění k vytvoření výpočetního prostředku nebo přístupu k výpočetnímu prostředku, který používá Databricks Runtime pro Machine Learning.
• Musíte mít USE CATALOG oprávnění k katalogu.
• V tomto katalogu musíte mít pro schéma následující oprávnění: USE SCHEMACREATE TABLE, a CREATE MODEL.

Návod

Veškerý kód v tomto článku je k dispozici v poznámkovém bloku, který můžete importovat přímo do pracovního prostoru. Viz ukázkový poznámkový blok: Vytvoření klasifikačního modelu.

Krok 1: Vytvoření poznámkového bloku Databricks

Chcete-li vytvořit poznámkový blok v pracovním prostoru, klepněte na tlačítko Nový na bočním panelu a potom klepněte na příkaz Poznámkový blok. V pracovním prostoru se otevře prázdný poznámkový blok.

Další informace o vytváření a správě poznámkových bloků najdete v tématu Správa poznámkových bloků.

Krok 2: Připojení k výpočetním prostředkům

Pokud chcete provádět průzkumnou analýzu dat a přípravu dat, musíte mít přístup k výpočetním prostředkům. Kroky v tomto článku vyžadují modul Databricks Runtime pro Machine Learning. Další informace a pokyny pro výběr verze ML databricks Runtime najdete v tématu Databricks Runtime pro Machine Learning.

Klikněte na rozevírací nabídku Připojit v pravém horním rohu vašeho poznámkového bloku. Pokud máte přístup k existujícímu prostředku, který používá Databricks Runtime pro Machine Learning, vyberte tento prostředek z nabídky. V opačném případě klikněte na vytvořit nový prostředek...a nakonfigurujte nový výpočetní prostředek.

Krok 3: Nastavení registru modelů, katalogu a schématu

Než začnete, musíte provést dva důležité kroky. Nejprve musíte nakonfigurovat klienta MLflow tak, aby jako registr modelů používal katalog Unity. Do nové buňky v poznámkovém bloku zadejte následující kód.

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

Musíte také nastavit katalog a schéma, kde bude model registrován. Ke katalogu musíte mít USE CATALOG oprávnění a ke schématu USE SCHEMA, CREATE TABLE a CREATE MODEL oprávnění.

Další informace o používání katalogu Unity najdete v tématu Co je Katalog Unity?.

Do nové buňky v poznámkovém bloku zadejte následující kód.

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

Krok 4: Načtení dat a vytvoření tabulek katalogu Unity

Tento příklad používá dva soubory CSV, které jsou k dispozici v databricks-datasets. Informace o příjmu vlastních dat najdete v tématu Standardní konektory ve službě Lakeflow Connect.

Do nové buňky v poznámkovém bloku zadejte následující kód. Tento kód provede následující:

1. Načíst data z winequality-white.csv a winequality-red.csv do datových rámců Spark.
2. Vyčistěte data nahrazením mezer v názvech sloupců podtržítky.
3. Zapište datové rámce do tabulek white_wine a red_wine v katalogu Unity. Uložením dat do katalogu Unity se data uchovávají a umožňuje řídit, jak je sdílet s ostatními.

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

Krok 5. Předběžné zpracování a rozdělení dat

V tomto kroku načtete data z tabulek katalogu Unity, které jste vytvořili v kroku 4, do datových rámců Pandas a předzpracujete data. Kód v této části provede následující:

1. Načte data jako datové rámce Pandas.
2. Přidá do každého datového rámce logický sloupec pro rozlišení červených a bílých vín a potom zkombinuje datové rámce do nového datového rámce data_df.
3. Datová sada obsahuje quality sloupec, který hodnotí vína od 1 do 10, přičemž 10 označuje nejvyšší kvalitu. Kód transformuje tento sloupec na dvě klasifikační hodnoty: "True", aby označil vysoce kvalitní víno (quality>= 7) a "False" označující víno, které není vysoce kvalitní (quality< 7).
4. Rozdělí datový rámec do samostatných trénování a testovacích datových sad.

Nejprve naimportujte požadované knihovny:

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

Teď načtěte a předzpracuje 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
)

Krok 6. Trénování klasifikačního modelu

Tento krok trénuje gradientní zvýšení klasifikátoru pomocí výchozího nastavení algoritmu. Potom použije výsledný model na testovací datovou sadu a vypočítá, zaprotokoluje a zobrazí plochu pod křivkou ROC k vyhodnocení výkonu modelu.

Nejprve povolte automatické protokolování MLflow:

mlflow.autolog()

Teď spusťte trénování modelu:

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

Výsledky buňky zobrazují počítanou oblast pod křivkou a graf křivky ROC:

Krok 7. Zobrazení spuštění experimentu v MLflow

Sledování experimentů MLflow pomáhá sledovat vývoj modelů protokolováním kódu a výsledků při iterativním vývoji modelů.

Pokud chcete zobrazit zaprotokolované výsledky z právě spuštěného trénovacího spuštění, klikněte na odkaz ve výstupu buňky, jak je znázorněno na následujícím obrázku.

Stránka experimentu umožňuje porovnat spuštění a zobrazit podrobnosti o konkrétních spuštěních. Kliknutím na název spuštění zobrazíte podrobnosti, jako jsou hodnoty parametrů a metrik pro dané spuštění. Viz sledování experimentů MLflow.

Experimenty v poznámkovém bloku můžete zobrazit také kliknutím na ikonu Experiment v pravém horním rohu poznámkového bloku. Otevře se boční panel experimentu, který zobrazuje souhrn jednotlivých spuštění spojených s experimentem poznámkového bloku, včetně parametrů spuštění a metrik. V případě potřeby klikněte na ikonu obnovení a načtěte a sledujte nejnovější běhy.

Krok 8. Použití Hyperoptu pro ladění hyperparametrů

Důležitým krokem při vývoji modelu ML je optimalizace přesnosti modelu vyladěním parametrů, které řídí algoritmus označovaný jako hyperparametry.

Databricks Runtime ML zahrnuje Hyperopt, knihovnu Pythonu pro ladění hyperparametrů. Hyperopt můžete použít k vyhledávání hyperparametrů a ke paralelnímu trénování více modelů, což zkracuje dobu potřebnou pro optimalizaci výkonu modelu. Sledování MLflow je integrované s Hyperoptem pro automatické protokolování modelů a parametrů. Další informace o použití Hyperoptu v Databricks najdete v tématu Ladění hyperparametrů.

Následující kód ukazuje příklad použití Hyperoptu.

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

Krok 9. Najděte nejlepší model a zaregistrujte ho do katalogu Unity.

Následující kód identifikuje spuštění, které vytvořilo nejlepší výsledky měřené oblastí pod křivkou ROC:

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

Pomocí run_id, které jste identifikovali pro nejlepší model, zaregistruje následující kód tento model do katalogu Unity.

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

Krok 10. Nasazení modelu do produkčního prostředí

Až budete připraveni obsluhovat a nasazovat modely, můžete to udělat pomocí uživatelského rozhraní obsluhy v pracovním prostoru Azure Databricks.

• Viz Vytvoření vlastních modelů obsluhujících koncové body.
• Viz Dotaz obsluhující koncové body pro vlastní modely.

Ukázkový poznámkový blok: Vytvoření klasifikačního modelu

Pomocí následujícího poznámkového bloku proveďte kroky v tomto článku. Pokyny k importu poznámkového bloku do pracovního prostoru Azure Databricks najdete v tématu Import poznámkového bloku.

Vytvoření prvního modelu strojového učení pomocí Databricks

Pořiďte si notebook

Další informace

Databricks poskytuje jednu platformu, která slouží ke každému kroku vývoje a nasazení ML, od nezpracovaných dat až po tabulky odvozování, které ukládají všechny požadavky a odpovědi pro obsluhovaný model. Datoví vědci, datoví inženýři, technici ML a DevOps můžou své úlohy provádět pomocí stejné sady nástrojů a jediného zdroje pravdy pro data.

Další informace najdete v těchto článcích:

• Kurzy strojového učení a umělé inteligence
• Přehled strojového učení a umělé inteligence v Databricks
• Přehled trénování modelů strojového učení a AI v Databricks
• MLflow pro životní cyklus modelu ML

Související prostředky

• scikit-learn