Memulai: Membangun model pembelajaran mesin pertama Anda di Databricks

Contoh notebook ini menggambarkan cara melatih model klasifikasi pembelajaran mesin di Databricks. Databricks Runtime for Pembelajaran Mesin dilengkapi dengan banyak pustaka yang telah diinstal sebelumnya, termasuk scikit-learn untuk algoritma pelatihan dan pra-pemrosesan, MLflow untuk melacak proses pengembangan model, dan Optuna untuk meningkatkan penyetelan hiperparameter.

Dalam notebook ini, Anda membuat model klasifikasi untuk memprediksi apakah anggur dianggap "berkualitas tinggi". Himpunan data terdiri dari 11 fitur anggur yang berbeda (misalnya, kandungan alkohol, keasaman, dan gula sisa) dan peringkat kualitas antara 1 hingga 10.

Tutorial ini mencakup:

• Bagian 1: Melatih model klasifikasi dengan pelacakan MLflow
• Bagian 2: Penyetelan hyperparameter untuk meningkatkan performa model
• Bagian 3: Menyimpan hasil dan model ke Unity Catalog
• Bagian 4: Mengimplementasikan model

Untuk detail selengkapnya tentang menerapkan pembelajaran mesin ke dalam produksi pada Databricks termasuk manajemen siklus hidup model dan inferensi model, lihat Contoh Ujung ke Ujung ML.

Himpunan data tersedia dari UCI Pembelajaran Mesin Repository dan disajikan dalam pemodelan preferensi anggur melalui penambangan data dari properti fisikokimia [Cortez et al., 2009].

Persyaratan

• Kluster yang menjalankan Databricks Runtime 17.3 LTS ML atau lebih tinggi. Jika Anda menjalankan Databricks Runtime 16.4 LTS ML atau di bawah ini, lihat Tutorial: Membangun model pembelajaran mesin pertama Anda di Databricks (Hyperopt).

Siapkan

Di bagian ini, Anda melakukan hal berikut:

• Konfigurasikan klien MLflow untuk menggunakan Unity Catalog sebagai registri model.
• Atur katalog dan skema tempat model akan didaftarkan.
• Impor data dan simpan ke tabel di Katalog Unity.
• Pra-pemrosesan data

Mengonfigurasi klien MLflow

Secara default, klien Python MLflow membuat model di registri model ruang kerja Databricks. Untuk menyimpan model di Unity Catalog, konfigurasikan klien MLflow seperti yang diperlihatkan dalam sel berikut.

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

Sel berikut mengatur katalog dan skema tempat model akan didaftarkan. Anda harus memiliki USE CATALOG hak istimewa pada katalog, dan hak istimewa USE_SCHEMA, CREATE_TABLE, dan CREATE_MODEL pada skema. Ubah nama katalog dan skema di sel berikut jika perlu.

Untuk informasi selengkapnya, lihat dokumentasi Katalog 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"

Membaca data dan menyimpannya ke tabel di Unity Katalog

Himpunan data tersedia di databricks-datasets. Di sel berikut, Anda membaca data dari .csv file ke Spark DataFrames. Anda kemudian menulis DataFrames ke tabel di Unity Catalog. Ini keduanya mempertahankan data dan memungkinkan Anda mengontrol cara membagikannya dengan orang lain.

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

Data pra-pemrosesan

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

Bagian 1. Melatih model klasifikasi

# Enable MLflow autologging for scikit-learn
mlflow.sklearn.autolog()

Selanjutnya, latih pengklasifikasi dalam konteks eksekusi MLflow, yang secara otomatis mencatat model terlatih dan banyak metrik dan parameter terkait.

Anda dapat melengkapi pengelogan dengan metrik tambahan seperti skor AUC model pada himpunan data pengujian.

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

Lihat jalankan MLflow

Untuk melihat jalannya pelatihan yang dicatat, klik ikon Eksperimen Experiment icon di kanan atas buku catatan untuk menampilkan bilah sisi eksperimen. Jika perlu, klik ikon refresh untuk mengambil dan memantau eksekusi terbaru.

Untuk menampilkan halaman eksperimen MLflow yang lebih rinci, klik ikon halaman eksperimen. Halaman ini memungkinkan Anda membandingkan jalur dan melihat detail dari jalur tertentu. Lihat Melacak pengembangan model menggunakan MLflow.

Memuat model

Anda juga dapat mengakses hasil untuk eksekusi tertentu menggunakan API MLflow. Kode dalam sel berikut menggambarkan cara memuat model yang dilatih dalam eksekusi MLflow tertentu dan menggunakannya untuk membuat prediksi. Anda juga dapat menemukan cuplikan kode untuk memuat model tertentu di halaman eksekusi 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))

Bagian 2. Penyesuaian hiperparameter

Pada titik ini, Anda telah melatih model sederhana dan menggunakan layanan pelacakan MLflow untuk mengatur pekerjaan Anda. Selanjutnya, Anda dapat melakukan penyetelan yang lebih canggih menggunakan Optuna.

Pelatihan paralel menggunakan Optuna

Optuna adalah pustaka Python sumber terbuka untuk penyetelan hyperparameter yang dapat diskalakan secara horizontal di beberapa sumber daya komputasi. Untuk informasi selengkapnya tentang menggunakan Optuna di Databricks, lihat Penyetelan hyperparameter dengan Optuna.

def objective(trial):
  # Enable autologging on each worker
  mlflow.sklearn.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)

Pencarian dijalankan untuk pengambilan model terbaik

Karena semua eksekusi dilacak oleh MLflow, Anda dapat mengambil metrik dan parameter untuk eksekusi terbaik menggunakan API pencarian run MLflow untuk menemukan eksekusi penyetelan dengan AUC pengujian tertinggi.

Model yang disetel ini harus berkinerja lebih baik daripada model yang lebih sederhana yang dilatih di Bagian 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)

Bagian 3. Menyimpan hasil dan model ke Unity Catalog

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

Bagian 4. Mengimplementasikan model

Setelah menyimpan model ke Unity Catalog, Anda dapat menyebarkannya menggunakan Antarmuka Pengguna penyajian. Instruksi berikut memberikan deskripsi singkat. Untuk informasi selengkapnya, lihat Membuat model kustom yang melayani titik akhir.

1. Klik Serving di bar samping untuk menampilkan antarmuka pengguna Serving.

1. Klik Buat titik akhir penyajian.

2. Di bidang Nama berikan nama untuk titik akhir Anda.

3. Di bagian Entitas yang dilayani

   1. Klik bidang Entitas untuk membuka formulir Pilih entitas yang dilayani .
   2. Pilih Model saya- Unity Catalog. Formulir diperbarui secara dinamis berdasarkan pilihan Anda.
   3. Pilih wine_quality_model dan versi model yang ingin Anda layani.
   4. Pilih 100 sebagai persentase lalu lintas yang ingin Anda rutekan ke model yang dilayani.
   5. Pilih CPU sebagai jenis komputasi untuk contoh ini.
   6. Di bawah Peluasan Skala Komputasi, pilih Kecil sebagai ukuran peluasan skala komputasi.

4. Klik Buat. Halaman Titik akhir penayangan muncul dengan status Titik akhir penayangan ditampilkan sebagai Belum Siap.

5. Saat titik akhir Anda Siap, pilih Gunakan untuk mengirimkan permintaan inferensi ke titik akhir.

Contoh buku catatan

Memulai: Membangun model pembelajaran mesin pertama Anda di Databricks

Dapatkan buku catatan