Tutorial: Membangun model pembelajaran mesin pertama Anda di Azure Databricks

Tutorial ini menunjukkan kepada Anda cara membuat model klasifikasi pembelajaran mesin menggunakan scikit-learn pustaka di Azure Databricks.

Tujuannya adalah untuk 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.

Contoh ini juga menggambarkan penggunaan MLflow untuk melacak proses pengembangan model, dan Hyperopt untuk mengotomatiskan penyetelan hyperparameter.

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

Sebelum Anda mulai

Ruang kerja Anda harus diaktifkan untuk Katalog Unity. Lihat Mulai menggunakan Unity Catalog.
Anda harus memiliki izin untuk membuat sumber daya komputasi atau akses ke sumber daya komputasi yang menggunakan Databricks Runtime for Machine Learning.
Anda harus memiliki USE CATALOG hak istimewa pada katalog.
Dalam katalog tersebut, Anda harus memiliki hak istimewa berikut pada skema: USE SCHEMA, CREATE TABLE, dan CREATE MODEL.

Petunjuk / Saran

Semua kode dalam artikel ini tersedia di buku catatan yang bisa Anda impor langsung ke ruang kerja Anda. Lihat Contoh buku catatan: Membuat model klasifikasi.

Langkah 1: Membuat buku catatan Databricks

Untuk membuat buku catatan di ruang kerja Anda, klik Baru di bilah samping, lalu klik Buku Catatan. Buku catatan kosong terbuka di ruang kerja.

Untuk mempelajari selengkapnya tentang membuat dan mengelola buku catatan, lihat Mengelola buku catatan.

Langkah 2: Menyambungkan ke sumber daya komputasi

Untuk melakukan analisis data eksploratif dan rekayasa data, Anda harus memiliki akses ke komputasi. Langkah-langkah dalam artikel ini memerlukan Databricks Runtime untuk Pembelajaran Mesin. Untuk informasi dan instruksi selengkapnya tentang memilih versi ML Databricks Runtime, lihat Databricks Runtime untuk Pembelajaran Mesin.

Di buku catatan Anda, klik menu drop-down Sambungkan di kanan atas. Jika Anda memiliki akses ke sumber daya yang sudah ada yang menggunakan Databricks Runtime untuk Pembelajaran Mesin, pilih sumber daya tersebut dari menu. Jika tidak, klik Buat sumber daya baru... untuk mengonfigurasi sumber daya komputasi baru.

Langkah 3: Menyiapkan registri model, katalog, dan skema

Ada dua langkah penting yang diperlukan sebelum Anda memulai. Pertama, Anda harus mengonfigurasi klien MLflow untuk menggunakan Unity Catalog sebagai registri model. Masukkan kode berikut ke dalam sel baru di buku catatan Anda.

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

Anda juga harus mengatur katalog dan skema tempat model akan didaftarkan. Anda harus memiliki USE CATALOG hak istimewa pada katalog, dan USE SCHEMA, CREATE TABLE, dan hak istimewa MEMBUAT MODEL pada skema.

Untuk informasi selengkapnya tentang cara menggunakan Katalog Unity, lihat Apa itu Katalog Unity?.

Masukkan kode berikut ke dalam sel baru di buku catatan Anda.

# If necessary, replace "main" and "default" with a catalog and schema for which you have the required permissions.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"

Langkah 4: Muat data dan buat tabel Katalog Unity

Contoh ini menggunakan dua file CSV yang tersedia di databricks-datasets. Untuk mempelajari cara menyerap data Anda sendiri, lihat Konektor standar di Lakeflow Connect.

Masukkan kode berikut ke dalam sel baru di buku catatan Anda. Kode ini melakukan hal berikut:

Membaca data dari winequality-white.csv dan winequality-red.csv ke Spark DataFrames.
Bersihkan data dengan mengganti spasi dalam nama kolom dengan garis bawah.
Tulis DataFrame ke white_wine dan red_wine tabel di Unity Catalog. Menyimpan data ke Unity Catalog 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")

Langkah 5. Melakukan praprosces dan membagi data

Dalam langkah ini, Anda memuat data dari tabel Unity Catalog yang Anda buat di Langkah 4 ke Pandas DataFrames dan melakukan praproses data. Kode di bagian ini melakukan hal berikut:

Memuat data sebagai Pandas DataFrames.
Menambahkan kolom Boolean ke setiap DataFrame untuk membedakan anggur merah dan putih, lalu menggabungkan DataFrame ke dalam DataFrame baru, data_df.
Himpunan data mencakup kolom quality yang menilai anggur dari 1 hingga 10, dengan 10 menunjukkan kualitas tertinggi. Kode mengubah kolom ini menjadi dua nilai klasifikasi: "True" untuk menunjukkan anggur berkualitas tinggi (quality>= 7) dan "False" untuk menunjukkan anggur yang tidak berkualitas tinggi (quality< 7).
Membagi DataFrame menjadi himpunan data pelatihan dan pengujian terpisah.

Pertama, impor pustaka yang diperlukan:

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

Sekarang muat dan praprosces data:

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

Langkah 6. Melatih model klasifikasi

Langkah ini melatih pengklasifikasi peningkatan gradien menggunakan pengaturan algoritma default. Kemudian menerapkan model yang dihasilkan ke himpunan data pengujian dan menghitung, mencatat, dan menampilkan area di bawah kurva operasi penerima untuk mengevaluasi performa model.

Pertama, aktifkan autologging MLflow:

mlflow.autolog()

Sekarang mulai eksekusi pelatihan model:

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

Hasil sel memperlihatkan area terhitung di bawah kurva dan plot kurva ROC:

Kurva ROC untuk model klasifikasi.

Langkah 7. Melihat eksekusi eksperimen di MLflow

Pelacakan eksperimen MLflow membantu Anda melacak pengembangan model dengan mencatat kode dan hasil saat Anda mengembangkan model secara berulang.

Untuk melihat hasil yang dicatat dari pelatihan yang baru saja Anda jalankan, klik tautan dalam output sel, seperti yang ditunjukkan pada gambar berikut.

Tautkan ke eksperimen dalam hasil sel.

Halaman eksperimen memungkinkan Anda membandingkan eksekusi dan melihat detail untuk eksekusi tertentu. Klik nama eksekusi untuk melihat detail seperti parameter dan nilai metrik untuk eksekusi tersebut. Lihat Pelacakan eksperimen MLflow.

Anda juga bisa melihat hasil eksperimen pada buku catatan Anda dengan mengklik ikon Eksperimen ikon Eksperimen di pojok kanan atas buku catatan. Ini membuka bilah sisi eksperimen, yang menunjukkan ringkasan setiap pelaksanaan yang terkait dengan eksperimen menggunakan notebook, termasuk parameter dan metrik pelaksanaan. Jika perlu, klik ikon refresh untuk mengambil dan memantau eksekusi terbaru.

Eksperimen menjalankan bilah samping di notebook memperlihatkan eksekusi MLflow terbaru.

Langkah 8. Menggunakan Hyperopt untuk penyetelan hyperparameter

Langkah penting dalam mengembangkan model ML adalah mengoptimalkan akurasi model dengan menyetel parameter yang mengontrol algoritma, yang disebut hiperparameter.

Databricks Runtime ML mencakup Hyperopt, pustaka Python untuk penyetelan hyperparameter. Anda dapat menggunakan Hyperopt untuk menjalankan sapuan hyperparameter dan melatih beberapa model secara paralel, mengurangi waktu yang diperlukan untuk mengoptimalkan performa model. Pelacakan MLflow terintegrasi dengan Hyperopt untuk mencatat model dan parameter secara otomatis. Untuk informasi selengkapnya tentang menggunakan Hyperopt di Databricks, lihat Penyetelan hyperparameter.

Kode berikut menunjukkan contoh penggunaan 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)

Langkah 9. Temukan model terbaik dan daftarkan ke Unity Catalog

Kode berikut mengidentifikasi eksekusi yang menghasilkan hasil terbaik, seperti yang diukur oleh area di bawah kurva 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"]))

Menggunakan run_id yang Anda identifikasi untuk model terbaik, kode berikut mendaftarkan model tersebut ke 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")

Langkah 10. Memasukkan model ke lingkungan produksi

Saat Anda siap untuk melayani dan menyebarkan model, Anda dapat melakukannya menggunakan Antarmuka pengguna Penyajian di ruang kerja Azure Databricks Anda.

Contoh buku catatan: Membangun model klasifikasi

Gunakan buku catatan berikut untuk melakukan langkah-langkah dalam artikel ini. Untuk instruksi tentang mengimpor buku catatan ke ruang kerja Azure Databricks, lihat Mengimpor buku catatan.

Membangun model pembelajaran mesin pertama Anda dengan Databricks

Dapatkan buku catatan

Pelajari lebih lanjut

Databricks menyediakan satu platform yang melayani setiap langkah pengembangan dan penyebaran ML, dari data mentah hingga tabel inferensi yang menyimpan setiap permintaan dan respons untuk model yang dilayani. Ilmuwan data, insinyur data, insinyur ML, dan DevOps dapat melakukan pekerjaan mereka menggunakan serangkaian alat yang sama dan satu sumber kebenaran untuk data.

Untuk mempelajari lebih lanjut, lihat berikut ini:

scikit-learn

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-08-14