Bagikan melalui

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

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

Pembelajaran mesin otomatis (AutoML) di Azure Pembelajaran Mesin menggunakan model pembelajaran mesin standar bersama dengan model rangkaian waktu terkenal untuk membuat prakiraan. Pendekatan ini menggabungkan informasi historis tentang variabel target dengan fitur yang disediakan pengguna dalam data input dan fitur yang direkayasa secara otomatis. Algoritma pencarian model membantu mengidentifikasi model dengan akurasi prediktif terbaik. Untuk informasi selengkapnya, lihat metodologi prakiraan dan pembersihan dan pemilihan model.

Artikel ini menjelaskan cara menyiapkan AutoML untuk prakiraan rangkaian waktu dengan Pembelajaran Mesin dengan menggunakan Azure Pembelajaran Mesin Python SDK](/python/api/overview/azure/ai-ml-readme). Proses ini termasuk menyiapkan data untuk pelatihan dan mengonfigurasi parameter rangkaian waktu dalam pekerjaan prakiraan (referensi kelas). Anda kemudian melatih, menyimpulkan, dan mengevaluasi model dengan menggunakan komponen dan alur.

Untuk pengalaman kode rendah, lihat Tutorial: Prakiraan permintaan dengan pembelajaran mesin otomatis. Sumber daya ini adalah contoh prakiraan rangkaian waktu yang menggunakan AutoML di studio Azure Pembelajaran Mesin.

Prasyarat

Menyiapkan 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 untuk mewakili sumbu waktu dan kolom target untuk kuantitas yang akan diprakirakan. Kolom lain dapat berfungsi sebagai prediktor. Untuk informasi selengkapnya, lihat Cara AutoML menggunakan data Anda.

Penting

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

Pertimbangkan fitur untuk harga saham saat ini, yang dapat secara besar-besaran meningkatkan akurasi pelatihan. Jika Anda memperkirakan dengan cakrawala yang panjang, Anda mungkin tidak dapat memprediksi nilai saham di masa mendatang secara akurat yang sesuai dengan titik rangkaian waktu di masa mendatang. Pendekatan ini dapat mengurangi akurasi model.

Pekerjaan prakiraan AutoML mengharuskan data pelatihan Anda diwakili sebagai MLTable objek. Objek MLTable menentukan sumber data dan langkah-langkah untuk memuat data. Untuk informasi selengkapnya dan kasus penggunaan, lihat [Bekerja dengan tabel(how-to-mltable.md).

Untuk contoh berikut, misalkan data pelatihan Anda terkandung dalam file CSV di direktori lokal, ./train_data/timeseries_train.csv.

Anda dapat membuat objek dengan menggunakan MLTable yang dapat diubah seperti yang ditunjukkan 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.

Untuk memulai pekerjaan pelatihan, tentukan objek data input dengan menggunakan 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. Buat MLTable objek dan tentukan 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. Untuk informasi selengkapnya, lihat sumber daya berikut:

Membuat komputasi untuk menjalankan eksperimen

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

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

Contoh berikut menunjukkan cara 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

# Set forecasting variables
# As needed, modify the variable values to run the snippet 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",
)

# Set optional limits
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Pengaturan pekerjaan prakiraan

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. 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. Ketika kolom ini dikelompokkan, kolom tersebut 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 bahwa data berisi kolom bernama penyimpanan dan merek:

# 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 berikut.

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.

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 yang ditunjukkan dalam contoh berikut:

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

Dalam skenario ini, pekerjaan prakiraan hanya mencari melalui kelas model Exponential Smoothing dan Elastic Net. Untuk menghapus sekumpulan kelas model tertentu dari ruang pencarian, gunakan seperti yang blocked_training_algorithms ditunjukkan dalam contoh berikut:

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

Pekerjaan mencari di semua kelas model kecuali Prophet. Untuk daftar prakiraan nama model yang diterima di allowed_training_algorithms dan blocked_training_algorithms, lihat properti pelatihan. Anda dapat menerapkan baik tetapi tidak baik allowed_training_algorithms dan blocked_training_algorithms untuk eksekusi pelatihan.

Mengaktifkan pembelajaran untuk jaringan neural mendalam

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

Diagram yang menunjukkan komponen utama model AutoML TCNForecaster.

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, rekomendasinya adalah mendistribusikan setiap uji coba TCNForecaster melalui beberapa core/GPU dan simpul. Untuk informasi selengkapnya dan sampel kode, lihat pelatihan terdistribusi.

Untuk mengaktifkan DNN untuk eksperimen AutoML yang dibuat di studio Azure Pembelajaran Mesin, lihat pengaturan jenis tugas di panduan 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 Azure Databricks.
  • Pendekatan yang disarankan adalah menggunakan jenis komputasi GPU 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 dengan 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 informasi dan contoh selengkapnya, lihat fitur Lag untuk prakiraan rangkaian waktu di AutoML.

Diagram tabel dengan data yang memperlihatkan jendela bergulir target dan nilai di kolom Permintaan disorot.

Anda dapat mengaktifkan fitur agregasi jendela jeda dan bergulir untuk target dengan mengatur ukuran jendela bergulir dan urutan jeda yang ingin Anda buat. Ukuran jendela adalah tiga dalam contoh sebelumnya. Anda juga dapat mengaktifkan lag untuk fitur dengan feature_lags pengaturan . Dalam contoh berikut, semua pengaturan ini diatur ke auto untuk menginstruksikan AutoML untuk 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

AutoML menganggap rangkaian waktu sebagai seri pendek jika tidak ada cukup poin data untuk melakukan fase pelatihan dan validasi pengembangan model. Untuk informasi selengkapnya, lihat persyaratan panjang data pelatihan.

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

Pengaturan Deskripsi Catatan
auto Nilai default untuk penanganan seri pendek. - Jika semua seri pendek, pad data.
- Jika tidak semua seri pendek, hilangkan seri pendek.
pad short_series_handling_config = pad Jika pengaturan digunakan, AutoML menambahkan nilai acak ke setiap seri pendek yang ditemukan. AutoML mengalihkan kolom target dengan kebisingan putih. Anda bisa menggunakan jenis kolom berikut dengan padding yang ditentukan:
- Kolom objek, pad dengan NaNs
- Kolom numerik, pad dengan 0 (nol)
- Kolom Boolean/logika, pad dengan False
drop short_series_handling_config = drop Jika pengaturan digunakan, AutoML menghilangkan seri pendek, dan tidak digunakan untuk pelatihan atau prediksi. Prediksi untuk pengembalian NaNseri ini .
None Tidak ada seri yang diisi atau dihilangkan.

Contoh berikut 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'
)

Perhatian

Padding dapat memengaruhi akurasi model yang dihasilkan karena memperkenalkan data buatan untuk menghindari kegagalan pelatihan. Jika banyak seri pendek, Anda mungkin juga melihat beberapa dampak dalam hasil penjelasan.

Frekuensi dan agregasi data 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 skenario 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. Tabel berikut ini memperlihatkan nilai yang didukung untuk fungsi agregasi:

Fungsi Deskripsi
sum  Jumlah nilai target
mean  Rata-rata atau rata-rata nilai target
min Nilai minimum target
max Nilai maksimum target

AutoML menerapkan agregasi untuk kolom berikut:

Kolom Metode agregasi
Prediktor numerik AutoML menggunakan sumfungsi , mean, min, dan max . Ini menghasilkan kolom baru, di mana setiap nama kolom menyertakan akhiran yang mengidentifikasi nama fungsi agregasi yang diterapkan ke nilai kolom.
Prediktor kategoris AutoML menggunakan nilai forecast_mode parameter untuk mengagregasi data. Ini adalah kategori yang paling menonjol di jendela. Untuk informasi selengkapnya, lihat deskripsi parameter di bagian Alur banyak model dan alur HTS.
Prediktor data AutoML menggunakan nilai target minimum (min), nilai target maksimum (max), dan forecast_mode pengaturan parameter untuk mengagregasi data.
Sasaran AutoML mengagregasi nilai sesuai dengan operasi yang ditentukan. Biasanya, sum fungsi ini sesuai untuk sebagian besar skenario.

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. Sesuaikan jumlah lipatan dengan parameter n_cross_validations , dan konfigurasikan parameter cv_step_size untuk menentukan offset waktu di antara lipatan. Untuk informasi selengkapnya, lihat pemilihan model prakiraan.

Secara default, AutoML mengatur kedua pengaturan secara otomatis berdasarkan karakteristik data Anda. 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 nilai-nilai 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. Untuk informasi selengkapnya, lihat rekayasa fitur otomatis. Beberapa langkah pra-pemrosesan dapat disesuaikan dengan menggunakan konfigurasi fiturisasi pekerjaan prakiraan.

Tabel berikut mencantumkan kustomisasi yang didukung untuk prakiraan:

Penyesuaian Deskripsi Opsi
Pembaruan tujuan kolom Mengganti jenis fitur yang terdeteksi otomatis untuk kolom yang ditentukan. categorical, , dateTimenumeric
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, on sale bendera, 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 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 Pembelajaran Mesin untuk eksperimen Anda, lihat Mengonfigurasi pengaturan fiturisasi di studio.

Mengirimkan pekerjaan prakiraan

Setelah mengonfigurasi semua pengaturan, Anda siap untuk menjalankan pekerjaan prakiraan. Contoh berikut menunjukkan proses ini.

# 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 studio UI
returned_job.services["Studio"].endpoint

Setelah Anda mengirimkan pekerjaan, AutoML menyediakan sumber daya komputasi, menerapkan fiturisasi dan langkah-langkah persiapan lainnya untuk data input, dan mulai menyapu model prakiraan. Untuk informasi selengkapnya, lihat metodologi prakiraan dalam Pembersihan dan pemilihan AutoML dan Model untuk prakiraan di AutoML.

Mengatur pelatihan, inferensi, dan evaluasi dengan komponen dan alur

Alur kerja pembelajaran mesin 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 Azure Pembelajaran Mesin bersama dengan pekerjaan pelatihan. Untuk mendukung tugas inferensi dan evaluasi, Azure Pembelajaran Mesin menyediakan komponen, yang merupakan bagian kode mandiri yang melakukan satu langkah dalam alur Azure Pembelajaran Mesin.

Dalam contoh berikut, ambil kode komponen dari registri klien:

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

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

# Create client to access assets in AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create client to access assets in AzureML registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

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

# Get component to compute evaluation metrics from registry
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

Selanjutnya, tentukan fungsi pabrik yang membuat alur yang mengatur pelatihan, inferensi, dan komputasi metrik. Untuk informasi selengkapnya, lihat Mengonfigurasi eksperimen.

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 training node of 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 inference node to make rolling forecasts on 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',
        step=1
    )

    # Configure 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 dictionary with evaluation metrics and raw test set forecasts
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Tentukan melatih dan menguji input data yang 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, buat alur, atur komputasi defaultnya, dan kirimkan 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 pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

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

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

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

Anda dapat meninjau output di lokasi berikut:

  • Metrik: ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Prakiraan: ./named-outputs/rolling_fcst_result/inference_output_file (format baris JSON)

Untuk informasi selengkapnya tentang evaluasi bergulir, lihat Inferensi dan evaluasi model prakiraan.

Prakiraan dalam skala besar: Banyak model

Banyaknya komponen model di AutoML memungkinkan Anda melatih dan mengelola jutaan model secara paralel. Untuk informasi selengkapnya tentang banyak konsep model, lihat 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 memiliki spesifikasi yang sama dengan pekerjaan perintah Prakiraan ditambah partition_column_names parameter dan allow_multi_partitions .

Pengaturan 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.

Contoh berikut menyediakan contoh konfigurasi YAML:

$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, konfigurasi disimpan di jalur, ./automl_settings_mm.yml'.

Banyak alur model

Selanjutnya, tentukan fungsi pabrik yang membuat alur untuk orkestrasi banyak pelatihan model, inferensi, dan komputasi metrik. Tabel berikut menjelaskan parameter untuk fungsi pabrik ini:

Pengaturan 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 batas waktu komponen model yang ditentukan dalam jumlah detik.
retrain_failed_models Bendera untuk mengaktifkan pelatihan ulang untuk model yang gagal. Nilai ini berguna jika Anda melakukan banyak model sebelumnya yang berjalan yang mengakibatkan pekerjaan AutoML gagal pada beberapa partisi data. Saat Anda mengaktifkan bendera ini, banyak model hanya meluncurkan pekerjaan pelatihan untuk partisi yang sebelumnya gagal.
forecast_mode Mode inferensi untuk evaluasi model. Nilai yang valid adalah recursive (default) dan rolling. Untuk informasi selengkapnya, lihat Inferensi dan evaluasi model prakiraan dan referensi Kelas ManyModelsInferenceParameters.
step Ukuran langkah untuk prakiraan bergulir (defaultnya adalah 1). Untuk informasi selengkapnya, lihat Inferensi dan evaluasi model prakiraan dan referensi Kelas ManyModelsInferenceParameters.

Contoh berikut menunjukkan metode pabrik untuk membangun banyak pelatihan model dan alur evaluasi model:

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

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

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

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

# Get component to compute 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,
        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 metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Buat alur dengan fungsi pabrik. Data pelatihan dan pengujian masing-masing berada di folder lokal ./data/train dan ./data/test. Terakhir, atur komputasi default dan kirimkan pekerjaan seperti yang ditunjukkan dalam contoh 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, Anda dapat mengunduh metrik evaluasi secara lokal dengan menggunakan prosedur yang sama seperti dalam alur eksekusi pelatihan tunggal.

Untuk contoh yang lebih rinci, lihat prakiraan permintaan dengan banyak buku catatan model.

Pertimbangan pelatihan untuk banyak model yang dijalankan

  • Banyak komponen pelatihan dan inferensi model secara kondisional mempartisi data Anda sesuai dengan partition_column_names pengaturan. Proses ini menghasilkan setiap partisi berada dalam filenya sendiri. Prosesnya bisa sangat lambat atau gagal ketika data sangat besar. Rekomendasinya adalah mempartisi data Anda secara manual sebelum Anda menjalankan banyak pelatihan atau inferensi model.

  • Selama banyak pelatihan model, model secara otomatis terdaftar di ruang kerja, dan karenanya pendaftaran manual model tidak diperlukan. Model dinamai berdasarkan partisi tempat model dilatih dan ini tidak dapat disesuaikan. Sama untuk tag, ini tidak dapat disesuaikan, dan kami menggunakan properti ini untuk mendeteksi model secara otomatis selama inferensi.

  • Menyebarkan model individual sama sekali tidak dapat diskalakan, dan karenanya kami menyediakan PipelineComponentBatchDeployment untuk memudahkan proses penyebaran. Silakan lihat prakiraan permintaan dengan banyak buku catatan model untuk melihat tindakan ini.

  • Selama inferensi, model yang sesuai (versi terbaru) secara otomatis dipilih berdasarkan partisi yang dikirim dalam data inferensi. Secara default, model terbaru dipilih dari eksperimen dengan menyediakan training_experiment_name tetapi Anda dapat mengambil alih untuk memilih model dari pelatihan tertentu yang dijalankan dengan juga menyediakan train_run_id.

Catatan

Batas paralelisme default untuk banyak model yang dijalankan dalam langganan diatur ke 320. Jika beban kerja Anda memerlukan batas yang lebih tinggi, Anda dapat menghubungi dukungan Microsoft.

Prakiraan dalam skala besar: Rangkaian waktu hierarkis

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

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 perintah Prakiraan ditambah parameter lain yang terkait dengan informasi hierarki:

Pengaturan 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 menentukan tingkat hierarki daun, atau yang paling tidak diagregasi.
hierarchy_training_level Tingkat hierarki yang digunakan untuk pelatihan model prakiraan.

Contoh berikut menyediakan contoh konfigurasi YAML:

$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, konfigurasi disimpan di jalur, ./automl_settings_hts.yml.

Alur HTS

Selanjutnya, tentukan fungsi pabrik yang membuat alur untuk orkestrasi pelatihan, inferensi, dan komputasi metrik HTS. Tabel berikut menjelaskan parameter untuk fungsi pabrik ini:

Pengaturan 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 batas waktu komponen model yang ditentukan dalam jumlah detik.
forecast_mode Mode inferensi untuk evaluasi model. Nilai yang berlaku adalah recursive atau rolling. Untuk informasi selengkapnya, lihat Inferensi dan evaluasi model prakiraan dan referensi Kelas HTSInferenceParameters.
step Ukuran langkah untuk prakiraan bergulir (defaultnya adalah 1). Untuk informasi selengkapnya, lihat Inferensi dan evaluasi model prakiraan dan referensi Kelas HTSInferenceParameters. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

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

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

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

# Get component to compute 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,
        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 metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Buat alur dengan menggunakan fungsi pabrik. Data pelatihan dan pengujian masing-masing berada di folder lokal ./data/train dan ./data/test. Terakhir, atur komputasi default dan kirimkan pekerjaan seperti yang ditunjukkan dalam contoh 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 dengan menggunakan prosedur yang sama seperti dalam alur eksekusi pelatihan tunggal.

Untuk contoh yang lebih rinci, lihat prakiraan permintaan dengan buku catatan rangkaian waktu hierarkis.

Pertimbangan pelatihan untuk eksekusi HTS

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. Pendekatan yang disarankan adalah mempartisi data Anda secara manual sebelum Anda menjalankan pelatihan atau inferensi HTS.

Catatan

Batas paralelisme default untuk HTS yang dijalankan dalam langganan diatur ke 320. Jika beban kerja Anda memerlukan batas yang lebih tinggi, Anda dapat menghubungi dukungan Microsoft.

Prakiraan dalam skala besar: Pelatihan DNN terdistribusi

Seperti yang dijelaskan sebelumnya dalam artikel ini, Anda dapat mengaktifkan pembelajaran untuk jaringan neural mendalam (DNN). Untuk mempelajari cara kerja pelatihan terdistribusi untuk tugas prakiraan DNN, lihat Pelatihan jaringan neural mendalam terdistribusi (pratinjau).

Untuk skenario dengan persyaratan data besar, pelatihan terdistribusi dengan AutoML tersedia untuk serangkaian model terbatas. Anda dapat menemukan informasi selengkapnya dan sampel kode di AutoML dalam skala besar: Pelatihan terdistribusi.

Menjelajahi contoh buku catatan

Sampel kode terperinci yang menunjukkan konfigurasi prakiraan tingkat lanjut tersedia di repositori GitHub Buku Catatan Sampel Prakiraan AutoML. Berikut adalah beberapa contoh buku catatan:

Konten terkait