Penyetelan hyperparameter (pratinjau)

Artikel
04/03/2024

Penyetelan hyperparameter adalah proses menemukan nilai optimal untuk parameter yang tidak dipelajari oleh model pembelajaran mesin selama pelatihan, melainkan diatur oleh pengguna sebelum proses pelatihan dimulai. Parameter ini biasanya disebut sebagai hiperparameter, dan contohnya termasuk tingkat pembelajaran, jumlah lapisan tersembunyi dalam jaringan saraf, kekuatan regularisasi, dan ukuran batch.

Performa model pembelajaran mesin dapat sangat sensitif terhadap pilihan hiperparameter, dan serangkaian hiperparameter yang optimal dapat sangat bervariasi tergantung pada masalah dan himpunan data tertentu. Oleh karena itu, penyetelan hyperparameter adalah langkah penting dalam alur pembelajaran mesin, karena dapat berdampak signifikan pada akurasi model dan performa generalisasi.

Dalam Fabric, ilmuwan data dapat memanfaatkan FLAML, pustaka Python ringan untuk otomatisasi operasi pembelajaran mesin dan AI yang efisien, untuk persyaratan penyetelan hiperparameter mereka. Dalam notebook Fabric, pengguna dapat memanggil flaml.tune penyetelan hyperparameter ekonomis.

Penting

Fitur ini dalam pratinjau.

Menyetel alur kerja

Ada tiga langkah penting yang harus digunakan flaml.tune untuk menyelesaikan tugas penyetelan dasar:

Tentukan tujuan penyetelan sehubungan dengan hyperparameter.
Tentukan ruang pencarian hiperparameter.
Tentukan batasan penyetelan, termasuk batasan pada anggaran sumber daya untuk melakukan penyetelan, batasan pada konfigurasi, atau/dan batasan pada metrik tertentu (atau beberapa).

Tujuan penyetelan

Langkah pertama adalah menentukan tujuan penyetelan Anda. Untuk melakukan ini, Anda harus terlebih dahulu menentukan prosedur evaluasi sehubungan dengan hiperparameter dalam fungsi evaluation_functionyang ditentukan pengguna . Fungsi ini memerlukan konfigurasi hyperparameter sebagai input. Ini hanya dapat mengembalikan nilai metrik dalam skalar atau mengembalikan kamus nama metrik dan pasangan nilai metrik.

Dalam contoh di bawah ini, kita dapat menentukan fungsi evaluasi sehubungan dengan 2 hiperparameter bernama x dan y.

import time

def evaluate_config(config: dict):
    """evaluate a hyperparameter configuration"""
    score = (config["x"] - 85000) ** 2 - config["x"] / config["y"]


    faked_evaluation_cost = config["x"] / 100000
    time.sleep(faked_evaluation_cost)
    # we can return a single float as a score on the input config:
    # return score
    # or, we can return a dictionary that maps metric name to metric value:
    return {"score": score, "evaluation_cost": faked_evaluation_cost, "constraint_metric": config["x"] * config["y"]}

Ruang pencarian

Selanjutnya, kita akan menentukan ruang pencarian hiperparameter. Di ruang pencarian, Anda perlu menentukan nilai yang valid untuk hyperparameter Anda dan bagaimana nilai-nilai ini diambil sampelnya (misalnya, dari distribusi seragam atau distribusi seragam log). Dalam contoh di bawah ini, kita dapat menyediakan ruang pencarian untuk hyperparameter x dan y. Nilai yang valid untuk keduanya adalah bilangan bulat mulai dari [1, 100.000]. Hiperparameter ini diambil sampelnya secara seragam dalam rentang yang ditentukan.

from flaml import tune

# construct a search space for the hyperparameters x and y.
config_search_space = {
    "x": tune.lograndint(lower=1, upper=100000),
    "y": tune.randint(lower=1, upper=100000)
}

# provide the search space to tune.run
tune.run(..., config=config_search_space, ...)

Dengan FLAML, pengguna dapat menyesuaikan domain untuk hyperparameter tertentu. Ini memungkinkan pengguna untuk menentukan jenis dan rentang yang valid untuk sampel parameter dari. FLAML mendukung jenis hiperparameter berikut: float, bilangan bulat, dan kategoris. Anda dapat melihat contoh ini di bawah ini untuk domain yang umum digunakan:

config = {
    # Sample a float uniformly between -5.0 and -1.0
    "uniform": tune.uniform(-5, -1),

    # Sample a float uniformly between 3.2 and 5.4,
    # rounding to increments of 0.2
    "quniform": tune.quniform(3.2, 5.4, 0.2),

    # Sample a float uniformly between 0.0001 and 0.01, while
    # sampling in log space
    "loguniform": tune.loguniform(1e-4, 1e-2),

    # Sample a float uniformly between 0.0001 and 0.1, while
    # sampling in log space and rounding to increments of 0.00005
    "qloguniform": tune.qloguniform(1e-4, 1e-1, 5e-5),

    # Sample a random float from a normal distribution with
    # mean=10 and sd=2
    "randn": tune.randn(10, 2),

    # Sample a random float from a normal distribution with
    # mean=10 and sd=2, rounding to increments of 0.2
    "qrandn": tune.qrandn(10, 2, 0.2),

    # Sample a integer uniformly between -9 (inclusive) and 15 (exclusive)
    "randint": tune.randint(-9, 15),

    # Sample a random uniformly between -21 (inclusive) and 12 (inclusive (!))
    # rounding to increments of 3 (includes 12)
    "qrandint": tune.qrandint(-21, 12, 3),

    # Sample a integer uniformly between 1 (inclusive) and 10 (exclusive),
    # while sampling in log space
    "lograndint": tune.lograndint(1, 10),

    # Sample a integer uniformly between 2 (inclusive) and 10 (inclusive (!)),
    # while sampling in log space and rounding to increments of 2
    "qlograndint": tune.qlograndint(2, 10, 2),

    # Sample an option uniformly from the specified choices
    "choice": tune.choice(["a", "b", "c"]),
}

Untuk mempelajari selengkapnya tentang bagaimana Anda dapat menyesuaikan domain dalam ruang pencarian Anda, kunjungi dokumentasi FLAML tentang menyesuaikan ruang pencarian.

Menyetel batasan

Langkah terakhir adalah menentukan batasan tugas penyetelan. Salah satu properti flaml.tune penting adalah dapat menyelesaikan proses penyetelan dalam batasan sumber daya yang diperlukan. Untuk melakukan ini, pengguna dapat memberikan batasan sumber daya dalam hal waktu jam dinding (dalam detik) menggunakan time_budget_s argumen atau dalam hal jumlah percobaan menggunakan num_samples argumen.

# Set a resource constraint of 60 seconds wall-clock time for the tuning.
flaml.tune.run(..., time_budget_s=60, ...)

# Set a resource constraint of 100 trials for the tuning.
flaml.tune.run(..., num_samples=100, ...)

# Use at most 60 seconds and at most 100 trials for the tuning.
flaml.tune.run(..., time_budget_s=60, num_samples=100, ...)

Untuk mempelajari selengkapnya tentang batasan konfigurasi tambahan, Anda dapat mengunjungi dokumentasi FLAML untuk opsi penyetelan tingkat lanjut.

Menempatkannya bersama-sama

Setelah menentukan kriteria penyetelan, kita dapat menjalankan uji coba penyetelan. Untuk melacak hasil uji coba kami, kami dapat memanfaatkan autologging MLFlow untuk menangkap metrik dan parameter untuk masing-masing eksekusi ini. Kode ini akan menangkap seluruh uji coba penyetelan hiperparameter, menyoroti masing-masing kombinasi hiperparameter yang dieksplorasi oleh FLAML.

import mlflow
mlflow.set_experiment("flaml_tune_experiment")
mlflow.autolog(exclusive=False)

with mlflow.start_run(nested=True, run_name="Child Run: "):
    analysis = tune.run(
        evaluate_config,  # the function to evaluate a config
        config=config_search_space,  # the search space defined
        metric="score",
        mode="min",  # the optimization mode, "min" or "max"
        num_samples=-1,  # the maximal number of configs to try, -1 means infinite
        time_budget_s=10,  # the time budget in seconds
    )

Catatan

Ketika autologging MLflow diaktifkan, metrik, parameter, dan model harus dicatat secara otomatis saat MLFlow berjalan. Namun, ini bervariasi menurut kerangka kerja. Metrik dan parameter untuk model tertentu mungkin tidak dicatat. Misalnya, tidak ada metrik yang akan dicatat untuk model XGBoost , LightGBM , Spark, dan SynapseML. Anda dapat mempelajari selengkapnya tentang metrik dan parameter apa yang diambil dari setiap kerangka kerja menggunakan dokumentasi autologging MLFlow.

Penyetelan paralel dengan Apache Spark

Fungsionalitas ini flaml.tune mendukung penyetelan apache Spark dan pelajar simpul tunggal. Selain itu, saat menyetel pelajar simpul tunggal (misalnya pelajar Scikit-Learn), Anda juga dapat menyetel penyetelan untuk mempercepat proses penyetelan Anda dengan mengatur use_spark = True. Untuk kluster Spark, secara default, FLAML akan meluncurkan satu percobaan per eksekutor. Anda juga dapat menyesuaikan jumlah uji coba bersamaan dengan menggunakan n_concurrent_trials argumen .


analysis = tune.run(
    evaluate_config,  # the function to evaluate a config
    config=config_search_space,  # the search space defined
    metric="score",
    mode="min",  # the optimization mode, "min" or "max"
    num_samples=-1,  # the maximal number of configs to try, -1 means infinite
    time_budget_s=10,  # the time budget in seconds
    use_spark=True,
)
print(analysis.best_trial.last_result)  # the best trial's result
print(analysis.best_config)  # the best config

Untuk mempelajari selengkapnya tentang cara menyejajarkan jejak penyetelan, Anda dapat mengunjungi dokumentasi FLAML untuk pekerjaan Spark paralel.

Memvisualisasikan hasil

Modul ini flaml.visualization menyediakan fungsi utilitas untuk merencanakan proses pengoptimalan menggunakan Plotly. Dengan memanfaatkan Plotly, pengguna dapat secara interaktif menjelajahi hasil eksperimen AutoML mereka. Untuk menggunakan fungsi plot ini, cukup berikan objek atau flaml.tune.tune.ExperimentAnalysis yang dioptimalkan flaml.AutoML sebagai input.

Anda bisa menggunakan fungsi berikut dalam buku catatan Anda:

plot_optimization_history: Plot riwayat pengoptimalan semua uji coba dalam eksperimen.
plot_feature_importance: Plot kepentingan untuk setiap fitur dalam himpunan data.
plot_parallel_coordinate: Memplot hubungan parameter dimensi tinggi dalam eksperimen.
plot_contour: Plot hubungan parameter sebagai plot kontur dalam eksperimen.
plot_edf: Plot nilai tujuan EDF (fungsi distribusi empiris) eksperimen.
plot_timeline: Plot garis waktu eksperimen.
plot_slice: Plot hubungan parameter sebagai plot ipotong dalam sebuah penelitian.
plot_param_importance: Plot kepentingan hyperparameter eksperimen.

Bagikan melalui