Wprowadzenie: tworzenie pierwszego modelu uczenia maszynowego w usłudze Azure Databricks

W tym artykule pokazano, jak utworzyć model klasyfikacji uczenia maszynowego przy użyciu scikit-learn biblioteki w usłudze Azure Databricks.

Celem jest utworzenie modelu klasyfikacji w celu przewidywania, czy wino jest uznawane za "wysokiej jakości". Zestaw danych składa się z 11 cech różnych win (na przykład zawartości alkoholu, kwasowości i cukru resztowego) oraz klasyfikacji jakości od 1 do 10.

W tym przykładzie pokazano również użycie biblioteki MLflow do śledzenia procesu tworzenia modelu i funkcji Hyperopt w celu zautomatyzowania dostrajania hiperparametrów.

Zestaw danych pochodzi z repozytorium UCI Machine Learning, przedstawione w temacie Modelowanie preferencji wina przez eksplorację danych z właściwości fizycznych [Cortez et al., 2009].

Zanim rozpoczniesz

• Obszar roboczy musi być włączony dla Unity Catalog.
• Musisz mieć uprawnienia do tworzenia klastra lub dostępu do klastra.
• Musisz mieć uprawnienia USE_CATALOG w katalogu.
• W tym wykazie musisz mieć następujące uprawnienia do schematu: USE_SCHEMA, CREATE_TABLE i CREATE_MODEL.

Krok 1. Tworzenie notesu usługi Databricks

Aby utworzyć notes w obszarze roboczym, kliknij pozycję Nowy na pasku bocznym, a następnie kliknij przycisk Notes. W obszarze roboczym zostanie otwarty pusty notes.

Aby dowiedzieć się więcej na temat tworzenia notesów i zarządzania nimi, zobacz Zarządzanie notesami.

Krok 2. Łączenie z zasobami obliczeniowymi

Aby przeprowadzić eksploracyjne analizy danych i inżynierii danych, musisz mieć dostęp do obliczeń.

Aby uzyskać instrukcje dotyczące nawiązywania połączenia z istniejącymi zasobami obliczeniowymi, zobacz Obliczenia. Aby uzyskać instrukcje dotyczące konfigurowania nowego zasobu obliczeniowego, zobacz Dokumentacja konfiguracji obliczeń.

Kroki opisane w tym artykule wymagają środowiska Databricks Runtime na potrzeby uczenia maszynowego. Aby uzyskać więcej informacji i instrukcje dotyczące wybierania wersji uczenia maszynowego środowiska Databricks Runtime, zobacz Databricks Runtime for Machine Learning.

Krok 3. Konfigurowanie rejestru modeli, katalogu i schematu

Przed rozpoczęciem pracy wymagane są dwa ważne kroki. Najpierw należy skonfigurować klienta MLflow, aby używał Unity Catalog jako rejestru modeli. Wprowadź następujący kod w nowej komórce w notesie.

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

Należy również ustawić katalog i schemat, w którym model zostanie zarejestrowany. Musisz mieć uprawnienia USE CATALOG w wykazie oraz uprawnienia USE_SCHEMA, CREATE_TABLE i CREATE_MODEL w schemacie.

Aby uzyskać więcej informacji na temat korzystania z Unity Catalog, zobacz Co to jest Unity Catalog?.

Wprowadź następujący kod w nowej komórce w notesie.

# 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. Załaduj dane i utwórz tabele Unity Catalog

W tym przykładzie użyto dwóch plików CSV wbudowanych w usługę Azure Databricks. Aby dowiedzieć się, jak pozyskiwać własne dane, zobacz Pozyskiwanie danych do usługi Databricks Lakehouse.

Wprowadź następujący kod w nowej komórce w notesie.

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

Krok 5. Wstępne przetwarzanie i dzielenie danych

W tym kroku załadujesz dane z tabel Unity Catalog utworzonych w kroku 4 do ramek danych Pandas i wstępnie przetworzysz dane. Kod w tej sekcji wykonuje następujące czynności:

1. Ładuje dane jako ramki danych Biblioteki Pandas.
2. Dodaje kolumnę logiczną do każdej ramki danych, aby odróżnić czerwone i białe wina, a następnie łączy ramki danych w nową ramkę danych, data_df.
3. Zestaw danych zawiera kolumnę quality, która ocenia wina z zakresu od 1 do 10, z 10 wskazującą najwyższą jakość. Kod przekształca tę kolumnę w dwie wartości klasyfikacji: "True", aby wskazać wino wysokiej jakości (quality>= 7) i "False", aby wskazać wino, które nie jest wysokiej jakości (quality< 7).
4. Dzieli ramkę danych na oddzielne zestawy danych trenowania i testowania.

Najpierw zaimportuj wymagane biblioteki:

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

Teraz ładuj i wstępnie przetwarza dane:

# 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. Trenowanie modelu klasyfikacji

Ten krok szkoli klasyfikator gradientu zwiększającego przy użyciu domyślnych ustawień algorytmu. Następnie stosuje wynikowy model do zestawu danych testowych i oblicza, rejestruje i wyświetla obszar pod krzywą operacyjną odbiorcy, aby ocenić wydajność modelu.

Najpierw włącz automatyczne rejestrowanie MLflow:

mlflow.autolog()

Teraz uruchom przebieg trenowania 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))

Wyniki komórki pokazują obliczony obszar pod krzywą i wykres krzywej ROC:

Krok 7. Wyświetlanie przebiegów eksperymentów w środowisku MLflow

Śledzenie eksperymentów MLflow ułatwia śledzenie opracowywania modeli przez rejestrowanie kodu i wyników podczas iteracyjnego opracowywania modeli.

Aby wyświetlić zarejestrowane wyniki z właśnie wykonanego przebiegu trenowania, kliknij link w danych wyjściowych komórki, jak pokazano na poniższej ilustracji.

Strona eksperymentu umożliwia porównywanie przebiegów i wyświetlanie szczegółów dla określonych przebiegów. Zobacz Śledzenie eksperymentów MLflow.

Krok 8. Dostrajanie hiperparametrów

Ważnym krokiem tworzenia modelu uczenia maszynowego jest optymalizacja dokładności modelu przez dostrajanie parametrów sterujących algorytmem nazywanych hiperparametrami.

Środowisko Databricks Runtime ML obejmuje funkcję Hyperopt, bibliotekę języka Python do dostrajania hiperparametrów. Funkcja Hyperopt umożliwia równoległe uruchamianie zamiatania hiperparametrów i trenowanie wielu modeli, co skraca czas wymagany do zoptymalizowania wydajności modelu. Śledzenie MLflow jest zintegrowane z funkcją Hyperopt w celu automatycznego rejestrowania modeli i parametrów. Aby uzyskać więcej informacji na temat korzystania z funkcji Hyperopt w usłudze Databricks, zobacz Dostrajanie hiperparametrów.

Poniższy kod przedstawia przykład użycia funkcji 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)

Krok 9. Znajdź najlepszy model i zarejestruj go w Unity Catalog.

Poniższy kod identyfikuje przebieg, który wygenerował najlepsze wyniki, mierzony przez obszar pod krzywą 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"]))

Korzystając z run_id, który zidentyfikowałeś dla najlepszego modelu, poniższy kod rejestruje ten model w katalogu 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")

Przykładowy notes: tworzenie modelu klasyfikacji

Aby wykonać kroki opisane w tym artykule, wykonaj poniższe notesy. Aby uzyskać instrukcje dotyczące importowania notesu do obszaru roboczego usługi Azure Databricks, zobacz Importowanie notesu.

Tworzenie pierwszego modelu uczenia maszynowego przy użyciu usługi Databricks

Zdobądź notes

Dowiedz się więcej

Usługa Databricks udostępnia jedną platformę, która obsługuje każdy etap opracowywania i wdrażania uczenia maszynowego, od danych pierwotnych po tabele wnioskowania, które zapisują każde żądanie i odpowiedź dla obsługiwanego modelu. Analitycy danych, inżynierowie danych, inżynierowie uczenia maszynowego i metodyka DevOps mogą wykonywać swoje zadania przy użyciu tego samego zestawu narzędzi i pojedynczego źródła prawdy dla danych.

Aby dowiedzieć się więcej, zobacz następujące tematy:

• Samouczki dotyczące uczenia maszynowego i sztucznej inteligencji
• Omówienie uczenia maszynowego i sztucznej inteligencji w usłudze Databricks
• Omówienie trenowania modeli uczenia maszynowego i sztucznej inteligencji w usłudze Databricks
• MLflow dla agenta generatywnej sztucznej inteligencji i cyklu życia modelu uczenia maszynowego

Powiązane zasoby

• scikit-learn