Začínáme: Vytvoření prvního modelu strojového učení v Databricks

Otevřít verzi poznámkového bloku této stránky

Tento ukázkový poznámkový blok ukazuje, jak trénovat model klasifikace strojového učení v Databricks. Databricks Runtime pro Machine Learning obsahuje mnoho předinstalovaných knihoven, včetně knihovny scikit-learn pro trénování a předzpracování algoritmů, MLflow pro sledování procesu vývoje modelu a optuna pro škálování ladění hyperparametrů.

V tomto poznámkovém bloku vytvoříte 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 kurz zahrnuje:

• Část 1: Trénování klasifikačního modelu pomocí sledování MLflow
• Část 2: Ladění hyperparametrů za účelem zlepšení výkonu modelu
• Část 3: Uložení výsledků a modelů do katalogu Unity
• Část 4: Nasazení modelu

Další podrobnosti o produkčním prostředí strojového učení v Databricks, včetně správy životního cyklu modelu a odvozování modelů, najdete v koncovém příkladu strojového učení.

Datová sada je dostupná z úložiště UCI Machine Learning a je prezentována v Modeling předvoleb vína dolováním dat z physicochemických vlastností [Cortez et al., 2009].

Požadavky

• Cluster běžící na Databricks Runtime 17.3 LTS ML nebo novějším Pokud používáte Databricks Runtime 16.4 LTS ML nebo níže, přečtěte si kurz: Sestavení prvního modelu strojového učení v Databricks (Hyperopt).

Setup

V této části provedete následující akce:

• Nakonfigurujte klienta MLflow tak, aby jako registr modelů používal katalog Unity.
• Nastavte katalog a schéma, kde se model zaregistruje.
• Přečtěte si data a uložte je do tabulek v katalogu Unity.
• Předzpracuje data.

Konfigurace klienta MLflow

Ve výchozím nastavení klient MLflow Python vytváří modely v registru modelů pracovního prostoru Databricks. Pokud chcete uložit modely v katalogu Unity, nakonfigurujte klienta MLflow, jak je znázorněno v následující buňce.

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

Následující buňka nastaví katalog a schéma, kde se model zaregistruje. Musíte mít USE CATALOG oprávnění k katalogu a USE_SCHEMA, CREATE_TABLE a CREATE_MODEL oprávnění ke schématu. V případě potřeby změňte názvy katalogu a schématu v následující buňce.

Další informace najdete v dokumentaci k katalogu Unity.

# Specify the catalog and schema to use. You must have USE_CATALOG privilege on the catalog and USE_SCHEMA, CREATE_TABLE, and CREATE_MODEL privileges on the schema.
# Change the catalog and schema here if necessary.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"

Čtení dat a jejich uložení do tabulek v katalogu Unity

Datová sada je k dispozici v databricks-datasets. V následující buňce načtete data ze .csv souborů do datových rámců Sparku. Datové rámce pak zapíšete do tabulek v katalogu Unity. Tím se data zachová a umožní vám ří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")

Předběžné zpracování dat

# Import required libraries
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

import optuna
from mlflow.optuna.storage import MlflowStorage
from mlflow.pyspark.optuna.study import MlflowSparkStudy

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

Část 1. Trénování klasifikačního modelu

# Enable MLflow autologging for this notebook
mlflow.autolog()

Dále vytrénujte klasifikátor v kontextu spuštění MLflow, který automaticky protokoluje trénovaný model a řadu přidružených metrik a parametrů.

Protokolování můžete doplnit dalšími metrikami, jako je skóre AUC modelu u testovací datové sady.

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

Prohlížení běhů MLflow

Pokud chcete zobrazit zaprotokolované trénování, klikněte na pravém horním rohu poznámkového bloku a zobrazte boční panel experimentu. V případě potřeby klikněte na ikonu obnovení a načtěte a sledujte nejnovější běhy.

Pokud chcete zobrazit podrobnější stránku experimentu MLflow, klikněte na ikonu stránky experimentu. Tato stránka umožňuje porovnat běhy a zobrazit podrobnosti o konkrétních bězích. Viz Sledování vývoje modelů pomocí MLflow.

Načtení modelů

K výsledkům konkrétního spuštění se dostanete také pomocí rozhraní API MLflow. Kód v následující buňce ukazuje, jak načíst model vytrénovaný v běhu MLflow a použít ho pro předpovědi. Fragmenty kódu pro načítání konkrétních modelů najdete také na stránce spuštění MLflow.

# After a model has been logged, you can load it in different notebooks or jobs
# mlflow.pyfunc.load_model makes model prediction available under a common API
model_loaded = mlflow.pyfunc.load_model(
  'runs:/{run_id}/model'.format(
    run_id=run.info.run_id
  )
)

predictions_loaded = model_loaded.predict(X_test)
predictions_original = model.predict(X_test)

# The loaded model should match the original
assert(np.array_equal(predictions_loaded, predictions_original))

Část 2. Ladění hyperparametrů

V tomto okamžiku jste natrénovali jednoduchý model a použili jste sledovací službu MLflow k uspořádání práce. Dále můžete provádět sofistikovanější ladění pomocí Optuna.

Paralelní trénování s využitím Optuna

Optuna je opensourcová knihovna Python pro ladění hyperparametrů, která se dá horizontálně škálovat napříč několika výpočetními prostředky. Další informace o používání optuna v Databricks najdete v tématu Ladění hyperparametrů pomocí Optuna.

def objective(trial):
  # Enable autologging on each worker
  mlflow.autolog()
  with mlflow.start_run(nested=True):
    params = {
      'n_estimators': trial.suggest_int('n_estimators', 20, 1000),
      'learning_rate': trial.suggest_float('learning_rate', 0.05, 1.0, log=True),
      'max_depth': trial.suggest_int('max_depth', 2, 5),
    }
    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)

    # Negate the AUC because Optuna minimizes the objective by default
    return -roc_auc


with mlflow.start_run(run_name='gb_optuna') as run:
  # Use the MLflow Tracking Server as the Optuna storage backend
  experiment_id = mlflow.active_run().info.experiment_id
  mlflow_storage = MlflowStorage(experiment_id=experiment_id)

  # MlflowSparkStudy distributes the tuning using Spark workers
  mlflow_study = MlflowSparkStudy(
    study_name="gb-optuna-tuning",
    storage=mlflow_storage,
  )

  mlflow_study.optimize(objective, n_trials=32, n_jobs=4)

Hledání probíhá za účelem vyhledání nejlepšího modelu

Vzhledem k tomu, že MLflow sleduje všechna spuštění, můžete pomocí rozhraní API pro vyhledávání MLflow načíst metriky a parametry nejlepšího běhu a najít ladicí běh s nejvyšším testovacím AUC.

Tento vyladěný model by měl fungovat lépe než jednodušší modely natrénované v části 1.

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

best_model_pyfunc = mlflow.pyfunc.load_model(
  'runs:/{run_id}/model'.format(
    run_id=best_run.run_id
  )
)

# Make a dataset with all predictions
best_model_predictions = X_test
best_model_predictions["prediction"] = best_model_pyfunc.predict(X_test)

Část 3. Uložení výsledků a modelů do katalogu Unity

predictions_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions"
spark.sql(f"DROP TABLE IF EXISTS {predictions_table}")

results = spark.createDataFrame(best_model_predictions)

# Write results back to Unity Catalog from Python
results.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions")

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

Část 4. Nasazení modelu

Po uložení modelu do katalogu Unity ho můžete nasadit pomocí uživatelského rozhraní obsluhy. Následující pokyny obsahují stručný popis. Další informace najdete v tématu Vytvoření vlastního modelu obsluhující koncové body.

1. Klikněte na Serving na bočním panelu pro zobrazení rozhraní Serving UI.

1. Klikněte na Vytvořit obslužný koncový bod.

2. Do pole Název zadejte název vašeho koncového bodu.

3. V části Obsluhované entity

   1. Klikněte do pole Entita a otevřete formulář Vybrat obsluhovanou entitu.
   2. Vyberte Moje modely – Katalog Unity. Formulář se dynamicky aktualizuje na základě vašeho výběru.
   3. Vyberte wine_quality_model a verzi modelu, kterou chcete použít.
   4. Jako procento provozu, které chcete směrovat na obsluhovaný model, vyberte 100.
   5. Jako typ výpočetního výkonu v tomto příkladu vyberte procesor.
   6. Pod Compute Scale-out vyberte Small jako velikost horizontálního škálování výpočetních prostředků.

4. Klikněte na Vytvořit. Stránka Obslužné koncové body se zobrazí se stavem obsluhujícího koncového bodu, který je zobrazen jako Nezpracovaný.

5. Až bude koncový bod připraven, vyberte Použít k odeslání žádosti o inferenci na koncový bod.

Příklad notebooku

Začínáme: Vytvoření prvního modelu strojového učení v Databricks

Pořiďte si notebook