Melihat kode pelatihan model ML otomatis (pratinjau)

Artikel
07/07/2022
12 menit untuk membaca

Penting

Fitur ini sedang 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.

Dalam artikel ini, Anda mempelajari cara melihat kode pelatihan yang dihasilkan dari model pelatihan pembelajaran mesin otomatis apa pun.

Pembuatan kode untuk model terlatih ML otomatis memungkinkan Anda melihat detail berikut yang digunakan ML otomatis guna melatih dan membuat model untuk proses tertentu.

Praproses data
Pemilihan algoritma
Fiturisasi
Hiperparameter

Anda dapat memilih model terlatih ML otomatis, yang direkomendasikan atau eksekusi turunan, dan melihat kode pelatihan Python yang dihasilkan yang membuat model spesifik tersebut.

Dengan kode pelatihan model yang dihasilkan, Anda dapat,

Mempelajari fiturisasi dan hiperparameter apa yang digunakan algoritma model.
Melacak/membuat versi/mengaudit model terlatih. Simpan kode berversi untuk melacak kode pelatihan spesifik mana yang digunakan dengan model yang akan disebarkan ke produksi.
Menyesuaikan kode pelatihan dengan mengubah hiperparameter atau menerapkan keterampilan/pengalaman algoritma dan ML, dan melatih kembali model baru dengan kode kustom Anda.

Anda dapat membuat kode untuk eksperimen ML otomatis dengan klasifikasi jenis tugas, regresi, dan prakiraan deret waktu.

Peringatan

Model visi komputer dan model berbasis pemrosesan bahasa alami di AutoML saat ini tidak mendukung pembuatan kode pelatihan model.

Diagram berikut mengilustrasikan bahwa Anda dapat mengaktifkan pembuatan kode untuk setiap model yang dibuat AutoML dari UI studio Azure Machine Learning atau dengan SDK Azure Machine Learning. Setelah Anda memilih model, Azure Machine Learning akan menyalin file kode yang digunakan untuk membuat model dan menampilkannya ke folder bersama notebook Anda. Dari sini, Anda dapat melihat dan menyesuaikan kode sesuai kebutuhan.

Diagram pembuatan kode

Prasyarat

Ruang kerja Azure Machine Learning. Untuk membuat ruang kerja, lihat Membuat ruang kerja Azure Machine Learning.
Dengan mengikuti artikel ini, Anda diasumsikan memiliki pemahaman akan penyiapan percobaan pembelajaran mesin otomatis. Ikuti tutorial atau cara melihat pola desain percobaan pembelajaran mesin otomatis utama.
Pembuatan kode ML otomatis hanya tersedia untuk eksperimen yang dijalankan di target komputasi Azure ML jarak jauh. Pembuatan kode tidak didukung untuk eksekusi lokal.
Untuk mengaktifkan pembuatan kode dengan SDK, Anda memiliki opsi berikut:
- Anda dapat menjalankan kode melalui notebook Jupyter di instans komputasi Azure Machine Learning, yang berisi SDK Azure ML terbaru yang sudah diinstal. Instans komputasi dilengkapi dengan lingkungan Conda siap pakai yang kompatibel dengan kemampuan pembuatan kode ML otomatis (pratinjau).
- Atau, Anda dapat membuat lingkungan Conda lokal baru di komputer lokal Anda, lalu menginstal Azure ML SDK terbaru. Cara menginstal SDK klien AutoML di lingkungan Conda dengan automl paket.

Pembuatan kode dengan SDK

Secara default, setiap model terlatih ML otomatis menghasilkan kode pelatihannya setelah pelatihan selesai. ML otomatis menyimpan kode ini di outputs/generated_code eksperimen untuk model spesifik tersebut. Anda dapat melihatnya di antarmuka pengguna studio Azure ML pada tab Output + log dari model yang dipilih.

Anda juga dapat secara eksplisit mengaktifkan pembuatan kode untuk eksperimen ML otomatis di objek AutoMLConfig dengan parameter enable_code_generation=True. Parameter ini harus ditetapkan sebelum mengirimkan eksperimen Anda.

Pastikan bahwa Anda memanggil experiment.submit() dari lingkungan Conda yang berisi SDK Azure ML terbaru dengan ML otomatis. Tindakan ini memastikan bahwa pembuatan kode dipicu dengan benar untuk eksperimen yang dijalankan di target komputasi jarak jauh.

config = AutoMLConfig( task="classification",
                       training_data=data,
                       label_column_name="label",
                       compute_target=compute_target,
                       enable_code_generation=True
                     )

Dalam beberapa kasus pemecahan masalah, Anda mungkin ingin menonaktifkan pembuatan kode. Sebelum mengirimkan eksperimen ML otomatis, Anda dapat menonaktifkan pembuatan kode di objek AutoMLConfig Anda dengan parameter enable_code_generation=False.

# Disabling Code Generation
config = AutoMLConfig( task="classification", 
                       training_data=data,
                       label_column_name="label",
                       compute_target=compute_target,
                       enable_code_generation=False
                     )

Ada dua file utama dengan kode yang dibuat,

script.py Ini adalah kode pelatihan model yang mungkin ingin Anda analisis dengan langkah-langkah fiturisasi, algoritma khusus yang digunakan, dan hiperparameter.
script_run_notebook.ipynb Notebook dengan kode boiler-plate untuk menjalankan kode pelatihan model (script.py) dalam komputasi AzureML melalui kelas SDK Azure ML seperti ScriptRunConfig.

Mendapatkan kode yang dibuat dan artefak model

Setelah pelatihan ML otomatis selesai, Anda bisa mendapatkan file script.py dan script_run_notebook.ipynb. Kode berikut mendapatkan eksekusi turunan terbaik dan mengunduh kedua file.


best_run = remote_run.get_best_child()

best_run.download_file("outputs/generated_code/script.py", "script.py")
best_run.download_file("outputs/generated_code/script_run_notebook.ipynb", "script_run_notebook.ipynb")

Anda juga dapat melihat kode yang dihasilkan dan menyiapkannya untuk penyesuaian kode melalui antarmuka pengguna studio Azure Machine Learning.

Untuk melakukannya, buka tab Model dari halaman eksekusi induk eksperimen ML otomatis. Setelah memilih salah satu model terlatih, Anda dapat memilih tombol Lihat kode yang dihasilkan (pratinjau). Tombol ini mengarahkan Anda ke ekstensi portal Notebook, tempat Anda dapat melihat, mengedit, dan menjalankan kode yang dihasilkan untuk model tertentu yang dipilih.

tampilan tab model yang dijalankan induk menghasilkan tombol kode

Atau, Anda juga dapat mengakses kode yang dihasilkan model dari bagian atas halaman eksekusi turunan setelah Anda membuka halaman eksekusi turunan model tertentu.

turunan menjalankan tampilan halaman yang dihasilkan tombol kode

script.py

File script.py berisi logika inti yang diperlukan untuk melatih model dengan hiperparameter yang digunakan sebelumnya. Meskipun ditujukan untuk dieksekusi dalam konteks eksekusi skrip Azure ML, dengan beberapa modifikasi, kode pelatihan model juga dapat dijalankan secara mandiri di lingkungan lokal Anda sendiri.

Skrip ini kurang lebih dapat dipecah menjadi beberapa bagian berikut: pemuatan data, penyiapan data, fiturisasi data, spesifikasi praprosesor/algoritma, dan pelatihan.

Pemuatan Data

Fungsi get_training_dataset() memuat himpunan data yang digunakan sebelumnya. Fungsi ini mengasumsikan bahwa skrip dijalankan dalam skrip AzureML yang dijalankan di ruang kerja yang sama dengan eksperimen asli.

def get_training_dataset(dataset_id):
    from azureml.core.dataset import Dataset
    from azureml.core.run import Run
    
    logger.info("Running get_training_dataset")
    ws = Run.get_context().experiment.workspace
    dataset = Dataset.get_by_id(workspace=ws, id=dataset_id)
    return dataset.to_pandas_dataframe()

Saat menjalankan sebagai bagian dari eksekusi skrip, Run.get_context().experiment.workspace mengambil ruang kerja yang benar. Namun, jika skrip ini dijalankan di dalam ruang kerja yang berbeda atau dijalankan secara lokal tanpa menggunakan ScriptRunConfig, Anda perlu memodifikasi skrip untuk menentukan secara eksplisit ruang kerja yang sesuai.

Setelah ruang kerja telah diambil, himpunan data asli diambil oleh ID-nya. Himpunan data lain dengan struktur yang sama persis juga dapat ditentukan oleh ID atau nama dengan get_by_id() atau get_by_name(). Anda nanti dapat menemukan ID di skrip, di bagian yang sama seperti kode berikut.

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--training_dataset_id', type=str, default='xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx', help='Default training dataset id is populated from the parent run')
    args = parser.parse_args()
    
    main(args.training_dataset_id)

Anda juga dapat memilih untuk mengganti seluruh fungsi ini dengan mekanisme pemuatan data Anda sendiri; satu-satunya batasan adalah bahwa nilai yang dikembalikan harus berupa kerangka data Pandas dan bahwa data harus memiliki bentuk yang sama seperti pada eksperimen awal.

Kode penyiapan data

Fungsi prepare_data() akan membersihkan data, membagi fitur dan kolom berat sampel, serta menyiapkan data untuk digunakan dalam pelatihan. Fungsi ini dapat bervariasi bergantung pada jenis himpunan data dan jenis tugas eksperimen: klasifikasi, regresi, atau prakiraan deret waktu.

Contoh berikut menunjukkan bahwa secara umum, kerangka data dari langkah pemuatan data diteruskan. Jika ditentukan sebelumnya, kolom label dan bobot sampel akan diekstraksi dan baris yang berisi NaN akan dikeluarkan dari data input.

def prepare_data(dataframe):
    from azureml.training.tabular.preprocessing import data_cleaning
    
    logger.info("Running prepare_data")
    label_column_name = 'y'
    
    # extract the features, target and sample weight arrays
    y = dataframe[label_column_name].values
    X = dataframe.drop([label_column_name], axis=1)
    sample_weights = None
    X, y, sample_weights = data_cleaning._remove_nan_rows_in_X_y(X, y, sample_weights,
     is_timeseries=False, target_column=label_column_name)
    
    return X, y, sample_weights

Jika ingin melakukan penyiapan data tambahan, Anda dapat melakukannya pada langkah ini dengan menambahkan kode penyiapan data kustom Anda.

Kode fiturisasi data

Fungsi generate_data_transformation_config() menentukan langkah fiturisasi dalam alur akhir scikit-learn. Fitur dari eksperimen asli direproduksi di sini, bersama dengan parameternya.

Misalnya, kemungkinan transformasi data yang dapat terjadi dalam fungsi ini dapat didasarkan pada imputer seperti, SimpleImputer() dan CatImputer(), atau transformator seperti StringCastTransformer() dan LabelEncoderTransformer().

Berikut ini adalah transformator jenis StringCastTransformer() yang dapat digunakan untuk mentransformasikan sekumpulan kolom. Dalam hal ini, set ditunjukkan oleh column_names.

def get_mapper_c6ba98(column_names):
    # ... Multiple imports to package dependencies, removed for simplicity ...
    
    definition = gen_features(
        columns=column_names,
        classes=[
            {
                'class': StringCastTransformer,
            },
            {
                'class': CountVectorizer,
                'analyzer': 'word',
                'binary': True,
                'decode_error': 'strict',
                'dtype': numpy.uint8,
                'encoding': 'utf-8',
                'input': 'content',
                'lowercase': True,
                'max_df': 1.0,
                'max_features': None,
                'min_df': 1,
                'ngram_range': (1, 1),
                'preprocessor': None,
                'stop_words': None,
                'strip_accents': None,
                'token_pattern': '(?u)\\b\\w\\w+\\b',
                'tokenizer': wrap_in_lst,
                'vocabulary': None,
            },
        ]
    )
    mapper = DataFrameMapper(features=definition, input_df=True, sparse=True)
    
    return mapper

Perlu diketahui jika Anda memiliki banyak kolom yang perlu menerapkan fiturisasi/transformasi yang sama (misalnya, 50 kolom dalam beberapa grup kolom), kolom tersebut ditangani dengan pengelompokan berdasarkan jenisnya.

Dalam contoh berikut, perhatikan bahwa setiap grup menerapkan pemeta unik. Pemeta ini kemudian diterapkan ke masing-masing kolom grup tersebut.

def generate_data_transformation_config():
    from sklearn.pipeline import FeatureUnion
    
    column_group_1 = [['id'], ['ps_reg_01'], ['ps_reg_02'], ['ps_reg_03'], ['ps_car_11_cat'], ['ps_car_12'], ['ps_car_13'], ['ps_car_14'], ['ps_car_15'], ['ps_calc_01'], ['ps_calc_02'], ['ps_calc_03']]
    
    column_group_2 = ['ps_ind_06_bin', 'ps_ind_07_bin', 'ps_ind_08_bin', 'ps_ind_09_bin', 'ps_ind_10_bin', 'ps_ind_11_bin', 'ps_ind_12_bin', 'ps_ind_13_bin', 'ps_ind_16_bin', 'ps_ind_17_bin', 'ps_ind_18_bin', 'ps_car_08_cat', 'ps_calc_15_bin', 'ps_calc_16_bin', 'ps_calc_17_bin', 'ps_calc_18_bin', 'ps_calc_19_bin', 'ps_calc_20_bin']
    
    column_group_3 = ['ps_ind_01', 'ps_ind_02_cat', 'ps_ind_03', 'ps_ind_04_cat', 'ps_ind_05_cat', 'ps_ind_14', 'ps_ind_15', 'ps_car_01_cat', 'ps_car_02_cat', 'ps_car_03_cat', 'ps_car_04_cat', 'ps_car_05_cat', 'ps_car_06_cat', 'ps_car_07_cat', 'ps_car_09_cat', 'ps_car_10_cat', 'ps_car_11', 'ps_calc_04', 'ps_calc_05', 'ps_calc_06', 'ps_calc_07', 'ps_calc_08', 'ps_calc_09', 'ps_calc_10', 'ps_calc_11', 'ps_calc_12', 'ps_calc_13', 'ps_calc_14']
    
    feature_union = FeatureUnion([
        ('mapper_ab1045', get_mapper_ab1045(column_group_1)),
        ('mapper_c6ba98', get_mapper_c6ba98(column_group_3)),
        ('mapper_9133f9', get_mapper_9133f9(column_group_2)),
    ])
    return feature_union

Dengan pendekatan ini, Anda dapat memiliki kode yang lebih ringkas, tanpa menyertakan blok kode transformator untuk setiap kolom, yang bisa sangat merepotkan bahkan ketika Anda memiliki puluhan atau ratusan kolom dalam himpunan data Anda.

Dengan tugas klasifikasi dan regresi, [FeatureUnion] digunakan untuk fitur. Untuk model prakiraan deret waktu, beberapa fitur yang sadar deret waktu dikumpulkan ke dalam alur scikit-learn, lalu dikemas dalam TimeSeriesTransformer. Setiap fiturisasi yang disediakan pengguna untuk model prakiraan deret waktu terjadi sebelum yang disediakan oleh ML otomatis.

Kode spesifikasi praprosesor

Fungsi generate_preprocessor_config(), jika ada, akan menentukan langkah prapemrosesan yang harus dilakukan setelah fiturisasi di jalur akhir scikit-learn.

Biasanya, langkah prapemrosesan ini hanya terdiri dari standarisasi/normalisasi data yang dilakukan dengan sklearn.preprocessing.

ML otomatis hanya menentukan langkah prapemrosesan untuk model regresi dan klasifikasi non-ansambel.

Berikut ini contoh kode praprosesor yang dihasilkan:

def generate_preprocessor_config():
    from sklearn.preprocessing import MaxAbsScaler
    
    preproc = MaxAbsScaler(
        copy=True
    )
    
    return preproc

Kode spesifikasi algoritma dan hiperparameter

Kode spesifikasi algoritma dan hiperparameter kemungkinan adalah yang paling diminati oleh banyak profesional ML.

Fungsi generate_algorithm_config() menentukan algoritma dan hiperparameter aktual untuk melatih model sebagai tahap terakhir dari alur scikit-learn akhir.

Contoh berikut menggunakan algoritma XGBoostClassifier dengan hiperparameter tertentu.

def generate_algorithm_config():
    from xgboost.sklearn import XGBClassifier
    
    algorithm = XGBClassifier(
        base_score=0.5,
        booster='gbtree',
        colsample_bylevel=1,
        colsample_bynode=1,
        colsample_bytree=1,
        gamma=0,
        learning_rate=0.1,
        max_delta_step=0,
        max_depth=3,
        min_child_weight=1,
        missing=numpy.nan,
        n_estimators=100,
        n_jobs=-1,
        nthread=None,
        objective='binary:logistic',
        random_state=0,
        reg_alpha=0,
        reg_lambda=1,
        scale_pos_weight=1,
        seed=None,
        silent=None,
        subsample=1,
        verbosity=0,
        tree_method='auto',
        verbose=-10
    )
    
    return algorithm

Kode yang dihasilkan dalam banyak kasus menggunakan paket dan kelas perangkat lunak sumber terbuka (OSS). Ada contoh ketika kelas pengemas menengah digunakan untuk menyederhanakan kode yang lebih kompleks. Misalnya, pengklasifikasi XGBoost dan pustaka lain yang umum digunakan seperti algoritma LightGBM atau Scikit-Learn dapat diterapkan.

Sebagai Profesional ML, Anda dapat menyesuaikan kode konfigurasi algoritma tersebut dengan mengubah hiperparameternya sesuai kebutuhan berdasarkan keahlian dan pengalaman Anda untuk algoritma tersebut dan masalah ML khusus Anda.

Untuk model ansambel, generate_preprocessor_config_N() (jika diperlukan) dan generate_algorithm_config_N() ditentukan untuk setiap learner dalam model ansambel, dengan N mewakili penempatan setiap learner dalam daftar model ansambel. Untuk model ansambel tumpukan, learner meta generate_algorithm_config_meta() ditentukan.

Kode pelatihan ujung ke ujung

Pembuatan kode memancarkan build_model_pipeline() dan train_model() untuk mendefinisikan alur scikit-learn dan untuk memanggil fit().

def build_model_pipeline():
    from sklearn.pipeline import Pipeline
    
    logger.info("Running build_model_pipeline")
    pipeline = Pipeline(
        steps=[
            ('featurization', generate_data_transformation_config()),
            ('preproc', generate_preprocessor_config()),
            ('model', generate_algorithm_config()),
        ]
    )
    
    return pipeline

Alur scikit-learn mencakup langkah fiturisasi, praprosesor (jika digunakan), dan algoritma atau model.

Untuk model prakiraan deret waktu, alur scikit-learn dikemas dalam ForecastingPipelineWrapper, yang memiliki beberapa logika tambahan yang diperlukan untuk menangani data deret waktu dengan benar bergantung pada algoritma yang diterapkan. Untuk semua jenis tugas, kami menggunakan PipelineWithYTransformer jika kolom label perlu dikodekan.

Setelah Anda memiliki alur scikit-Learn, yang tersisa untuk dipanggil adalah metode fit() untuk melatih model:

def train_model(X, y, sample_weights):
    
    logger.info("Running train_model")
    model_pipeline = build_model_pipeline()
    
    model = model_pipeline.fit(X, y)
    return model

Nilai pengembalian dari train_model() merupakan model yang dipasang/dilatih pada data input.

Kode utama yang menjalankan semua fungsi sebelumnya adalah sebagai berikut:

def main(training_dataset_id=None):
    from azureml.core.run import Run
    
    # The following code is for when running this code as part of an AzureML script run.
    run = Run.get_context()
    setup_instrumentation(run)
    
    df = get_training_dataset(training_dataset_id)
    X, y, sample_weights = prepare_data(df)
    split_ratio = 0.1
    try:
        (X_train, y_train, sample_weights_train), (X_valid, y_valid, sample_weights_valid) = split_dataset(X, y, sample_weights, split_ratio, should_stratify=True)
    except Exception:
        (X_train, y_train, sample_weights_train), (X_valid, y_valid, sample_weights_valid) = split_dataset(X, y, sample_weights, split_ratio, should_stratify=False)

    model = train_model(X_train, y_train, sample_weights_train)
    
    metrics = calculate_metrics(model, X, y, sample_weights, X_test=X_valid, y_test=y_valid)
    
    print(metrics)
    for metric in metrics:
        run.log(metric, metrics[metric])

Setelah memiliki model terlatih, Anda dapat menggunakannya untuk membuat prediksi dengan metode predict(). Jika eksperimen Anda digunakan untuk model deret waktu, gunakan metode forecast() untuk prediksi.

y_pred = model.predict(X)

Terakhir, model akan diserialkan dan disimpan sebagai file .pkl bernama "model.pkl":

    with open('model.pkl', 'wb') as f:
        pickle.dump(model, f)
    run.upload_file('outputs/model.pkl', 'model.pkl')

script_run_notebook.ipynb

Notebook script_run_notebook.ipynb berfungsi sebagai cara mudah untuk mengeksekusi script.py pada komputasi ML Azure. Notebook ini mirip dengan notebook sampel ML otomatis yang ada, namun ada beberapa perbedaan utama seperti yang dijelaskan di bagian berikut.

Lingkungan

Biasanya, lingkungan pelatihan untuk menjalankan ML otomatis diatur secara otomatis oleh SDK. Namun, saat menjalankan skrip khusus yang dijalankan seperti kode yang dihasilkan, ML otomatis tidak lagi menjalankan proses, sehingga lingkungan harus ditentukan agar skrip dapat berjalan dengan sukses.

Pembuatan kode menggunakan kembali lingkungan yang digunakan dalam eksperimen ML otomatis asli, jika memungkinkan. Tindakan ini akan menjamin eksekusi skrip pelatihan tidak gagal akibat dependensi yang hilang, dan memiliki keuntungan sampingan karena tidak memerlukan pembangunan kembali citra Docker, yang menghemat waktu dan sumber daya komputasi.

Jika membuat perubahan pada script.py yang memerlukan dependensi tambahan, atau ingin menggunakan lingkungan Anda sendiri, Anda perlu memperbarui sel Create environment di script_run_notebook.ipynb yang sesuai.

Untuk informasi selengkapnya tentang lingkungan AzureML, baca dokumentasi kelas Lingkungan.

Mengirim eksperimen

Karena kode yang dihasilkan tidak lagi didorong oleh ML otomatis, alih-alih membuat AutoMLConfig dan meneruskannya ke experiment.submit(), Anda perlu membuat ScriptRunConfig dan memberikan kode yang dihasilkan (script.py) ke dalamnya.

Contoh berikut berisi parameter dan dependensi reguler yang diperlukan untuk menjalankan ScriptRunConfig, seperti komputasi, lingkungan, dll. Untuk informasi selengkapnya tentang cara menggunakan ScriptRunConfig, lihat Mengonfigurasi dan mengirimkan proses pelatihan.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder, 
                      script='script.py', 
                      compute_target=cpu_cluster, 
                      environment=myenv,
                      docker_runtime_config=docker_config)
 
run = experiment.submit(config=src)

Mengunduh dan memuat model terlatih serial dalam memori

Setelah memiliki model terlatih, Anda dapat menyimpan/membuat serial ke file .pkl dengan pickle.dump() dan pickle.load(). Anda juga dapat menggunakan joblib.dump() dan joblib.load().

Contoh berikut adalah cara mengunduh dan memuat model dalam memori yang dilatih dalam komputasi AzureML dengan ScriptRunConfig. Kode ini dapat berjalan di notebook yang sama dengan yang Anda gunakan SDK Azure ML ScriptRunConfig.

import joblib

# Load the fitted model from the script run.

# Note that if training dependencies are not installed on the machine
# this notebook is being run from, this step can fail.
try:
    # Download the model from the run in the Workspace
    run.download_file("outputs/model.pkl", "model.pkl")

    # Load the model into memory
    model = joblib.load("model.pkl")

except ImportError:
    print('Required dependencies are missing; please run pip install azureml-automl-runtime.')
    raise

Membuat prediksi dengan model dalam memori

Terakhir, Anda dapat memuat data uji dalam kerangka data Pandas dan menggunakan model untuk membuat prediksi.

import os
import numpy as np
import pandas as pd

DATA_DIR = "."
filepath = os.path.join(DATA_DIR, 'porto_seguro_safe_driver_test_dataset.csv')

test_data_df = pd.read_csv(filepath)

print(test_data_df.shape)
test_data_df.head(5)

#test_data_df is a Pandas dataframe with test data
y_predictions = model.predict(test_data_df)

Dalam instans komputasi Azure ML, Anda memiliki semua dependensi ML otomatis untuk memuat model dan memprediksi dari notebook mana pun dalam instans komputasi yang baru dibuat.

Namun, untuk memuat model tersebut di notebook dalam lingkungan Conda lokal kustom Anda, Anda harus memiliki semua dependensi yang berasal dari lingkungan yang digunakan saat pelatihan (lingkungan AutoML) diinstal.

Langkah berikutnya

Pelajari selengkapnya tentang cara dan tempat menerapkan model.
Lihat cara mengaktifkan fitur interpretabilitas khususnya dalam eksperimen ML otomatis.