Penyetelan hyperparameter model dengan Azure Machine Learning (v1)

BERLAKU UNTUK:Ekstensi ml Azure CLI v1

Penting

Beberapa perintah CLI Azure dalam artikel ini menggunakan ekstensi azure-cli-ml, atau v1, untuk Azure Machine Learning. Dukungan untuk ekstensi v1 akan berakhir pada 30 September 2025. Anda dapat memasang dan menggunakan ekstensi v1 hingga tanggal tersebut.

Kami menyarankan agar Anda beralih ke ekstensi ml, atau v2 sebelum 30 September 2025. Untuk informasi selengkapnya mengenai ekstensi v2, lihat Ekstensi Azure ML CLI dan Python SDK v2.

Mengotomatiskan penyetelan hyperparameter yang efisien dengan menggunakan Azure Machine Learning (v1) paket HyperDrive. Pelajari cara menyelesaikan langkah-langkah yang diperlukan untuk menyetel hyperparameter dengan SDK Azure Machine Learning:

1. Menentukan ruang pencarian parameter
2. Menentukan metrik utama untuk dioptimalkan
3. Menentukan kebijakan penghentian dini untuk eksekusi dengan performa rendah
4. Membuat dan menetapkan sumber daya
5. Meluncurkan eksperimen dengan konfigurasi yang ditentukan
6. Memvisualisasikan eksekusi pelatihan
7. Memilih konfigurasi terbaik untuk model Anda

Apa itu penyetelan hyperparameter?

Hyperparameter adalah parameter yang dapat disesuaikan yang memungkinkan Anda mengontrol proses pelatihan model. Misalnya, dengan jaringan neural, Anda memutuskan jumlah lapisan tersembunyi dan jumlah simpul di setiap lapisan. Kinerja model sangat bergantung pada hyperparameter.

Penyetelan hyperparameter, juga disebut pengoptimalan hyperparameter, adalah proses menemukan konfigurasi hyperparameter yang menghasilkan kinerja terbaik. Proses ini cenderung bersifat manual dan mahal secara komputasi.

Azure Machine Learning memungkinkan Anda mengotomatiskan penyetelan hyperparameter dan menjalankan eksperimen secara paralel untuk mengoptimalkan hyperparameter secara efisien.

Menentukan ruang pencarian

Menyetel hyperparameter dengan mempelajari rentang nilai yang ditentukan untuk setiap hyperparameter.

Hyperparameter dapat bersifat diskret atau berkelanjutan, dan memiliki distribusi nilai yang dijelaskan oleh ekspresi parameter.

Hiperparameter diskrit

Hyperparameter diskret ditentukan sebagai choice di antara nilai diskret. choice dapat berupa:

• satu atau beberapa nilai yang dipisahkan koma
• objek range
• objek list arbitrer apa pun

    {
        "batch_size": choice(16, 32, 64, 128)
        "number_of_hidden_layers": choice(range(1,5))
    }

Dalam hal ini, batch_size salah satu nilai [16, 32, 64, 128] dan number_of_hidden_layers mengambil salah satu nilai [1, 2, 3, 4].

Hyperparameter diskret berikut juga dapat ditentukan menggunakan distribusi:

• quniform(low, high, q) - Mengembalikan nilai seperti round(uniform(low, high) / q) * q
• qloguniform(low, high, q) - Mengembalikan nilai seperti round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Mengembalikan nilai seperti round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Mengembalikan nilai seperti round(exp(normal(mu, sigma)) / q) * q

Hiperparameter berkelanjutan

Hyperparameter berkelanjutan ditentukan sebagai distribusi dalam rentang nilai berkelanjutan:

• uniform(low, high) - Mengembalikan nilai yang didistribusikan secara seragam antara rendah dan tinggi
• loguniform(low, high) - Mengembalikan nilai yang digambar sesuai dengan exp(uniform(low, high)) sehingga logaritma dari nilai yang dikembalikan didistribusikan secara seragam
• normal(mu, sigma) - Mengembalikan nilai riil yang biasanya didistribusikan dengan rata-rata mu dan sigma simpangan baku
• lognormal(mu, sigma) - Mengembalikan nilai yang digambar sesuai dengan exp(normal(mu, sigma)) sehingga logaritma dari nilai yang dikembalikan didistribusikan secara normal

Contoh definisi ruang parameter:

    {    
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1)
    }

Kode ini mendefinisikan ruang pencarian dengan dua parameter - learning_rate dan keep_probability. learning_rate memiliki distribusi normal dengan nilai rata-rata 10 dan simpangan baku 3. keep_probability memiliki distribusi seragam dengan nilai minimum 0,05 dan nilai maksimum 0,1.

Mengambil sampel ruang hyperparameter

Tentukan metode pengambilan sampel parameter untuk digunakan di atas ruang hyperparameter. Azure Machine Learning mendukung metode berikut:

• Pengambilan sampel acak
• Pengambilan sampel kisi
• Pengambilan sampel Bayesian

Pengambilan sampel acak

Pengambilan sampel acak mendukung hyperparameter diskret dan berkelanjutan. Hal ini mendukung penghentian dini eksekusi dengan performa rendah. Beberapa pengguna melakukan pencarian awal dengan pengambilan sampel acak dan kemudian mempersempit ruang pencarian untuk meningkatkan hasil.

Dalam pengambilan sampel acak, nilai hyperparameter dipilih secara acak dari ruang pencarian yang ditentukan.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import normal, uniform, choice
param_sampling = RandomParameterSampling( {
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Pengambilan sampel kisi

Pengambilan sampel kisi mendukung hyperparameter diskrit. Menggunakan pengambilan sampel kisi jika Anda dapat menganggarkan untuk mencari ruang pencarian secara menyeluruh. Mendukung penghentian dini eksekusi dengan performa rendah.

Pengambilan sampel kisi melakukan pencarian kisi sederhana atas semua nilai yang memungkinkan. Pengambilan sampel kisi hanya dapat digunakan dengan hyperparameter choice. Misalnya, ruang berikut memiliki enam sampel:

from azureml.train.hyperdrive import GridParameterSampling
from azureml.train.hyperdrive import choice
param_sampling = GridParameterSampling( {
        "num_hidden_layers": choice(1, 2, 3),
        "batch_size": choice(16, 32)
    }
)

Pengambilan sampel Bayesian

Pengambilan sampel bayes didasarkan pada algoritma pengoptimalan bayes. Pengambilan sampel ini memilih sampel berdasarkan cara sampel sebelumnya diambil, sehingga sampel baru meningkatkan metrik utama.

Pengambilan sampel bayes disarankan jika Anda memiliki anggaran yang cukup untuk menjelajahi ruang hyperparameter. Untuk hasil terbaik, kami merekomendasikan jumlah maksimum eksekusi yang lebih besar dari atau sama dengan 20 kali jumlah hyperparameter yang disetel.

Jumlah eksekusi bersamaan berdampak pada efektivitas proses penyetelan. Jumlah eksekusi bersamaan yang lebih kecil dapat menyebabkan konvergensi pengambilan sampel yang lebih baik, karena tingkat paralelisme yang lebih kecil meningkatkan jumlah eksekusi yang mendapat keuntungan dari eksekusi yang telah selesai sebelumnya.

Pengambilan sampel bayes hanya mendukung distribusi choice, uniform, dan quniform pada ruang pencarian.

from azureml.train.hyperdrive import BayesianParameterSampling
from azureml.train.hyperdrive import uniform, choice
param_sampling = BayesianParameterSampling( {
        "learning_rate": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Tentukan metrik utama

Tentukan metrik utama yang Anda inginkan untuk dioptimalkan oleh penyetelan hyperparameter. Setiap eksekusi pelatihan dievaluasi untuk metrik utama. Kebijakan penghentian dini menggunakan metrik utama untuk mengidentifikasi eksekusi dengan performa rendah.

Tentukan atribut berikut untuk metrik utama Anda:

• primary_metric_name: Nama metrik utama harus sama persis dengan nama metrik yang telah dicatat di log oleh skrip pelatihan
• primary_metric_goal: Hal tersebut dapat berupa PrimaryMetricGoal.MAXIMIZE atau PrimaryMetricGoal.MINIMIZE dan menentukan apakah metrik utama akan dimaksimalkan atau diminimalkan saat mengevaluasi eksekusi.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Sampel ini memaksimalkan "accuracy".

Membuat log metrik untuk penyetelan hyperparameter

Skrip pelatihan untuk model Anda harus membuat log metrik utama selama pelatihan model sehingga HyperDrive bisa mengaksesnya untuk penyetelan hyperparameter.

Buat log metrik utama dalam skrip pelatihan Anda dengan cuplikan sampel berikut:

from azureml.core.run import Run
run_logger = Run.get_context()
run_logger.log("accuracy", float(val_accuracy))

Skrip pelatihan menghitung val_accuracy dan membuat log sebagai metrik utama "accuracy". Setiap kali metrik dicatat di log, metrik diterima oleh layanan penyetelan hyperparameter. Anda dapat menentukan frekuensi pelaporan sesuai keinginan Anda.

Untuk informasi selengkapnya tentang nilai pengelogan dalam eksekusi pelatihan model, lihat Mengaktifkan pengelogan di Azure Pembelajaran Mesin eksekusi pelatihan.

Tentukan kebijakan penghentian dini

Secara otomatis mengakhiri eksekusi performa buruk dengan kebijakan penghentian dini. Penghentian dini meningkatkan efisiensi komputasi.

Anda dapat mengonfigurasi parameter berikut yang mengontrol kapan kebijakan diterapkan:

• evaluation_interval: frekuensi penerapan kebijakan. Setiap kali skrip pelatihan membuat log metrik utama dihitung sebagai satu interval. evaluation_interval 1 akan menerapkan kebijakan setiap kali skrip pelatihan melaporkan metrik utama. evaluation_interval 2 akan menerapkan kebijakan setiap waktu lain. Jika tidak ditentukan, evaluation_interval diatur ke 1 secara default.
• delay_evaluation: menunda evaluasi kebijakan pertama untuk jumlah interval yang ditentukan. Ini adalah parameter opsional yang menghindari penghentian dini eksekusi pelatihan dengan mengizinkan semua konfigurasi berjalan untuk jumlah interval minimum. Jika ditentukan, kebijakan ini menerapkan setiap kelipatan evaluation_interval yang lebih besar dari atau sama dengan delay_evaluation.

Azure Machine Learning mendukung kebijakan penghentian dini berikut:

• Kebijakan bandit
• Kebijakan penghentian median
• Kebijakan pemilihan pemotongan
• Tidak ada kebijakan penghentian

Kebijakan bandit

Kebijakan bandit didasarkan pada faktor kelonggaran/jumlah kelonggaran dan interval evaluasi. Bandit mengakhiri eksekusi ketika metrik utama tidak dalam faktor kelonggaran yang ditentukan/jumlah kelonggaran dari eksekusi yang paling sukses.

Catatan

Pengambilan sampel Bayes tidak mendukung penghentian dini. Saat menggunakan pengambilan sampel Bayes, atur early_termination_policy = None.

Menentukan parameter konfigurasi berikut:

• slack_factor atau slack_amount : kelonggaran yang diizinkan sehubungan dengan eksekusi pelatihan dengan performa terbaik. slack_factor menentukan kelonggaran yang diperbolehkan sebagai rasio. slack_amount menentukan kelonggaran yang diperbolehkan sebagai jumlah absolut, bukan rasio.

  Misalnya, pertimbangkan kebijakan Bandit yang diterapkan pada interval 10. Asumsikan bahwa eksekusi dengan performa terbaik pada interval 10 melaporkan metrik utama adalah 0,8 dengan tujuan untuk memaksimalkan metrik utama. Jika kebijakan menentukan slack_factor0,2, setiap eksekusi pelatihan yang metrik terbaiknya pada interval 10 kurang dari 0,66 (0,8/(1+slack_factor)) akan dihentikan.

• evaluation_interval: (opsional) frekuensi penerapan kebijakan

• delay_evaluation: (opsional) menunda evaluasi kebijakan pertama untuk jumlah interval yang ditentukan

from azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_factor = 0.1, evaluation_interval=1, delay_evaluation=5)

Dalam contoh ini, kebijakan penghentian dini diterapkan pada setiap interval ketika metrik dilaporkan, dimulai pada interval evaluasi 5. Setiap eksekusi dengan metrik terbaiknya kurang dari (1/(1+0,1) atau 91% dari eksekusi dengan performa terbaik akan dihentikan.

Kebijakan penghentian median

Penghentian median adalah kebijakan penghentian dini berdasarkan eksekusi rata-rata metrik utama yang dilaporkan oleh eksekusi tersebut. Kebijakan ini menghitung eksekusi rata-rata di semua eksekusi pelatihan dan berhenti berjalan yang nilai metrik utamanya lebih buruk daripada median rata-rata.

Kebijakan ini mengambil parameter konfigurasi berikut:

• evaluation_interval: frekuensi penerapan kebijakan (parameter opsional).
• delay_evaluation: menunda evaluasi kebijakan pertama untuk jumlah interval yang ditentukan (parameter opsional).

from azureml.train.hyperdrive import MedianStoppingPolicy
early_termination_policy = MedianStoppingPolicy(evaluation_interval=1, delay_evaluation=5)

Dalam contoh ini, kebijakan penghentian dini diterapkan pada setiap interval mulai dari interval evaluasi 5. Eksekusi dihentikan pada interval 5 jika metrik utama terbaiknya lebih buruk daripada median rata-rata berjalan selama interval 1:5 di semua eksekusi latihan.

Kebijakan pemilihan pemotongan

Pemilihan pemotongan membatalkan persentase eksekusi terendah yang dijalankan pada setiap interval evaluasi. Eksekusi dibandingkan menggunakan metrik utama.

Kebijakan ini mengambil parameter konfigurasi berikut:

• truncation_percentage: persentase eksekusi dengan performa terendah untuk mengakhiri pada setiap interval evaluasi. Nilai bilangan bulat antara 1 dan 99.
• evaluation_interval: (opsional) frekuensi penerapan kebijakan
• delay_evaluation: (opsional) menunda evaluasi kebijakan pertama untuk jumlah interval yang ditentukan
• exclude_finished_jobs: menentukan apakah akan mengecualikan pekerjaan yang sudah selesai saat menerapkan kebijakan

from azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

Dalam contoh ini, kebijakan penghentian dini diterapkan pada setiap interval mulai dari interval evaluasi 5. Eksekusi berakhir pada interval 5 jika performanya pada interval 5 berada di 20% terendah dari performa pada semua eksekusi pada interval 5 dan akan mengecualikan pekerjaan yang selesai saat menerapkan kebijakan.

Tidak ada kebijakan penghentian (default)

Jika tidak ada kebijakan yang ditentukan, layanan penyetelan hyperparameter akan memungkinkan semua eksekusi pelatihan untuk menyelesaikan.

policy=None

Memilih kebijakan penghentian awal

• Untuk kebijakan konservatif yang menyediakan penghematan tanpa mengakhiri pekerjaan yang menjanjikan, pertimbangkan Policy Penghentian Median dengan evaluation_interval 1 dan delay_evaluation 5. Ini adalah pengaturan konservatif, yang dapat memberikan penghematan sekitar 25%-35% tanpa kehilangan metrik utama (berdasarkan data evaluasi kami).
• Untuk penghematan yang lebih agresif, gunakan Kebijakan Bandit dengan kelonggaran yang lebih kecil atau Policy Pemilihan Pemotongan dengan persentase pemotongan yang lebih besar.

Membuat dan menetapkan sumber daya

Mengontrol anggaran sumber daya Anda dengan menentukan jumlah maksimum eksekusi pelatihan.

• max_total_runs: Jumlah maksimum eksekusi pelatihan. Harus bilangan bulat antara 1 dan 1000.
• max_duration_minutes: (opsional) Durasi maksimum, dalam hitungan menit, dari eksperimen penyetelan hyperparameter. Eksekusi setelah durasi ini dibatalkan.

Catatan

Jika max_total_runs dan max_duration_minutes ditentukan, eksperimen penyetelan hyperparameter berakhir ketika yang pertama dari dua ambang batas ini tercapai.

Selain itu, tentukan jumlah maksimum eksekusi pelatihan yang untuk berjalan bersamaan selama pencarian penyetelan hyperparameter Anda.

• max_concurrent_runs: (opsional) Jumlah maksimum eksekusi yang dapat berjalan bersamaan. Jika tidak ditentukan, semua eksekusi diluncurkan secara paralel. Jika ditentukan, harus bilangan bulat antara 1 dan 100.

Catatan

Jumlah eksekusi bersamaan terjaga pada sumber daya yang tersedia dalam target komputasi yang ditentukan. Pastikan bahwa target komputasi memiliki sumber daya yang tersedia untuk konkurensi yang diinginkan.

max_total_runs=20,
max_concurrent_runs=4

Kode ini mengonfigurasi eksperimen penyetelan hyperparameter untuk menggunakan maksimal 20 total eksekusi, menjalankan empat konfigurasi sekaligus.

Mengonfigurasi eksperimen penyetelan hyperparameter

Untuk mengonfigurasi eksperimen penyetelan hyperparameter Anda, berikan hal berikut:

• Ruang pencarian hyperparameter yang ditentukan
• Kebijakan penghentian dini Anda
• Metrik utama
• Pengaturan alokasi sumber daya
• ScriptRunConfig script_run_config

ScriptRunConfig adalah skrip pelatihan yang akan berjalan dengan hyperparameter sampel. ScriptRunConfig mendefinisikan sumber daya per pekerjaan (simpul tunggal dan multi-simpul) dan target komputasi untuk digunakan.

Catatan

Target komputasi yang digunakan di script_run_config harus memiliki sumber daya yang cukup untuk tingkat konkurensi Anda. Untuk informasi lebih lengkap tentang ScriptRunConfig, lihat Mengonfigurasi eksekusi pelatihan.

Mengonfigurasi eksperimen penyetelan hyperparameter:

from azureml.train.hyperdrive import HyperDriveConfig
from azureml.train.hyperdrive import RandomParameterSampling, BanditPolicy, uniform, PrimaryMetricGoal

param_sampling = RandomParameterSampling( {
        'learning_rate': uniform(0.0005, 0.005),
        'momentum': uniform(0.9, 0.99)
    }
)

early_termination_policy = BanditPolicy(slack_factor=0.15, evaluation_interval=1, delay_evaluation=10)

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

HyperDriveConfig mengatur parameter yang diteruskan ke ScriptRunConfig script_run_config. script_run_config, pada gilirannya, meneruskan parameter ke skrip pelatihan. Cuplikan kode di atas diambil dari notebook sampel Melatih, menyetel hyperparameter, dan menyebarkan dengan PyTorch. Dalam sampel ini, parameter learning_rate dan momentum akan disetel. Eksekusi penghentian dini akan ditentukan oleh BanditPolicy, yang menghentikan eksekusi yang metrik utamanya tidak disertakan dalam slack_factor (lihat referensi kelas BanditPolicy).

Kode berikut dari sampel menunjukkan cara nilai yang sedang disetel diterima, diuraikan, dan diteruskan ke fungsi fine_tune_model skrip pelatihan:

# from pytorch_train.py
def main():
    print("Torch version:", torch.__version__)

    # get command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--num_epochs', type=int, default=25,
                        help='number of epochs to train')
    parser.add_argument('--output_dir', type=str, help='output directory')
    parser.add_argument('--learning_rate', type=float,
                        default=0.001, help='learning rate')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum')
    args = parser.parse_args()

    data_dir = download_data()
    print("data directory is: " + data_dir)
    model = fine_tune_model(args.num_epochs, data_dir,
                            args.learning_rate, args.momentum)
    os.makedirs(args.output_dir, exist_ok=True)
    torch.save(model, os.path.join(args.output_dir, 'model.pt'))

Penting

Setiap eksekusi parameter memulai ulang pelatihan dari awal, termasuk membangun ulang model dan semua pemuat data. Anda dapat meminimalkan biaya ini dengan menggunakan Azure Machine Learning atau proses manual untuk melakukan persiapan data sebanyak mungkin sebelum eksekusi pelatihan anda.

Mengirimkan eksperimen penyetelan hyperparameter

Setelah Anda menentukan konfigurasi penyetelan hyperparameter Anda, kirimkan eksperimen:

from azureml.core.experiment import Experiment
experiment = Experiment(workspace, experiment_name)
hyperdrive_run = experiment.submit(hd_config)

Melakukan warm start penyetelan hyperparameter (opsional)

Menemukan nilai hyperparameter terbaik untuk model Anda bisa menjadi proses yang iteratif. Anda dapat menggunakan kembali pengetahuan dari lima eksekusi sebelumnya untuk mempercepat penyetelan hyperparameter.

Warm start ditangani secara berbeda tergantung pada metode pengambilan sampel:

• Pengambilan sampel Bayes: Uji coba dari eksekusi sebelumnya digunakan sebagai pengetahuan sebelumnya untuk memilih sampel baru, dan untuk meningkatkan metrik utama.
• Pengambilan sampel acak atau pengambilan sampel kisi: Penghentian pada awal prosesnya menggunakan pengetahuan dari eksekusi sebelumnya untuk menentukan eksekusi yang performanya buruk.

Tentukan daftar eksekusi induk yang ingin Anda lakukan warm start.

from azureml.train.hyperdrive import HyperDriveRun

warmstart_parent_1 = HyperDriveRun(experiment, "warmstart_parent_run_ID_1")
warmstart_parent_2 = HyperDriveRun(experiment, "warmstart_parent_run_ID_2")
warmstart_parents_to_resume_from = [warmstart_parent_1, warmstart_parent_2]

Jika eksperimen penyetelan hyperparameter dibatalkan, Anda dapat melanjutkan pelatihan yang dijalankan dari titik pemeriksaan terakhir. Namun, skrip pelatihan Anda harus menangani logika titik pemeriksaan.

Eksekusi pelatihan harus menggunakan konfigurasi hyperparameter yang sama dan memasang folder output. Skrip pelatihan harus menerima argumen resume-from, yang berisi file model atau titik pemeriksaan tempat melanjutkan eksekusi pelatihan. Anda dapat melanjutkan eksekusi latihan individu menggunakan cuplikan berikut:

from azureml.core.run import Run

resume_child_run_1 = Run(experiment, "resume_child_run_ID_1")
resume_child_run_2 = Run(experiment, "resume_child_run_ID_2")
child_runs_to_resume = [resume_child_run_1, resume_child_run_2]

Anda dapat mengonfigurasi eksperimen penyetelan hyperparameter untuk memulai ulang dari eksperimen sebelumnya atau melanjutkan eksekusi latihan individu menggunakan parameter resume_from dan resume_child_runs opsional di konfigurasi:

from azureml.train.hyperdrive import HyperDriveConfig

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             resume_from=warmstart_parents_to_resume_from,
                             resume_child_runs=child_runs_to_resume,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Memvisualisasikan eksekusi penyetelan hyperparameter

Anda dapat memvisualisasikan eksekusi penyetelan hyperparameter anda di studio Azure Machine Learning, atau Anda dapat menggunakan widget notebook.

Studio

Anda dapat memvisualisasikan semua eksekusi penyetelan hyperparameter Anda di studio Azure Machine Learning. Untuk informasi selengkapnya tentang cara menampilkan eksperimen di portal, lihat Menampilkan data eksekusi di studio.

• Bagan metrik: Visualisasi ini melacak metrik yang dicatat untuk setiap anak hyperdrive yang berjalan selama durasi penyetelan hyperparameter. Setiap baris mewakili eksekusi anak, dan setiap titik mengukur nilai metrik utama pada iterasi runtime.

  

• Bagan Koordinat Paralel: Visualisasi ini menunjukkan korelasi antara performa metrik utama dan nilai hyperparameter individu. Bagan interaktif melalui pergerakan sumbu (klik dan seret menurut label sumbu), dan dengan menyoroti nilai di seluruh sumbu tunggal (klik dan seret secara vertikal di sepanjang sumbu tunggal untuk menyoroti rentang nilai yang diinginkan). Bagan koordinat paralel mencakup sumbu di bagian paling kanan bagan yang memplot nilai metrik terbaik yang sesuai dengan hiperparameter yang ditetapkan untuk instans yang dijalankan tersebut. Sumbu ini diberikan untuk memproyeksikan legenda gradien bagan ke data dengan cara yang lebih mudah dibaca.

  

• Bagan Sebar 2 Dimensi: Visualisasi ini menunjukkan korelasi antara dua hyperparameter individu bersama dengan nilai metrik utama terkait.

  

• Bagan Sebar 3 Dimensi:Visualisasi ini sama dengan 2D tetapi memungkinkan tiga dimensi korelasi hyperparameter dengan nilai metrik utama. Anda juga dapat mengeklik dan menyeret untuk mengorientasikan ulang bagan untuk melihat korelasi yang berbeda dalam ruang 3D.

  

Widget buku catatan

Gunakan widget Notebook untuk memvisualisasikan kemajuan eksekusi pelatihan Anda. Cuplikan berikut memvisualisasikan semua penyetelan hyperparameter Anda yang berjalan di satu tempat di buku catatan Jupyter:

from azureml.widgets import RunDetails
RunDetails(hyperdrive_run).show()

Kode ini menampilkan tabel dengan detail tentang pelatihan yang dijalankan untuk setiap konfigurasi hyperparameter.

Anda juga dapat memvisualisasikan kinerja masing-masing eksekusi saat pelatihan berlangsung.

Menemukan model terbaik

Setelah semua eksekusi penyetelan hyperparameter selesai, identifikasi nilai hyperparameter dan konfigurasi yang memiliki kinerja terbaik:

best_run = hyperdrive_run.get_best_run_by_primary_metric()
best_run_metrics = best_run.get_metrics()
parameter_values = best_run.get_details()['runDefinition']['arguments']

print('Best Run Id: ', best_run.id)
print('\n Accuracy:', best_run_metrics['accuracy'])
print('\n learning rate:',parameter_values[3])
print('\n keep probability:',parameter_values[5])
print('\n batch size:',parameter_values[7])

Notebook sampel

Lihat notebook train-hyperparameter-* di folder ini:

• how-to-use-azureml/ml-frameworks

Pelajari cara menjalankan notebook dengan mengikuti artikel Menggunakan notebook Jupyter untuk menjelajahi layanan ini.

Langkah berikutnya

• Melacak eksperimen
• Menyebarkan model terlatih