Menyiapkan AutoML untuk melatih model prakiraan rangkaian waktu dengan SDK dan CLI

  • Artikel

BERLAKU UNTUK:Ekstensi ml Azure CLI v2 (saat ini)Python SDK azure-ai-ml v2 (saat ini)

Dalam artikel ini, Anda akan mempelajari cara menyiapkan AutoML untuk prakiraan rangkaian waktu dengan Azure Pembelajaran Mesin ML otomatis di Azure Pembelajaran Mesin Python SDK.

Untuk melakukannya, Anda perlu:

  • Siapkan data untuk pelatihan.
  • Konfigurasikan parameter rangkaian waktu tertentu dalam Pekerjaan Prakiraan.
  • Mengatur pelatihan, inferensi, dan evaluasi model menggunakan komponen dan alur.

Untuk pengalaman minim kode, lihat Tutorial: Memperkirakan permintaan dengan pembelajaran mesin otomatis untuk contoh perkiraan rangkaian waktu menggunakan ML otomatis di studio Azure Machine Learning.

AutoML menggunakan model pembelajaran mesin standar bersama dengan model rangkaian waktu terkenal untuk membuat prakiraan. Pendekatan kami menggabungkan informasi historis tentang variabel target, fitur yang disediakan pengguna dalam data input, dan fitur yang direkayasa secara otomatis. Algoritma pencarian model kemudian bekerja untuk menemukan model dengan akurasi prediktif terbaik. Untuk detail selengkapnya, lihat artikel kami tentang metodologi prakiraan dan pencarian model.

Prasyarat

Untuk artikel ini Anda memerlukan,

Data pelatihan dan validasi

Data input untuk prakiraan AutoML harus berisi rangkaian waktu yang valid dalam format tabular. Setiap variabel harus memiliki kolom yang sesuai sendiri dalam tabel data. AutoML memerlukan setidaknya dua kolom: kolom waktu yang mewakili sumbu waktu dan kolom target yang merupakan kuantitas untuk prakiraan. Kolom lain dapat berfungsi sebagai prediktor. Untuk detail selengkapnya, lihat cara AutoML menggunakan data Anda.

Penting

Saat melatih model untuk memperkirakan nilai masa depan, pastikan semua fitur yang digunakan dalam pelatihan dapat digunakan saat menjalankan prediksi untuk cakrawala yang Anda maksudkan.

Misalnya, fitur untuk harga saham saat ini dapat secara besar-besaran meningkatkan akurasi pelatihan. Namun, jika Anda berniat untuk memperkirakan dengan cakrawala yang panjang, Anda mungkin tidak dapat memprediksi nilai saham di masa depan secara akurat sesuai dengan poin rangkaian waktu di masa depan, dan akurasi model dapat menurun.

Pekerjaan prakiraan AutoML mengharuskan data pelatihan Anda diwakili sebagai objek MLTable . MLTable menentukan sumber data dan langkah-langkah untuk memuat data. Untuk informasi selengkapnya dan kasus penggunaan, lihat panduan cara menggunakan MLTable. Sebagai contoh sederhana, misalkan data pelatihan Anda terkandung dalam file CSV di direktori lokal, ./train_data/timeseries_train.csv.

Anda dapat membuat MLTable menggunakan Mltable Python SDK seperti dalam contoh berikut:

import mltable

paths = [
    {'file': './train_data/timeseries_train.csv'}
]

train_table = mltable.from_delimited_files(paths)
train_table.save('./train_data')

Kode ini membuat file baru, ./train_data/MLTable, yang berisi format file dan instruksi pemuatan.

Anda sekarang menentukan objek data input, yang diperlukan untuk memulai pekerjaan pelatihan, menggunakan Azure Pembelajaran Mesin Python SDK sebagai berikut:

from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import Input

# Training MLTable defined locally, with local data to be uploaded
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./train_data"
)

Anda menentukan data validasi dengan cara yang sama, dengan membuat MLTable dan menentukan input data validasi. Atau, jika Anda tidak menyediakan data validasi, AutoML secara otomatis membuat pemisahan validasi silang dari data pelatihan Anda untuk digunakan untuk pemilihan model. Lihat artikel kami tentang pemilihan model prakiraan untuk detail selengkapnya. Lihat juga persyaratan panjang data pelatihan untuk detail tentang berapa banyak data pelatihan yang Anda butuhkan untuk berhasil melatih model prakiraan.

Pelajari selengkapnya tentang cara AutoML menerapkan validasi silang untuk mencegah over fitting.

Komputasi untuk menjalankan eksperimen

AutoML menggunakan Azure Pembelajaran Mesin Compute, yang merupakan sumber daya komputasi yang dikelola sepenuhnya, untuk menjalankan pekerjaan pelatihan. Dalam contoh berikut, kluster komputasi bernama cpu-compute dibuat:

from azure.ai.ml.entities import AmlCompute

# specify aml compute name.
cpu_compute_target = "cpu-cluster"

try:
    ml_client.compute.get(cpu_compute_target)
except Exception:
    print("Creating a new cpu compute target...")
    compute = AmlCompute(
        name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
    )
    ml_client.compute.begin_create_or_update(compute).result()

Mengonfigurasi eksperimen

Anda menggunakan fungsi pabrik automl untuk mengonfigurasi pekerjaan prakiraan di Python SDK. Contoh berikut menunjukkan cara membuat pekerjaan prakiraan dengan mengatur metrik utama dan menetapkan batas pada pelatihan yang dijalankan:

from azure.ai.ml import automl

# note that the below is a code snippet -- you might have to modify the variable values to run it successfully
forecasting_job = automl.forecasting(
    compute="cpu-compute",
    experiment_name="sdk-v2-automl-forecasting-job",
    training_data=my_training_data_input,
    target_column_name=target_column_name,
    primary_metric="normalized_root_mean_squared_error",
    n_cross_validations="auto",
)

# Limits are all optional
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Memperkirakan pengaturan pekerjaan

Tugas prakiraan memiliki banyak pengaturan yang khusus untuk prakiraan. Yang paling mendasar dari pengaturan ini adalah nama kolom waktu dalam data pelatihan dan cakrawala prakiraan.

Gunakan metode ForecastingJob untuk mengonfigurasi pengaturan ini:

# Forecasting specific configuration
forecasting_job.set_forecast_settings(
    time_column_name=time_column_name,
    forecast_horizon=24
)

Nama kolom waktu adalah pengaturan yang diperlukan dan Anda umumnya harus mengatur cakrawala prakiraan sesuai dengan skenario prediksi Anda. Jika data Anda berisi beberapa rangkaian waktu, Anda dapat menentukan nama kolom ID rangkaian waktu. Kolom ini, saat dikelompokkan, menentukan seri individual. Misalnya, Anda memiliki data yang terdiri dari penjualan per jam dari berbagai toko dan merek. Contoh berikut menunjukkan cara mengatur kolom ID rangkaian waktu dengan asumsi data berisi kolom bernama "store" dan "brand":

# Forecasting specific configuration
# Add time series IDs for store and brand
forecasting_job.set_forecast_settings(
    ...,  # other settings
    time_series_id_column_names=['store', 'brand']
)

AutoML mencoba mendeteksi kolom ID rangkaian waktu secara otomatis dalam data Anda jika tidak ada yang ditentukan.

Pengaturan lain bersifat opsional dan ditinjau di bagian berikutnya.

Pengaturan pekerjaan prakiraan opsional

Konfigurasi opsional tersedia untuk tugas prakiraan, seperti mengaktifkan pembelajaran mendalam dan menentukan agregasi jendela bergulir target. Daftar lengkap parameter tersedia dalam dokumentasi referensi prakiraan.

Pengaturan pencarian model

Ada dua pengaturan opsional yang mengontrol ruang model tempat AutoML mencari model terbaik, allowed_training_algorithms dan blocked_training_algorithms. Untuk membatasi ruang pencarian ke sekumpulan kelas model tertentu, gunakan allowed_training_algorithms parameter seperti dalam sampel berikut:

# Only search ExponentialSmoothing and ElasticNet models
forecasting_job.set_training(
    allowed_training_algorithms=["ExponentialSmoothing", "ElasticNet"]
)

Dalam hal ini, pekerjaan prakiraan hanya mencari di atas kelas model Exponential Smoothing dan Elastic Net. Untuk menghapus sekumpulan kelas model tertentu dari ruang pencarian, gunakan blocked_training_algorithms seperti dalam sampel berikut:

# Search over all model classes except Prophet
forecasting_job.set_training(
    blocked_training_algorithms=["Prophet"]
)

Sekarang, pekerjaan mencari di semua kelas model kecuali Prophet. Untuk daftar nama model prakiraan yang diterima di allowed_training_algorithms dan blocked_training_algorithms, lihat dokumentasi referensi properti pelatihan. Baik, tetapi tidak keduanya, dari allowed_training_algorithms dan blocked_training_algorithms dapat diterapkan pada eksekusi pelatihan.

Mengaktifkan pembelajaran mendalam

AutoML dikirim dengan model jaringan neural dalam kustom (DNN) yang disebut TCNForecaster. Model ini adalah jaringan konvolusional temporal, atau TCN, yang menerapkan metode tugas pencitraan umum untuk pemodelan rangkaian waktu. Yaitu, konvolusi "kausal" satu dimensi membentuk tulang punggung jaringan dan memungkinkan model untuk mempelajari pola kompleks selama durasi panjang dalam riwayat pelatihan. Untuk detail selengkapnya, lihat artikel TCNForecaster kami.

Diagram memperlihatkan komponen utama TCNForecaster AutoML.

TCNForecaster sering mencapai akurasi yang lebih tinggi daripada model rangkaian waktu standar ketika ada ribuan atau lebih pengamatan dalam riwayat pelatihan. Namun, diperlukan waktu lebih lama untuk melatih dan menyapu model TCNForecaster karena kapasitasnya yang lebih tinggi.

Anda dapat mengaktifkan TCNForecaster di AutoML dengan mengatur enable_dnn_training bendera dalam konfigurasi pelatihan sebagai berikut:

# Include TCNForecaster models in the model search
forecasting_job.set_training(
    enable_dnn_training=True
)

Secara default, pelatihan TCNForecaster terbatas pada satu simpul komputasi dan satu GPU, jika tersedia, per uji coba model. Untuk skenario data besar, sebaiknya distribusikan setiap uji coba TCNForecaster melalui beberapa core/GPU dan simpul. Lihat bagian artikel pelatihan terdistribusi kami untuk informasi selengkapnya dan sampel kode.

Untuk mengaktifkan DNN untuk eksperimen AutoML yang dibuat di studio Azure Machine Learning, lihat Cara pengaturan jenis tugas di antarmuka pengguna studio.

Catatan

  • Saat Anda mengaktifkan DNN untuk percobaan yang dibuat dengan SDK, penjelasan model terbaik dinonaktifkan.
  • Dukungan DNN untuk prakiraan di Pembelajaran Mesin otomatis tidak didukung untuk eksekusi yang dimulai di Databricks.
  • Jenis komputasi GPU direkomendasikan saat pelatihan DNN diaktifkan

Fitur lag dan rolling window

Nilai terbaru dari target sering kali merupakan fitur yang berdampak dalam model prakiraan. Dengan demikian, AutoML dapat membuat fitur agregasi jendela bergulir dan tertinggal waktu untuk berpotensi meningkatkan akurasi model.

Pertimbangkan skenario prakiraan permintaan energi di mana data cuaca dan permintaan historis tersedia. Tabel menunjukkan rekayasa fitur yang dihasilkan yang terjadi ketika agregasi jendela diterapkan selama tiga jam terakhir. Kolom untuk minimum, maksimum, dan jumlah dihasilkan pada jendela geser tiga jam berdasarkan pengaturan yang ditentukan. Misalnya, untuk pengamatan yang berlaku pada 8 September 2017 04:00, nilai maksimum, minimum, dan jumlah dihitung menggunakan nilai permintaan untuk 8 September 2017 01:00 - 03:00. Jendela tiga jam ini bergeser bersama untuk mengisi data untuk baris yang tersisa. Untuk detail dan contoh selengkapnya, lihat artikel fitur jeda.

jendela bergulir target

Anda dapat mengaktifkan fitur agregasi jendela jeda dan bergulir untuk target dengan mengatur ukuran jendela bergulir, yaitu tiga dalam contoh sebelumnya, dan urutan jeda yang ingin Anda buat. Anda juga dapat mengaktifkan lag untuk fitur dengan feature_lags pengaturan . Dalam sampel berikut, kami mengatur semua pengaturan ini sehingga auto AutoML akan secara otomatis menentukan pengaturan dengan menganalisis struktur korelasi data Anda:

forecasting_job.set_forecast_settings(
    ...,  # other settings
    target_lags='auto', 
    target_rolling_window_size='auto',
    feature_lags='auto'
)

Penanganan rangkaian singkat

ML otomatis menganggap rangkaian waktu sebagai seri pendek jika tidak ada cukup poin data untuk melakukan fase pelatihan dan validasi pengembangan model. Lihat persyaratan panjang data pelatihan untuk detail selengkapnya tentang persyaratan panjang.

AutoML memiliki beberapa tindakan yang dapat dilakukan untuk seri pendek. Tindakan ini dapat dikonfigurasi dengan short_series_handling_config pengaturan . Nilai defaultnya adalah "otomatis." Tabel berikut ini menjelaskan pengaturan:

Pengaturan Deskripsi
auto Nilai default untuk penanganan seri pendek.
- Jika semua rangkaian berdurasi singkat, lapisi data.
- Jika tidak semua rangkaian berdurasi singkat. hilangkan rangkaian singkat.
pad Jika short_series_handling_config = pad, ML otomatis akan menambahkan nilai acak ke setiap rangkaian singkat yang ditemukan. Berikut ini mencantumkan jenis kolom dan apa yang disertakan dengannya:
- Kolom objek dengan NaN
- Kolom numerik dengan 0
- Kolom Boolean/logika dengan False
- Kolom target diisi dengan kebisingan putih.
drop Jika short_series_handling_config = drop, ML otomatis akan menghilangkan rangkaian singkat dan tidak akan digunakan untuk pelatihan atau prediksi. Prediksi untuk rangkaian ini akan menampilkan NaN.
None Tidak ada rangkaian yang dilapisi atau dihilangkan

Dalam contoh berikut, kami mengatur penanganan seri pendek sehingga semua seri pendek di-padding ke panjang minimum:

forecasting_job.set_forecast_settings(
    ...,  # other settings
    short_series_handling_config='pad'
)

Peringatan

Padding dapat berdampak pada akurasi model yang dihasilkan, karena kami memperkenalkan data buatan untuk menghindari kegagalan pelatihan. Jika banyak rangkaian singkat, Anda mungkin juga melihat beberapa pengaruh dalam hasil penjelasan

Agregasi data frekuensi & target

Gunakan opsi agregasi frekuensi dan data untuk menghindari kegagalan yang disebabkan oleh data yang tidak teratur. Data Anda tidak teratur jika tidak mengikuti irama yang ditetapkan tepat waktu, seperti per jam atau harian. Data titik penjualan adalah contoh data tidak teratur yang baik. Dalam kasus ini, AutoML dapat mengagregasi data Anda ke frekuensi yang diinginkan lalu membangun model prakiraan dari agregat.

Anda perlu mengatur frequency pengaturan dan target_aggregate_function untuk menangani data yang tidak teratur. Pengaturan frekuensi menerima string Pandas DateOffset sebagai input. Nilai yang didukung untuk fungsi agregasi adalah:

Fungsi Deskripsi
sum  Jumlah nilai target
mean  Nilai tengah atau rata-rata nilai target
min Nilai minimum target
max Nilai maksimum target
  • Nilai kolom target diagregasi sesuai dengan operasi yang ditentukan. Biasanya, jumlah sesuai untuk sebagian besar skenario.
  • Kolom prediktor numerik dalam data Anda diagregasi menurut jumlah, rata-rata, nilai minimum, dan nilai maksimum. Akibatnya, ML otomatis menghasilkan kolom baru yang dicukupkan dengan nama fungsi agregasi dan menerapkan operasi agregat yang dipilih.
  • Untuk kolom prediktor kategoris, data diagregasi menurut mode, kategori paling menonjol di jendela.
  • Kolom prediktor tanggal diagregasi menurut nilai minimum, nilai maksimum, dan mode.

Contoh berikut mengatur frekuensi ke per jam dan fungsi agregasi ke penjumlahan:

# Aggregate the data to hourly frequency
forecasting_job.set_forecast_settings(
    ...,  # other settings
    frequency='H',
    target_aggregate_function='sum'
)

Pengaturan validasi silang kustom

Ada dua pengaturan yang dapat disesuaikan yang mengontrol validasi silang untuk pekerjaan prakiraan: jumlah lipatan, n_cross_validations, dan ukuran langkah yang menentukan offset waktu antara lipatan, cv_step_size. Lihat pemilihan model prakiraan untuk informasi selengkapnya tentang arti parameter ini. Secara default, AutoML mengatur kedua pengaturan secara otomatis berdasarkan karakteristik data Anda, tetapi pengguna tingkat lanjut mungkin ingin mengaturnya secara manual. Misalnya, Anda memiliki data penjualan harian dan Anda ingin penyiapan validasi terdiri dari lima lipatan dengan offset tujuh hari antara lipatan yang berdekatan. Sampel kode berikut menunjukkan cara mengatur ini:

from azure.ai.ml import automl

# Create a job with five CV folds
forecasting_job = automl.forecasting(
    ...,  # other training parameters
    n_cross_validations=5,
)

# Set the step size between folds to seven days
forecasting_job.set_forecast_settings(
    ...,  # other settings
    cv_step_size=7
)

Fiturisasi kustom

Secara default, AutoML menambah data pelatihan dengan fitur yang direkayasa untuk meningkatkan akurasi model. Lihat rekayasa fitur otomatis untuk informasi selengkapnya. Beberapa langkah pra-pemrosesan dapat disesuaikan menggunakan konfigurasi fiturisasi pekerjaan prakiraan.

Kustomisasi yang didukung untuk prakiraan ada dalam tabel berikut:

Penyesuaian Deskripsi Opsi
Pembaruan tujuan kolom Mengganti jenis fitur yang terdeteksi otomatis untuk kolom yang ditentukan. "Kategoris", "DateTime", "Numerik"
Pembaruan parameter transformator Perbarui parameter untuk imputer yang ditentukan. {"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}{"strategy": "ffill"}

Misalnya, Anda memiliki skenario permintaan ritel di mana data mencakup harga, bendera "dijual", dan jenis produk. Contoh berikut menunjukkan bagaimana Anda dapat mengatur jenis dan imputer yang dikustomisasi untuk fitur-fitur ini:

from azure.ai.ml.automl import ColumnTransformer

# Customize imputation methods for price and is_on_sale features
# Median value imputation for price, constant value of zero for is_on_sale
transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["price"], parameters={"strategy": "median"}),
        ColumnTransformer(fields=["is_on_sale"], parameters={"strategy": "constant", "fill_value": 0}),
    ],
}

# Set the featurization
# Ensure that product_type feature is interpreted as categorical
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Jika Anda menggunakan studio Azure Machine Learning untuk percobaan, lihat cara menyesuaikan fiturisasi di studio.

Mengirimkan pekerjaan prakiraan

Setelah semua pengaturan dikonfigurasi, Anda meluncurkan pekerjaan prakiraan sebagai berikut:

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    forecasting_job
)

print(f"Created job: {returned_job}")

# Get a URL for the job in the AML studio user interface
returned_job.services["Studio"].endpoint

Setelah pekerjaan dikirimkan, AutoML akan menyediakan sumber daya komputasi, menerapkan fiturisasi dan langkah-langkah persiapan lainnya ke data input, lalu mulai menyapu model prakiraan. Untuk detail selengkapnya, lihat artikel kami tentang metodologi prakiraan dan pencarian model.

Mengatur pelatihan, inferensi, dan evaluasi dengan komponen dan alur

Penting

Fitur ini masih dalam pratinjau umum. Versi pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan terbatas.

Untuk mengetahui informasi selengkapnya, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.

Alur kerja ML Anda kemungkinan memerlukan lebih dari sekadar pelatihan. Inferensi, atau pengambilan prediksi model pada data yang lebih baru, dan evaluasi akurasi model pada set pengujian dengan nilai target yang diketahui adalah tugas umum lainnya yang dapat Anda atur di AzureML bersama dengan pekerjaan pelatihan. Untuk mendukung tugas inferensi dan evaluasi, AzureML menyediakan komponen, yang merupakan bagian kode mandiri yang melakukan satu langkah dalam alur AzureML.

Dalam contoh berikut, kami mengambil kode komponen dari registri klien:

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get a credential for access to the AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if we can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Create a client for accessing assets in the AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create a client for accessing assets in the AzureML preview registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

# Get an inference component from the registry
inference_component = ml_client_registry.components.get(
    name="automl_forecasting_inference",
    label="latest"
)

# Get a component for computing evaluation metrics from the registry
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

Selanjutnya, kami menentukan fungsi pabrik yang membuat alur yang mengatur pelatihan, inferensi, dan komputasi metrik. Lihat bagian konfigurasi pelatihan untuk detail selengkapnya tentang pengaturan pelatihan.

from azure.ai.ml import automl
from azure.ai.ml.constants import AssetTypes
from azure.ai.ml.dsl import pipeline

@pipeline(description="AutoML Forecasting Pipeline")
def forecasting_train_and_evaluate_factory(
    train_data_input,
    test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon,
    primary_metric='normalized_root_mean_squared_error',
    cv_folds='auto'
):
    # Configure the training node of the pipeline
    training_node = automl.forecasting(
        training_data=train_data_input,
        target_column_name=target_column_name,
        primary_metric=primary_metric,
        n_cross_validations=cv_folds,
        outputs={"best_model": Output(type=AssetTypes.MLFLOW_MODEL)},
    )

    training_node.set_forecasting_settings(
        time_column_name=time_column_name,
        forecast_horizon=max_horizon,
        frequency=frequency,
        # other settings
        ... 
    )
    
    training_node.set_training(
        # training parameters
        ...
    )
    
    training_node.set_limits(
        # limit settings
        ...
    )

    # Configure the inference node to make rolling forecasts on the test set
    inference_node = inference_component(
        test_data=test_data_input,
        model_path=training_node.outputs.best_model,
        target_column_name=target_column_name,
        forecast_mode='rolling',
        forecast_step=1
    )

    # Configure the metrics calculation node
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        ground_truth=inference_node.outputs.inference_output_file,
        prediction=inference_node.outputs.inference_output_file,
        evaluation_config=inference_node.outputs.evaluation_config_output_file
    )

    # return a dictionary with the evaluation metrics and the raw test set forecasts
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Sekarang, kami mendefinisikan input data pelatihan dan pengujian dengan asumsi bahwa input tersebut terkandung dalam folder lokal, ./train_data dan ./test_data:

my_train_data_input = Input(
    type=AssetTypes.MLTABLE,
    path="./train_data"
)

my_test_data_input = Input(
    type=AssetTypes.URI_FOLDER,
    path='./test_data',
)

Terakhir, kami membangun alur, mengatur komputasi defaultnya dan mengirimkan pekerjaan:

pipeline_job = forecasting_train_and_evaluate_factory(
    my_train_data_input,
    my_test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon
)

# set pipeline level compute
pipeline_job.settings.default_compute = compute_name

# submit the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

Setelah dikirimkan, alur menjalankan pelatihan AutoML, inferensi evaluasi bergulir, dan perhitungan metrik secara berurutan. Anda dapat memantau dan memeriksa eksekusi di antarmuka pengguna studio. Setelah eksekusi selesai, prakiraan bergulir dan metrik evaluasi dapat diunduh ke direktori kerja lokal:

# Download the metrics json
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='metrics_result')

# Download the rolling forecasts
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='rolling_fcst_result')

Kemudian, Anda dapat menemukan hasil metrik dan ./named-outputs/metrics_results/evaluationResult/metrics.json prakiraan, dalam format baris JSON, dalam ./named-outputs/rolling_fcst_result/inference_output_file.

Untuk detail selengkapnya tentang evaluasi bergulir, lihat artikel evaluasi model prakiraan kami.

Prakiraan dalam skala besar: banyak model

Penting

Fitur ini masih dalam pratinjau umum. Versi pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan terbatas.

Untuk mengetahui informasi selengkapnya, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.

Banyaknya komponen model di AutoML memungkinkan Anda melatih dan mengelola jutaan model secara paralel. Untuk informasi selengkapnya tentang banyak konsep model, lihat bagian artikel banyak model.

Banyak konfigurasi pelatihan model

Banyak komponen pelatihan model menerima file konfigurasi format YAML dari pengaturan pelatihan AutoML. Komponen menerapkan pengaturan ini ke setiap instans AutoML yang diluncurkannya. File YAML ini memiliki spesifikasi yang sama dengan Pekerjaan Prakiraan ditambah parameter partition_column_names tambahan dan allow_multi_partitions.

Parameter Deskripsi
partition_column_names Nama kolom dalam data yang, saat dikelompokkan, menentukan partisi data. Banyak komponen pelatihan model meluncurkan pekerjaan pelatihan independen pada setiap partisi.
allow_multi_partitions Bendera opsional yang memungkinkan pelatihan satu model per partisi saat setiap partisi berisi lebih dari satu rangkaian waktu unik. Nilai defaultnya adalah False.

Sampel berikut menyediakan templat konfigurasi:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

description: A time series forecasting job config
compute: azureml:<cluster-name>
task: forecasting
primary_metric: normalized_root_mean_squared_error
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: date
  time_series_id_column_names: ["state", "store"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
partition_column_names: ["state", "store"]
allow_multi_partitions: false

Dalam contoh berikutnya, kami berasumsi bahwa konfigurasi disimpan di jalur , ./automl_settings_mm.yml.

Banyak alur model

Selanjutnya, kami menentukan fungsi pabrik yang membuat alur untuk orkestrasi banyak pelatihan model, inferensi, dan komputasi metrik. Parameter fungsi pabrik ini dirinci dalam tabel berikut:

Parameter Deskripsi
max_nodes Jumlah simpul komputasi yang akan digunakan dalam pekerjaan pelatihan
max_concurrency_per_node Jumlah proses AutoML yang akan dijalankan pada setiap simpul. Oleh karena itu, konkurensi total dari banyak pekerjaan model adalah max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Banyak komponen model habis yang diberikan dalam jumlah detik.
retrain_failed_models Bendera untuk mengaktifkan pelatihan ulang untuk model yang gagal. Ini berguna jika Anda telah melakukan banyak eksekusi model sebelumnya yang mengakibatkan pekerjaan AutoML yang gagal pada beberapa partisi data. Ketika bendera ini diaktifkan, banyak model hanya akan meluncurkan pekerjaan pelatihan untuk partisi yang sebelumnya gagal.
forecast_mode Mode inferensi untuk evaluasi model. Nilai yang valid adalah "recursive" dan "rolling". Lihat artikel evaluasi model untuk informasi selengkapnya.
forecast_step Ukuran langkah untuk perkiraan bergulir. Lihat artikel evaluasi model untuk informasi selengkapnya.

Sampel berikut mengilustrasikan metode pabrik untuk membangun banyak pelatihan model dan alur evaluasi model:

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get a credential for access to the AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if we can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get a many models training component
mm_train_component = ml_client_registry.components.get(
    name='automl_many_models_training',
    version='latest'
)

# Get a many models inference component
mm_inference_component = ml_client_registry.components.get(
    name='automl_many_models_inference',
    version='latest'
)

# Get a component for computing evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML Many Models Forecasting Pipeline")
def many_models_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    compute_name,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    retrain_failed_model=False,
    forecast_mode="rolling",
    forecast_step=1
):
    mm_train_node = mm_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        retrain_failed_model=retrain_failed_model,
        compute_name=compute_name
    )

    mm_inference_node = mm_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=mm_train_node.outputs.run_output,
        forecast_mode=forecast_mode,
        forecast_step=forecast_step,
        compute_name=compute_name
    )

    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=mm_inference_node.outputs.evaluation_data,
        ground_truth=mm_inference_node.outputs.evaluation_data,
        evaluation_config=mm_inference_node.outputs.evaluation_configs
    )

    # Return the metrics results from the rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Sekarang, kami membangun alur melalui fungsi pabrik, dengan asumsi data pelatihan dan pengujian berada di folder lokal, ./data/train dan ./data/test, masing-masing. Terakhir, kami mengatur komputasi default dan mengirimkan pekerjaan seperti dalam sampel berikut:

pipeline_job = many_models_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_mm.yml"
    ),
    compute_name="<cluster name>"
)
pipeline_job.settings.default_compute = "<cluster name>"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Setelah pekerjaan selesai, metrik evaluasi dapat diunduh secara lokal menggunakan prosedur yang sama seperti dalam alur eksekusi pelatihan tunggal.

Lihat juga prakiraan permintaan dengan banyak buku catatan model untuk contoh yang lebih rinci.

Catatan

Banyak komponen pelatihan dan inferensi model secara kondisional mempartisi data Anda sesuai dengan partition_column_names pengaturan sehingga setiap partisi berada dalam filenya sendiri. Proses ini bisa sangat lambat atau gagal ketika data sangat besar. Dalam hal ini, sebaiknya partisi data Anda secara manual sebelum menjalankan banyak pelatihan atau inferensi model.

Prakiraan dalam skala besar: rangkaian waktu hierarkis

Penting

Fitur ini masih dalam pratinjau umum. Versi pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan terbatas.

Untuk mengetahui informasi selengkapnya, lihat Ketentuan Penggunaan Tambahan untuk Pratinjau Microsoft Azure.

Komponen seri waktu hierarkis (HTS) di AutoML memungkinkan Anda melatih sejumlah besar model pada data dengan struktur hierarkis. Untuk informasi selengkapnya, lihat bagian artikel HTS.

Konfigurasi pelatihan HTS

Komponen pelatihan HTS menerima file konfigurasi format YAML dari pengaturan pelatihan AutoML. Komponen menerapkan pengaturan ini ke setiap instans AutoML yang diluncurkannya. File YAML ini memiliki spesifikasi yang sama dengan Pekerjaan Prakiraan ditambah parameter tambahan yang terkait dengan informasi hierarki:

Parameter Deskripsi
hierarchy_column_names Daftar nama kolom dalam data yang menentukan struktur hierarkis data. Urutan kolom dalam daftar ini menentukan tingkat hierarki; tingkat agregasi menurun dengan indeks daftar. Artinya, kolom terakhir dalam daftar mendefinisikan tingkat hierarki daun (paling tidak diagregasi).
hierarchy_training_level Tingkat hierarki yang digunakan untuk pelatihan model prakiraan.

Berikut ini memperlihatkan konfigurasi sampel:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

description: A time series forecasting job config
compute: azureml:cluster-name
task: forecasting
primary_metric: normalized_root_mean_squared_error
log_verbosity: info
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: "date"
  time_series_id_column_names: ["state", "store", "SKU"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
hierarchy_column_names: ["state", "store", "SKU"]
hierarchy_training_level: "store"

Dalam contoh berikutnya, kami berasumsi bahwa konfigurasi disimpan di jalur , ./automl_settings_hts.yml.

Alur HTS

Selanjutnya, kami menentukan fungsi pabrik yang membuat alur untuk orkestrasi pelatihan, inferensi, dan komputasi metrik HTS. Parameter fungsi pabrik ini dirinci dalam tabel berikut:

Parameter Deskripsi
forecast_level Tingkat hierarki untuk mengambil prakiraan
allocation_method Metode alokasi yang digunakan saat prakiraan disagregasi. Nilai yang berlaku adalah "proportions_of_historical_average" atau "average_historical_proportions".
max_nodes Jumlah simpul komputasi yang akan digunakan dalam pekerjaan pelatihan
max_concurrency_per_node Jumlah proses AutoML yang akan dijalankan pada setiap simpul. Oleh karena itu, konkurensi total pekerjaan HTS adalah max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Banyak komponen model habis yang diberikan dalam jumlah detik.
forecast_mode Mode inferensi untuk evaluasi model. Nilai yang valid adalah "recursive" dan "rolling". Lihat artikel evaluasi model untuk informasi selengkapnya.
forecast_step Ukuran langkah untuk perkiraan bergulir. Lihat artikel evaluasi model untuk informasi selengkapnya. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get a credential for access to the AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if we can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get a HTS training component
hts_train_component = ml_client_registry.components.get(
    name='automl_hts_training',
    version='latest'
)

# Get a HTS inference component
hts_inference_component = ml_client_registry.components.get(
    name='automl_hts_inference',
    version='latest'
)

# Get a component for computing evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML HTS Forecasting Pipeline")
def hts_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    forecast_mode="rolling",
    forecast_step=1,
    forecast_level="SKU",
    allocation_method='proportions_of_historical_average'
):
    hts_train = hts_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        max_nodes=max_nodes
    )
    hts_inference = hts_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=hts_train.outputs.run_output,
        forecast_level=forecast_level,
        allocation_method=allocation_method,
        forecast_mode=forecast_mode,
        forecast_step=forecast_step
    )
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=hts_inference.outputs.evaluation_data,
        ground_truth=hts_inference.outputs.evaluation_data,
        evaluation_config=hts_inference.outputs.evaluation_configs
    )

    # Return the metrics results from the rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Sekarang, kami membangun alur melalui fungsi pabrik, dengan asumsi data pelatihan dan pengujian berada di folder lokal, ./data/train dan ./data/test, masing-masing. Terakhir, kami mengatur komputasi default dan mengirimkan pekerjaan seperti dalam sampel berikut:

pipeline_job = hts_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_hts.yml"
    )
)
pipeline_job.settings.default_compute = "cluster-name"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Setelah pekerjaan selesai, metrik evaluasi dapat diunduh secara lokal menggunakan prosedur yang sama seperti dalam alur eksekusi pelatihan tunggal.

Lihat juga prakiraan permintaan dengan notebook rangkaian waktu hierarkis untuk contoh yang lebih rinci.

Catatan

Komponen pelatihan dan inferensi HTS secara kondisional mempartisi data Anda sesuai dengan hierarchy_column_names pengaturan sehingga setiap partisi berada dalam filenya sendiri. Proses ini bisa sangat lambat atau gagal ketika data sangat besar. Dalam hal ini, sebaiknya partisi data Anda secara manual sebelum menjalankan pelatihan atau inferensi HTS.

Prakiraan dalam skala besar: pelatihan DNN terdistribusi

  • Untuk mempelajari cara kerja pelatihan terdistribusi untuk tugas prakiraan, lihat artikel prakiraan dalam skala besar.
  • Lihat bagian artikel pelatihan terdistribusi penyiapan kami untuk data tabular untuk sampel kode.

Contoh buku catatan

Lihat buku catatan contoh perkiraan untuk rincian contoh kode konfigurasi perkiraan tingkat lanjut termasuk:

Langkah berikutnya