Bagikan melalui

Gunakan ML otomatis di alur Azure Machine Learning di Python

  • Artikel

BERLAKU UNTUK: Python SDK azureml v1

Kemampuan ML otomatis Azure Machine Learning membantu Anda menemukan model berkinerja tinggi tanpa Anda menerapkan kembali setiap pendekatan yang mungkin ada. Dikombinasikan dengan alur Azure Machine Learning, Anda dapat membuat alur kerja yang dapat diterapkan yang dengan cepat dapat menemukan algoritma yang paling sesuai untuk data Anda. Artikel ini akan menunjukkan kepada Anda cara menggabungkan langkah persiapan data secara efisien dengan langkah ML otomatis. ML otomatis dapat dengan cepat menemukan algoritma yang paling cocok untuk data Anda, sambil memandu Anda ke MLOps dan operasionalisasi siklus hidup model dengan alur.

Prasyarat

Meninjau kelas pusat ML otomatis

ML otomatis dalam alur diwakili oleh sebuah AutoMLStep objek. Kelas AutoMLStep ini adalah subkelas dari PipelineStep. Grafik PipelineStep objek mendefinisikan sebuah Pipeline.

Ada beberapa subkelas dari PipelineStep. Selain AutoMLStep, artikel ini akan menunjukkan sebuah PythonScriptStep untuk persiapan data dan yang lain untuk mendaftarkan model.

Cara yang disukai untuk memindahkan data ke arus ML adalah dengan objek Dataset. Untuk memindahkan data antar langkah dan menyimpan output data dari proses, cara yang disukai adalah dengan objek OutputFileDatasetConfig dan OutputTabularDatasetConfig. Untuk digunakan dengan AutoMLStep, objek PipelineData harus diubah menjadi objek PipelineOutputTabularDataset. Untuk informasi selengkapnya, lihat Data input dan output dari arus ML.

AutoMLStep dikonfigurasi melalui objek AutoMLConfig. AutoMLConfig adalah kelas yang fleksibel, seperti yang dibahas dalam Mengkonfigurasi eksperimen ML otomatis di Python.

Sebuah Pipeline berjalan dalam sebuah Experiment. Arus Run memiliki, untuk setiap langkah, seorang anak StepRun. Output dari ML otomatis StepRun adalah metrik pelatihan dan model berkinerja tertinggi.

Untuk membuat hal-hal konkret, artikel ini membuat alur sederhana untuk tugas klasifikasi. Tugas ini memprediksi kelangsungan hidup Titanic, tetapi kita tidak akan membahas data atau tugas kecuali sambil lalu.

Memulai

Ambil set data awal

Seringkali, alur kerja ML dimulai dengan data garis dasar yang sudah ada sebelumnya. Ini adalah skenario yang baik untuk set data terdaftar. Set data terlihat di seluruh ruang kerja, pembuatan versi dukungan, dan dapat dieksplorasi secara interaktif. Ada banyak cara untuk membuat dan mengisi set data, seperti yang dibahas dalam Membuat set data Azure Machine Learning. Karena kita akan menggunakan Python SDK untuk membuat alur kami, gunakan SDK untuk mengunduh data garis dasar dan mendaftarkannya dengan nama 'titanic_ds'.

from azureml.core import Workspace, Dataset

ws = Workspace.from_config()
if not 'titanic_ds' in ws.datasets.keys() :
    # create a TabularDataset from Titanic training data
    web_paths = ['https://dprepdata.blob.core.windows.net/demo/Titanic.csv',
                 'https://dprepdata.blob.core.windows.net/demo/Titanic2.csv']
    titanic_ds = Dataset.Tabular.from_delimited_files(path=web_paths)

    titanic_ds.register(workspace = ws,
                                     name = 'titanic_ds',
                                     description = 'Titanic baseline data',
                                     create_new_version = True)

titanic_ds = Dataset.get_by_name(ws, 'titanic_ds')

Kode pertama kali masuk ke ruang kerja Azure Machine Learning yang didefinisikan config.jsaktif (untuk penjelasan, lihat Membuat file konfigurasi ruang kerja. Jika belum ada set data bernama 'titanic_ds' yang terdaftar, maka set data akan dibuat. Kode mengunduh data CSV dari Web, menggunakannya untuk membuat contoh satu TabularDataset lalu mendaftarkan set data kepada ruang kerja. Terakhir, fungsi Dataset.get_by_name() menetapkan Dataset ke titanic_ds.

Konfigurasikan penyimpanan Anda dan hitung target Anda

Sumber daya tambahan yang dibutuhkan alur adalah penyimpanan dan, umumnya, sumber daya komputasi Azure Machine Learning.

from azureml.core import Datastore
from azureml.core.compute import AmlCompute, ComputeTarget

datastore = ws.get_default_datastore()

compute_name = 'cpu-cluster'
if not compute_name in ws.compute_targets :
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2',
                                                                min_nodes=0,
                                                                max_nodes=1)
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)

    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=20)

    # Show the result
    print(compute_target.get_status().serialize())

compute_target = ws.compute_targets[compute_name]

Data perantara antara persiapan data dan langkah ML otomatis dapat disimpan di datastore default ruang kerja, jadi kita tidak perlu melakukan hal yang lebih selain memanggil get_default_datastore() pada objek Workspace.

Setelah itu, kode memeriksa apakah target 'cpu-cluster' komputasi Azure Pembelajaran Mesin sudah ada. Jika tidak, kami menentukan bahwa kami menginginkan target komputasi berbasis CPU kecil. Jika Anda berencana untuk menggunakan fitur pembelajaran mendalam ML otomatis (misalnya, fiturisasi teks dengan dukungan DNN) Anda harus memilih komputasi dengan dukungan GPU yang kuat, seperti yang dijelaskan dalam ukuran komputer virtual yang dioptimalkan GPU .

Kode memblokir sampai target disediakan dan kemudian mencetak beberapa detail target komputasi yang baru dibuat. Terakhir, target komputasi yang sudah dinamai diambil dari ruang kerja dan ditetapkan ke compute_target.

Mengonfigurasi eksekusi pelatihan

Konteks runtime diatur dengan membuat dan mengonfigurasi objek RunConfiguration. Di sini kita menetapkan target komputasi.

from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies

aml_run_config = RunConfiguration()
# Use just-specified compute target ("cpu-cluster")
aml_run_config.target = compute_target

# Specify CondaDependencies obj, add necessary packages
aml_run_config.environment.python.conda_dependencies = CondaDependencies.create(
    conda_packages=['pandas','scikit-learn'], 
    pip_packages=['azureml-sdk[automl]', 'pyarrow'])

Siapkan data untuk pembelajaran mesin otomatis

Tulis kode persiapan data

Set data Titanic dasar terdiri dari data numerik campuran dan teks, dengan beberapa nilai yang hilang. Untuk mempersiapkannya bagi pembelajaran mesin otomatis, langkah alur persiapan data adalah:

  • Isi data yang hilang dengan data acak atau kategori yang sesuai dengan "Tidak Diketahui"
  • Ubah data kategoris menjadi bilangan bulat
  • Letakkan kolom yang tidak ingin kita gunakan
  • Bagi data menjadi set pelatihan dan pengujian
  • Tulis data yang sudah ditransformasi ke OutputFileDatasetConfig jalur output
%%writefile dataprep.py
from azureml.core import Run

import pandas as pd 
import numpy as np 
import argparse

RANDOM_SEED=42

def prepare_age(df):
    # Fill in missing Age values from distribution of present Age values 
    mean = df["Age"].mean()
    std = df["Age"].std()
    is_null = df["Age"].isnull().sum()
    # compute enough (== is_null().sum()) random numbers between the mean, std
    rand_age = np.random.randint(mean - std, mean + std, size = is_null)
    # fill NaN values in Age column with random values generated
    age_slice = df["Age"].copy()
    age_slice[np.isnan(age_slice)] = rand_age
    df["Age"] = age_slice
    df["Age"] = df["Age"].astype(int)
    
    # Quantize age into 5 classes
    df['Age_Group'] = pd.qcut(df['Age'],5, labels=False)
    df.drop(['Age'], axis=1, inplace=True)
    return df

def prepare_fare(df):
    df['Fare'].fillna(0, inplace=True)
    df['Fare_Group'] = pd.qcut(df['Fare'],5,labels=False)
    df.drop(['Fare'], axis=1, inplace=True)
    return df 

def prepare_genders(df):
    genders = {"male": 0, "female": 1, "unknown": 2}
    df['Sex'] = df['Sex'].map(genders)
    df['Sex'].fillna(2, inplace=True)
    df['Sex'] = df['Sex'].astype(int)
    return df

def prepare_embarked(df):
    df['Embarked'].replace('', 'U', inplace=True)
    df['Embarked'].fillna('U', inplace=True)
    ports = {"S": 0, "C": 1, "Q": 2, "U": 3}
    df['Embarked'] = df['Embarked'].map(ports)
    return df
    
parser = argparse.ArgumentParser()
parser.add_argument('--output_path', dest='output_path', required=True)
args = parser.parse_args()
    
titanic_ds = Run.get_context().input_datasets['titanic_ds']
df = titanic_ds.to_pandas_dataframe().drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
df = prepare_embarked(prepare_genders(prepare_fare(prepare_age(df))))

df.to_csv(os.path.join(args.output_path,"prepped_data.csv"))

print(f"Wrote prepped data to {args.output_path}/prepped_data.csv")

Cuplikan kode di atas adalah contoh lengkap, namun minimal dari persiapan data untuk data Titanic. Cuplikan tersebut dimulai dengan "perintah sihir" Jupyter untuk menghasilkan kode bagi satu file. Jika Anda tidak menggunakan notebook Jupyter, hapus baris itu dan buat file secara manual.

Berbagai prepare_ fungsi dalam cuplikan di atas memodifikasi kolom yang relevan dalam set data input. Fungsi-fungsi ini bekerja pada data setelah diubah menjadi objek DataFrame Pandas. Dalam setiap kasus, data yang hilang diisi dengan data acak yang representatif atau data kategoris yang menunjukkan "Tidak diketahui". Data kategoris berbasis teks dipetakan ke bilangan bulat. Kolom yang tidak lagi diperlukan ditimpa atau dihilangkan.

Setelah kode mendefinisikan fungsi persiapan data, kode tersebut mengurai argumen input, yang merupakan jalur ke mana kita ingin menulis data kita. (Nilai-nilai ini akan ditentukan oleh objek OutputFileDatasetConfig yang akan dibahas pada langkah berikutnya.) Kode mengambil 'titanic_cs' Dataset yang sudah terdaftar, mengkonversinya ke Pandas DataFrame, dan memanggil berbagai fungsi persiapan data.

Karena output_path ini adalah direktori, panggilan untuk to_csv() menentukan nama file prepped_data.csv.

Tulis langkah alur persiapan data (PythonScriptStep)

Kode persiapan data yang dijelaskan di atas harus dikaitkan dengan objek PythonScripStep yang akan digunakan dengan alur. Jalur ke mana output CSV ditulis dihasilkan oleh objek OutputFileDatasetConfig. Sumber daya yang disiapkan sebelumnya, seperti ComputeTarget, RunConfig, dan 'titanic_ds' Dataset digunakan untuk melengkapi spesifikasi.

from azureml.data import OutputFileDatasetConfig
from azureml.pipeline.steps import PythonScriptStep

prepped_data_path = OutputFileDatasetConfig(name="output_path")

dataprep_step = PythonScriptStep(
    name="dataprep", 
    script_name="dataprep.py", 
    compute_target=compute_target, 
    runconfig=aml_run_config,
    arguments=["--output_path", prepped_data_path],
    inputs=[titanic_ds.as_named_input('titanic_ds')],
    allow_reuse=True
)

Objek prepped_data_path memiliki jenis OutputFileDatasetConfig yang mengarah pada direktori. Perhatikan bahwa objek ditentukan dalam parameter arguments. Jika Anda meninjau langkah sebelumnya, Anda akan melihat bahwa dalam kode persiapan data, nilai argumen '--output_path' adalah jalur direktori tempat file CSV ditulis.

Latih dengan AutoMLStep

Mengonfigurasi langkah alur ML otomatis dilakukan dengan kelas AutoMLConfig. Kelas fleksibel ini digambarkan pada Konfigurasikan eksperimen ML otomatis, seperti yang dibahas dalam Python . Input dan output data adalah satu-satunya aspek konfigurasi yang memerlukan perhatian khusus dalam alur ML. Input dan output untuk AutoMLConfig dalam alur dibahas secara rinci di bawah ini. Di luar data, keuntungan dari alur ML adalah kemampuan untuk menggunakan target komputasi yang berbeda untuk langkah yang berbeda. Anda mungkin memilih untuk menggunakan ComputeTarget yang lebih kuat hanya untuk proses ML otomatis. Melakukannya adalah sesederhana menetapkan RunConfiguration yang lebih kuat ke AutoMLConfig parameter run_configuration objek.

Kirim data ke AutoMLStep

Dalam alur ML, data input harus menjadi objek Dataset. Cara berkinerja tertinggi adalah dengan memberikan data input dalam bentuk objek OutputTabularDatasetConfig. Anda membuat objek dari jenis tersebut dengan read_delimited_files() pada OutputFileDatasetConfig, seperti prepped_data_path, seperti objek prepped_data_path.

# type(prepped_data) == OutputTabularDatasetConfig
prepped_data = prepped_data_path.read_delimited_files()

Opsi lain adalah menggunakan objek-objek Dataset yang terdaftar di ruang kerja:

prepped_data = Dataset.get_by_name(ws, 'Data_prepared')

Membandingkan dua teknik:

Teknik Manfaat dan kekurangan
OutputTabularDatasetConfig Performa yang lebih tinggi
Rute alami dari OutputFileDatasetConfig
Data tidak bertahan setelah jalannya alur
Terdaftar Dataset Performa lebih rendah
Dapat dihasilkan dengan banyak cara
Data tetap ada dan terlihat di seluruh ruang kerja
Notebook yang memperlihatkan teknik Dataset terdaftar

Tentukan output ML otomatis

Output dari AutoMLStep adalah skor metrik akhir dari model berkinerja lebih tinggi dan model itu sendiri. Untuk menggunakan output ini dalam langkah-langkah alur lebih lanjut, siapkan objek OutputFileDatasetConfig untuk menerimanya.

from azureml.pipeline.core import TrainingOutput, PipelineData

metrics_data = PipelineData(name='metrics_data',
                            datastore=datastore,
                            pipeline_output_name='metrics_output',
                            training_output=TrainingOutput(type='Metrics'))

model_data = PipelineData(name='best_model_data',
                          datastore=datastore,
                          pipeline_output_name='model_output',
                          training_output=TrainingOutput(type='Model'))

Cuplikan di atas menciptakan dua objek PipelineData untuk metrik dan output model. Masing-masing diberi nama, ditetapkan ke datastore default yang diambil sebelumnya, dan terkait dengan type dari TrainingOutput fileAutoMLStep. Karena kami menetapkan pipeline_output_name pada objek-objek PipelineData ini, nilai-nilainya akan tersedia tidak hanya dari langkah alur individu, tetapi dari alur secara keseluruhan, seperti yang akan dibahas di bawah ini di bagian "Periksa hasil alur."

Konfigurasikan dan buat langkah alur ML otomatis

Setelah input dan output ditentukan, saatnya untuk membuat AutoMLConfig dan AutoMLStep. Detail konfigurasi akan bergantung pada tugas Anda, seperti yang dijelaskan dalam Konfigurasikan eksperimen ML otomatis di Python. Untuk tugas klasifikasi kelangsungan Titanic, cuplikan berikut menunjukkan konfigurasi sederhana.

from azureml.train.automl import AutoMLConfig
from azureml.pipeline.steps import AutoMLStep

# Change iterations to a reasonable number (50) to get better accuracy
automl_settings = {
    "iteration_timeout_minutes" : 10,
    "iterations" : 2,
    "experiment_timeout_hours" : 0.25,
    "primary_metric" : 'AUC_weighted'
}

automl_config = AutoMLConfig(task = 'classification',
                             path = '.',
                             debug_log = 'automated_ml_errors.log',
                             compute_target = compute_target,
                             run_configuration = aml_run_config,
                             featurization = 'auto',
                             training_data = prepped_data,
                             label_column_name = 'Survived',
                             **automl_settings)

train_step = AutoMLStep(name='AutoML_Classification',
    automl_config=automl_config,
    passthru_automl_config=False,
    outputs=[metrics_data,model_data],
    enable_default_model_output=False,
    enable_default_metrics_output=False,
    allow_reuse=True)

Cuplikan menunjukkan idiom yang biasa digunakan dengan AutoMLConfig. Argumen-argumen yang lebih cair (hyperparameter-ish) ditentukan dalam kamus terpisah sementara nilai yang cenderung berubah ditentukan langsung di konstruktor AutoMLConfig. Dalam hal ini, automl_settings menentukan proses singkat: proses tersebut akan berhenti hanya setelah 2 iterasi atau 15 menit, mana yang lebih dulu.

Kamus automl_settings diteruskan ke konstruktor AutoMLConfig sebagai kwargs. Parameter lainnya tidak kompleks:

  • task diatur ke classification untuk contoh ini. Nilai lain yang valid adalah: regression dan forecasting
  • path dan debug_logmenjelaskan jalur ke proyek dan file lokal tempat informasi debug akan ditulis
  • compute_target didefinisikan sebelumnya compute_target yang, dalam contoh ini, adalah mesin berbasis CPU murah. Jika Anda menggunakan fasilitas Deep Learning AutoML, Anda ingin mengubah target komputasi menjadi berbasis GPU
  • featurization diatur ke auto. Detail lebih lanjut dapat ditemukan di bagian Fiturisasi Data pada dokumen konfigurasi ML otomatis
  • label_column_name menunjukkan kolom mana yang kami minati untuk memprediksi
  • training_data diatur ke objek OutputTabularDatasetConfig yang dibuat dari output langkah persiapan data

AutoMLStep sendiri mengambil AutoMLConfig dan memiliki, sebagai output, objek PipelineData yang dibuat untuk menahan metrik dan data model.

Penting

Anda harus mengatur enable_default_model_output dan enable_default_metrics_output ke True hanya jika Anda menggunakan AutoMLStepRun.

Dalam contoh ini, proses ML otomatis akan melakukan validasi silang pada training_data. Anda dapat mengontrol jumlah validasi silang dengan argumen n_cross_validations. Jika Anda sudah membagi data pelatihan sebagai bagian dari langkah-langkah persiapan data, Anda dapat mengaturvalidation_data sendiri Dataset.

Anda mungkin kadang-kadang melihat penggunaan X untuk fitur data dan y untuk label data. Teknik ini tidak digunakan lagi dan Anda harus menggunakan training_data untuk input.

Daftarkan model yang dihasilkan oleh ML otomatis

Langkah terakhir dalam alur ML sederhana adalah mendaftarkan model yang dibuat. Dengan menambahkan model ke registri model ruang kerja, model tersebut akan tersedia di portal dan dapat diversikan. Untuk mendaftarkan model, tulis PythonScriptStep yang lain yang mengambil output model_data dari AutoMLStep.

Tulis kode untuk mendaftarkan model

Model terdaftar dalam sebuah Workspace. Anda mungkin terbiasa menggunakan Workspace.from_config()untuk masuk ke ruang kerja di mesin lokal Anda, tetapi ada cara lain untuk mendapatkan ruang kerja dari dalam alur ML yang sedang berjalan. Run.get_context() mengambil Run aktif. Obyek run ini menyediakan akses ke banyak obyek penting, termasuk Workspace yang digunakan di sini.

%%writefile register_model.py
from azureml.core.model import Model, Dataset
from azureml.core.run import Run, _OfflineRun
from azureml.core import Workspace
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--model_name", required=True)
parser.add_argument("--model_path", required=True)
args = parser.parse_args()

print(f"model_name : {args.model_name}")
print(f"model_path: {args.model_path}")

run = Run.get_context()
ws = Workspace.from_config() if type(run) == _OfflineRun else run.experiment.workspace

model = Model.register(workspace=ws,
                       model_path=args.model_path,
                       model_name=args.model_name)

print("Registered version {0} of model {1}".format(model.version, model.name))

Tulis kode PythonScriptStep

Peringatan

Jika Anda menggunakan Azure Pembelajaran Mesin SDK v1, dan ruang kerja Anda dikonfigurasi untuk isolasi jaringan (VNet), Anda mungkin menerima kesalahan saat menjalankan langkah ini. Untuk informasi selengkapnya, lihat HyperdriveStep dan AutoMLStep gagal dengan isolasi jaringan.

PythonScriptStep pendaftar model menggunakan satu PipelineParameter untuk salah satu argumennya. Parameter alur adalah argumen ke alur yang dapat dengan mudah diatur pada waktu run-submission. Setelah dinyatakan, parameter-paramter tersebut diluluskan sebagai argumen normal.


from azureml.pipeline.core.graph import PipelineParameter

# The model name with which to register the trained model in the workspace.
model_name = PipelineParameter("model_name", default_value="TitanicSurvivalInitial")

register_step = PythonScriptStep(script_name="register_model.py",
                                       name="register_model",
                                       allow_reuse=False,
                                       arguments=["--model_name", model_name, "--model_path", model_data],
                                       inputs=[model_data],
                                       compute_target=compute_target,
                                       runconfig=aml_run_config)

Buat dan jalankan alur ML otomatis Anda

Membuat dan menjalankan sebuah alur yang berisi AutoMLStep tidak berbeda dengan alur normal.

from azureml.pipeline.core import Pipeline
from azureml.core import Experiment

pipeline = Pipeline(ws, [dataprep_step, train_step, register_step])

experiment = Experiment(workspace=ws, name='titanic_automl')

run = experiment.submit(pipeline, show_output=True)
run.wait_for_completion()

Kode di atas menggabungkan persiapan data, ML otomatis, dan langkah-langkah pendaftaran model ke dalam objek Pipeline. Kode tersebut kemudian membuat objek Experiment. Konstruktor Experiment akan mengambil eksperimen bernama jika ada atau membuatnya jika perlu. Konstruktor mengirimkan Pipeline ke Experiment, dengan membuat objek Run yang akan secara asinkron menjalankan alur. Fungsi wait_for_completion() memblokir hingga proses selesai.

Periksa hasil alur

Setelah run selesai, Anda dapat mengambil objek PipelineData yang telah ditetapkan sebagai pipeline_output_name. Anda dapat mengunduh hasilnya dan memuatnya untuk diproses lebih lanjut.

metrics_output_port = run.get_pipeline_output('metrics_output')
model_output_port = run.get_pipeline_output('model_output')

metrics_output_port.download('.', show_progress=True)
model_output_port.download('.', show_progress=True)

File yang diunduh ditulis ke subdirektori azureml/{run.id}/. File metrik berformat JSON dan dapat dikonversi menjadi dataframe Pandas untuk diperiksa.

Untuk pemrosesan lokal, Anda mungkin perlu menginstal paket yang relevan, seperti Pandas, Pickle, Azure Pembelajaran Mesin SDK, dan sebagainya. Untuk contoh ini, kemungkinan model terbaik yang ditemukan oleh ML otomatis akan tergantung pada XGBoost.

!pip install xgboost==0.90

import pandas as pd
import json

metrics_filename = metrics_output._path_on_datastore
# metrics_filename = path to downloaded file
with open(metrics_filename) as f:
   metrics_output_result = f.read()
   
deserialized_metrics_output = json.loads(metrics_output_result)
df = pd.DataFrame(deserialized_metrics_output)
df

Cuplikan kode di atas menunjukkan file metrik yang dimuat dari lokasinya di toko data Azure. Anda juga dapat memuatnya dari file yang diunduh, seperti yang ditunjukkan di komentar. Setelah Anda deserliasisasi dan mengonversinya menjadi Pandas DataFrame, Anda dapat melihat metrik terperinci untuk setiap iterasi langkah ML otomatis.

File model dapat dideserialisasi menjadi objek Model yang dapat Anda gunakan untuk menyimpulkan, analisis metrik lebih lanjut, dan sebagainya.

import pickle

model_filename = model_output._path_on_datastore
# model_filename = path to downloaded file

with open(model_filename, "rb" ) as f:
    best_model = pickle.load(f)

# ... inferencing code not shown ...

Untuk informasi selengkapnya tentang memuat dan bekerja dengan model yang sudah ada, lihat Gunakan model yang sudah ada dengan Azure Machine Learning.

Unduh hasil proses ML otomatis

Jika Anda telah mengikuti artikel, Anda akan memiliki objek run yang dipakai. Tetapi Anda juga dapat mengambil objek Run yang sudah lengkap dari Workspace dengan cara objek Experiment.

Ruang kerja berisi catatan lengkap semua eksperimen dan proses Anda. Anda dapat menggunakan portal untuk menemukan dan mengunduh output eksperimen atau menggunakan kode. Untuk mengakses catatan dari proses bersejarah, gunakan Azure Machine Learning untuk menemukan ID proses yang Anda minati. Dengan ID itu, Anda dapat memilih run yang spesifik dengan cara Workspace dan Experiment.

# Retrieved from Azure Machine Learning web UI
run_id = 'aaaaaaaa-bbbb-cccc-dddd-0123456789AB'
experiment = ws.experiments['titanic_automl']
run = next(run for run in ex.get_runs() if run.id == run_id)

Anda seharusnya mengubah string dalam kode di atas bagi rincian dari proses historis Anda. Cuplikan di atas mengasumsikan bahwa Anda telah menetapkan ws ke Workspace yang relevan dengan from_config() normal. Eksperimen minat langsung diambil dan kemudian kode menemukan Run minat dengan mencocokkan nilai run.id.

Setelah memiliki satu objek Run, Anda dapat mengunduh metrik dan model.

automl_run = next(r for r in run.get_children() if r.name == 'AutoML_Classification')
outputs = automl_run.get_outputs()
metrics = outputs['default_metrics_AutoML_Classification']
model = outputs['default_model_AutoML_Classification']

metrics.get_port_data_reference().download('.')
model.get_port_data_reference().download('.')

Setiap objek Run berisi objek-objek StepRun yang berisi informasi tentang masing-masing proses langkah alur. rundicari untuk objek StepRun untuk AutoMLStep. Metrik dan model diambil menggunakan nama defaultnya, yang tersedia meskipun Anda tidak meneruskan objek PipelineData ke parameter outputs dari AutoMLStep.

Terakhir, metrik dan model aktual diunduh ke mesin lokal Anda, seperti yang dibahas di bagian "Periksa hasil alur" di atas.

Langkah berikutnya