Memulai: Membangun model pembelajaran mesin pertama Anda di Databricks

Buka versi buku catatan halaman ini

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 Hyperopt dengan SparkTrials untuk menskalakan 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: Menyebarkan model

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

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

Persyaratan

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.
  • Memuat data ke dalam dan menyimpannya ke tabel di Katalog Unity.
  • Pra-proses 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 akses pada katalog, dan hak akses 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"

Baca data dan simpan ke tabel dalam Katalog Unity

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

Praolah data

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

Bagian 1. Melatih model klasifikasi

# Enable MLflow autologging for this notebook
mlflow.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))

Menampilkan aktivitas MLflow

Untuk melihat eksekusi pelatihan yang dicatat, klik ikon Eksperimen di bagian kanan atas notebook untuk menampilkan bilah sisi eksperimen. Jika perlu, klik ikon refresh untuk mengambil dan memantau eksekusi terbaru.

Eksperimen yang tercantum di bilah sisi kanan

Untuk menampilkan halaman eksperimen MLflow yang lebih rinci, klik ikon halaman eksperimen. Halaman ini memungkinkan Anda membandingkan proses dan melihat detail untuk proses 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 Hyperopt.

Pelatihan paralel dengan Hyperopt dan SparkTrials

Hyperopt adalah pustaka Python untuk penyetelan hiperparameter. Untuk informasi selengkapnya tentang menggunakan Hyperopt di Databricks, lihat Menggunakan algoritma pelatihan terdistribusi dengan Hyperopt.

Anda dapat menggunakan Hyperopt dengan SparkTrials untuk menjalankan penyapuan hyperparameter dan menggunakan beberapa model secara paralel. Ini mengurangi waktu yang diperlukan untuk mengoptimalkan performa model. Pelacakan MLflow terintegrasi dengan Hyperopt untuk mencatat model dan parameter secara otomatis.

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

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.

UI penyajian model

  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

  • Last updated on