Első lépések: Az első gépi tanulási modell létrehozása a Databricksen

A lap jegyzetfüzet-verziójának megnyitása

Ez a példajegyzetfüzet bemutatja, hogyan taníthat be gépi tanulási besorolási modellt a Databricksen. A Databricks Runtime for Machine Learning számos előre telepített kódtárat tartalmaz, beleértve a scikit-learn-t a betanítási és az előfeldolgozási algoritmusokhoz, az MLflow-t a modellfejlesztési folyamat nyomon követéséhez, valamint a Hyperoptot a SparkTrials használatával a hiperparaméterek finomhangolásának skálázásához.

Ebben a jegyzetfüzetben egy besorolási modellt hoz létre annak előrejelzésére, hogy egy bor "kiváló minőségűnek" minősül-e. Az adathalmaz 11 különböző bort (például alkoholtartalmat, savasságot és reziduális cukrot) és 1–10 közötti minőségi rangsort tartalmaz.

Ez az oktatóanyag az alábbiakkal foglalkozik:

• 1. rész: Besorolási modell betanítása MLflow-nyomkövetéssel
• 2. rész: Hiperparaméter-finomhangolás a modell teljesítményének javítása érdekében
• 3. rész: Eredmények és modellek mentése a Unity Katalógusba
• 4. rész: A modell üzembe helyezése

A Databricks gépi tanulásának élesítéséről, beleértve a modell életciklus-kezelését és a modellkövetkeztetést, tekintse meg az ML Végponttól végpontig című példát.

Az adatkészlet a UCI Machine Learning Adattárból érhető el, és a Fizikokémiai tulajdonságok alapján adatbányászattal történő borpreferenciák modellezése [Cortez et al., 2009] című cikkben van bemutatva.

Requirements

• Az alábbi Databricks Runtime-verziók egyikét futtató fürt: 13.3 LTS ML, 14.3 LTS ML, 15.4 LTS ML vagy 16.4 LTS ML. A Databricks Runtime 17.3 LTS ML vagy újabb verziója esetén lásd : Oktatóanyag: Az első gépi tanulási modell létrehozása a Databricksen.

Setup

Ebben a szakaszban a következőket teheti:

• Konfigurálja az MLflow-ügyfelet a Unity Catalog modellregisztrációs adatbázisként való használatára.
• Adja meg azt a katalógust és sémát, amelyben a modell regisztrálva lesz.
• Olvassa el az adatokat, és mentse őket a Unity Catalog tábláiba.
• Az adatok előfeldolgozása.

MLflow-ügyfél konfigurálása

Alapértelmezés szerint az MLflow Python-ügyfél modelleket hoz létre a Databricks-munkaterületi modellregisztrációs adatbázisban. A modellek Unity Catalogban való mentéséhez konfigurálja az MLflow-ügyfelet az alábbi cellában látható módon.

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

Az alábbi cella azt a katalógust és sémát állítja be, ahol a modell regisztrálva lesz. Jogosultsággal kell rendelkeznie USE CATALOG a katalógusban, és USE_SCHEMA, CREATE_TABLE és CREATE_MODEL jogosultsággal kell rendelkeznie a sémán. Szükség esetén módosítsa a katalógus- és sémaneveket a következő cellában.

További információkért tekintse meg a Unity Catalog dokumentációját.

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

Adatok beolvasása és mentése táblákba a Unity Katalógusban

Az adatkészlet a következő helyen databricks-datasetsérhető el: . A következő cellában a fájlokból .csv a Spark DataFramesbe olvassa be az adatokat. Ezután a DataFrame-eket a Unity Catalog tábláiba kell írnia. Ez mind megőrzi az adatokat, és lehetővé teszi annak szabályozását, hogyan oszthatja meg azokat másokkal.

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

Adatok előfeldolgozása

# 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

from hyperopt import fmin, tpe, hp, SparkTrials, Trials, STATUS_OK
from hyperopt.pyll import scope

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

1. rész. Besorolási modell betanítása

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

Ezután betanítsa az osztályozót egy MLflow-futtatás környezetében, amely automatikusan naplózza a betanított modellt és számos kapcsolódó metrikát és paramétert.

A naplózást kiegészítheti további metrikákkal, például a modell AUC-pontszámával a tesztadatkészleten.

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

MLflow-futtatások megtekintése

A naplózott betanítási futtatás megtekintéséhez kattintson a kísérlet ikon a jegyzetfüzet jobb felső sarkában a kísérlet oldalsávjának megjelenítéséhez. Ha szükséges, kattintson a frissítés ikonra a legújabb futtatások lekéréséhez és figyeléséhez.

A részletesebb MLflow-kísérletoldal megjelenítéséhez kattintson a kísérletoldal ikonra. Ezen a lapon összehasonlíthatja a futtatásokat, és megtekintheti az egyes futtatások részleteit. Lásd: MLflow használatával történő modellfejlesztés követése.

Modellek betöltése

Egy adott futtatás eredményeit az MLflow API-val is elérheti. Az alábbi cellában található kód bemutatja, hogyan töltheti be egy adott MLflow-futtatás során betanított modellt, és hogyan használhatja előrejelzések készítésére. Az MLflow-futtatási lapon adott modellek betöltésére szolgáló kódrészleteket is találhat.

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

2. rész. Hiperparaméterek finomhangolása

Ezen a ponton betanított egy egyszerű modellt, és az MLflow nyomkövetési szolgáltatásával rendszerezte a munkáját. Ezután kifinomultabb hangolást végezhet a Hyperopt használatával.

Párhuzamos betanítás Hyperopt és SparkTrials használatával

Hyperopt Python függvénytár hiperparaméter-finomhangoláshoz. A Hyperopt Databricksben való használatáról további információt az Elosztott betanítási algoritmusok használata a Hyperopttal című témakörben talál.

A Hyperopt és a SparkTrials használatával hiperparaméter kereséseket futtathat, és egyszerre több modellt is betaníthat párhuzamosan. Ez csökkenti a modell teljesítményének optimalizálásához szükséges időt. Az MLflow-nyomkövetés integrálva van a Hyperopttal a modellek és paraméterek automatikus naplózásához.

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

A keresés a legjobb modell lekéréséhez fut

Mivel az MLflow az összes futtatást nyomon követi, az MLflow keresési futtatási API-val lekérheti a legjobb futtatás metrikáit és paramétereit, hogy megtalálja azt a hangolási futtatást, amelynél a legmagasabb a tesztelési AUC.

Ennek a finomhangolt modellnek jobban kell teljesítenie, mint az 1. részben betanított egyszerűbb modelleknek.

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

3. rész. Eredmények és modellek mentése a Unity Catalogba

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

4. rész. Modell üzembe helyezése

Miután mentette a modellt a Unity Catalogba, üzembe helyezheti a kiszolgáló felhasználói felületén. Az alábbi utasítások rövid leírást adnak. További információ: Végpontokat kiszolgáló egyéni modell létrehozása.

1. Kattintson az oldalsávon a Kiszolgálás elemre a Kiszolgálás felület megjelenítéséhez.

1. Kattintson a Kiszolgálóvégpont létrehozása elemre.

2. A Név mezőben adja meg a végpont nevét.

3. A Kiszolgált entitások szakaszban

   1. Kattintson a Entitás mezőbe a Kiszolgált entitás kiválasztása űrlap megnyitásához.
   2. Válassza a Saját modellek – Unity Katalógus lehetőséget. Az űrlap a kijelölés alapján dinamikusan frissül.
   3. Válassza ki a wine_quality_model és a modellverziót, amelyet kiszolgálására kíván.
   4. Válassza ki a 100-as értéket a kiszolgált modellhez átirányítani kívánt forgalom százalékos arányaként.
   5. Válassza ki a cpu-t a jelen példához tartozó számítási típusként.
   6. A Számítási kiterjesztés alatt válassza a Kis számítási méretet.

4. Kattintson a Létrehozás gombra. A Végpontok kiszolgálása lap úgy jelenik meg , hogy a kiszolgálóvégpont állapotanem áll készen.

5. Ha a végpont készen áll, válassza a Következtetési kérés elküldése a végpontnak lehetőséget.

Példajegyzetfüzet

Első lépések: Az első gépi tanulási modell létrehozása a Databricksen

Jegyzetfüzet szerezz