Bagikan melalui

Apa itu Azure Machine Learning SDK v1 untuk Python?

  • Artikel

Penting

Artikel ini berisi tentang Azure Machine Learning SDK v1, yang bukan SDK saat ini. Versi SDK saat ini adalah Azure Machine Learning Python SDK v2. Untuk informasi tentang perbedaan antara versi SDK, baca Tingkatkan ke v2.

Ilmuwan data dan pengembang AI menggunakan Azure Machine Learning SDK v1 untuk Python untuk membangun dan menjalankan alur kerja pembelajaran mesin dengan layanan Azure Machine Learning. Anda dapat berinteraksi dengan layanan di lingkungan Python apa pun, termasuk Jupyter Notebooks, Visual Studio Code, atau IDE Python favorit Anda.

Area utama SDK meliputi:

  • Jelajahi, siapkan, dan kelola siklus hidup himpunan data Anda yang digunakan dalam eksperimen pembelajaran mesin.
  • Kelola sumber daya cloud untuk memantau, mencatat, dan mengatur eksperimen pembelajaran mesin Anda.
  • Latih model baik secara lokal atau dengan menggunakan sumber daya cloud, termasuk pelatihan model yang dipercepat GPU.
  • Gunakan pembelajaran mesin otomatis, yang menerima parameter konfigurasi dan data pelatihan. Ini secara otomatis melakukan iterasi melalui algoritma dan pengaturan hiperparameter untuk menemukan model terbaik untuk menjalankan prediksi.
  • Sebarkan layanan web untuk mengonversi model terlatih Anda menjadi layanan RESTful yang dapat digunakan dalam aplikasi apa pun.

Untuk panduan langkah demi langkah tentang cara memulai, coba tutorial .

Bagian berikut adalah gambaran umum dari beberapa kelas terpenting di SDK, dan pola desain umum untuk menggunakannya. Untuk mendapatkan SDK, lihat panduan penginstalan .

Stabil vs eksperimental

Azure Machine Learning SDK untuk Python menyediakan fitur stabil dan eksperimental dalam SDK yang sama.

Status fitur/kemampuan Deskripsi
Fitur stabil Siap produksi

Fitur-fitur ini direkomendasikan untuk sebagian besar kasus penggunaan dan lingkungan produksi. Mereka diperbarui lebih jarang kemudian fitur eksperimental.
Fitur eksperimental Pengembangan

Fitur-fitur ini adalah kemampuan yang baru dikembangkan & pembaruan yang mungkin belum siap atau sepenuhnya diuji untuk penggunaan produksi. Meskipun fitur biasanya berfungsi, fitur tersebut dapat mencakup beberapa perubahan yang melanggar. Fitur eksperimental digunakan untuk menyerika bug pemecah SDK, dan hanya akan menerima pembaruan selama periode pengujian. Fitur eksperimental juga disebut sebagai fitur yang berada dalam pratinjau .

Seperti namanya, fitur eksperimental (pratinjau) adalah untuk bereksperimen dan tidak dianggap bebas bug atau stabil. Untuk alasan ini, kami hanya merekomendasikan fitur eksperimental kepada pengguna tingkat lanjut yang ingin mencoba versi awal kemampuan dan pembaruan, dan berniat untuk berpartisipasi dalam pelaporan bug dan gangguan.

Fitur eksperimental diberi label oleh bagian catatan di referensi SDK dan ditandai dengan teks seperti, (pratinjau) di seluruh dokumentasi Azure Machine Learning .

Workspace

namespace: azureml.core.workspace.Workspace

Kelas Workspace adalah sumber daya dasar di cloud yang Anda gunakan untuk bereksperimen, melatih, dan menyebarkan model pembelajaran mesin. Ini mengikat langganan Azure dan grup sumber daya Anda ke objek yang mudah digunakan.

Lihat semua parameter metode buat Ruang Kerja untuk menggunakan kembali instans yang ada (Storage, Key Vault, App-Insights, dan Azure Container Registry-ACR) serta mengubah pengaturan tambahan seperti konfigurasi titik akhir privat dan target komputasi.

Impor kelas dan buat ruang kerja baru dengan menggunakan kode berikut. Atur create_resource_group ke False jika Anda memiliki grup sumber daya Azure yang sudah ada sebelumnya yang ingin Anda gunakan untuk ruang kerja. Beberapa fungsi mungkin meminta kredensial autentikasi Azure.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Gunakan ruang kerja yang sama di beberapa lingkungan dengan terlebih dahulu menulisnya ke file JSON konfigurasi. Ini menyimpan data langganan, sumber daya, dan nama ruang kerja Anda.

ws.write_config(path="./file-path", file_name="ws_config.json")

Muat ruang kerja Anda dengan membaca file konfigurasi.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Atau, gunakan metode get() statis untuk memuat ruang kerja yang ada tanpa menggunakan file konfigurasi.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

Variabel ws mewakili objek Workspace dalam contoh kode berikut.

Percobaan

namespace: azureml.core.experiment.Experiment

Kelas Experiment adalah sumber daya cloud dasar lain yang mewakili kumpulan uji coba (model individual berjalan). Kode berikut mengambil objek Experiment dari dalam Workspace berdasarkan nama, atau membuat objek Experiment baru jika nama tidak ada.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Jalankan kode berikut untuk mendapatkan daftar semua objek Experiment yang terkandung dalam Workspace.

list_experiments = Experiment.list(ws)

Gunakan fungsi get_runs untuk mengambil daftar objek Run (uji coba) dari Experiment. Kode berikut mengambil eksekusi dan mencetak setiap ID eksekusi.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Ada dua cara untuk menjalankan percobaan eksperimen. Jika Anda bereksperimen secara interaktif di notebook Jupyter, gunakan fungsi start_logging. Jika Anda mengirimkan eksperimen dari lingkungan Python standar, gunakan fungsi submit. Kedua fungsi mengembalikan objek Run. Variabel experiment mewakili objek Experiment dalam contoh kode berikut.

Lari

namespace: azureml.core.run.Run

Eksekusi mewakili satu percobaan eksperimen. Run adalah objek yang Anda gunakan untuk memantau eksekusi asinkron uji coba, menyimpan output uji coba, menganalisis hasil, dan mengakses artefak yang dihasilkan. Anda menggunakan Run di dalam kode eksperimen untuk mencatat metrik dan artefak ke layanan Riwayat Eksekusi. Fungsionalitas meliputi:

  • Menyimpan dan mengambil metrik dan data.
  • Menggunakan tag dan hierarki anak untuk pencarian yang mudah dari eksekusi sebelumnya.
  • Mendaftarkan file model tersimpan untuk penyebaran.
  • Menyimpan, memodifikasi, dan mengambil properti eksekusi.

Buat objek dengan mengirimkan objek dengan objek konfigurasi eksekusi . Gunakan parameter tags untuk melampirkan kategori dan label kustom ke eksekusi Anda. Anda dapat dengan mudah menemukan dan mengambilnya nanti dari Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Gunakan fungsi list statis untuk mendapatkan daftar semua objek Run dari Experiment. Tentukan parameter tags untuk difilter menurut tag yang Anda buat sebelumnya.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Gunakan fungsi get_details untuk mengambil output terperinci untuk eksekusi.

run_details = run.get_details()

Output untuk fungsi ini adalah kamus yang mencakup:

  • ID Eksekusi
  • Keadaan
  • Waktu mulai dan berakhir
  • Target komputasi (lokal versus cloud)
  • Dependensi dan versi yang digunakan dalam proses
  • Data khusus pelatihan (berbeda tergantung pada jenis model)

Untuk contoh selengkapnya tentang cara mengonfigurasi dan memantau eksekusi, lihat cara .

Pola

namespace: azureml.core.model.Model

Kelas Model digunakan untuk bekerja dengan representasi cloud model pembelajaran mesin. Metode membantu Anda mentransfer model antara lingkungan pengembangan lokal dan objek Workspace di cloud.

Anda dapat menggunakan pendaftaran model untuk menyimpan dan membuat versi model Anda di cloud Azure, di ruang kerja Anda. Model terdaftar diidentifikasi berdasarkan nama dan versi. Setiap kali Anda mendaftarkan model dengan nama yang sama dengan yang sudah ada, registri meningkatkan versi. Azure Machine Learning mendukung model apa pun yang dapat dimuat melalui Python 3, bukan hanya model Azure Machine Learning.

Contoh berikut menunjukkan cara membangun model klasifikasi lokal sederhana dengan scikit-learn, mendaftarkan model di Workspace, dan mengunduh model dari cloud.

Buat pengklasifikasi sederhana, clf, untuk memprediksi churn pelanggan berdasarkan usia mereka. Kemudian buang model ke file .pkl di direktori yang sama.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Gunakan fungsi register untuk mendaftarkan model di ruang kerja Anda. Tentukan jalur model lokal dan nama model. Mendaftarkan nama yang sama lebih dari sekali akan membuat versi baru.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Sekarang setelah model terdaftar di ruang kerja Anda, mudah untuk mengelola, mengunduh, dan mengatur model Anda. Untuk mengambil objek model (misalnya, di lingkungan lain) dari Workspace, gunakan konstruktor kelas dan tentukan nama model dan parameter opsional apa pun. Kemudian, gunakan fungsi download untuk mengunduh model, termasuk struktur folder cloud.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Gunakan fungsi delete untuk menghapus model dari Workspace.

model.delete()

Setelah Anda memiliki model terdaftar, menyebarkannya sebagai layanan web adalah proses yang mudah. Pertama, Anda membuat dan mendaftarkan gambar. Langkah ini mengonfigurasi lingkungan Python dan dependensinya, bersama dengan skrip untuk menentukan permintaan layanan web dan format respons. Setelah membuat gambar, Anda membuat konfigurasi penyebaran yang mengatur core CPU dan parameter memori untuk target komputasi. Anda kemudian melampirkan gambar Anda.

ComputeTarget, RunConfiguration, dan ScriptRunConfig

namespace: azureml.core.compute.ComputeTarget
namespace: azureml.core.runconfig.RunConfiguration
namespace: azureml.core.script_run_config.ScriptRunConfig

Kelas ComputeTarget adalah kelas induk abstrak untuk membuat dan mengelola target komputasi. Target komputasi mewakili berbagai sumber daya tempat Anda dapat melatih model pembelajaran mesin Anda. Target komputasi dapat berupa komputer lokal atau sumber daya cloud, seperti Komputasi Azure Machine Learning, Azure HDInsight, atau komputer virtual jarak jauh.

Gunakan target komputasi untuk memanfaatkan komputer virtual yang kuat untuk pelatihan model, dan siapkan target komputasi persisten atau target yang dipanggil runtime sementara. Untuk panduan komprehensif tentang menyiapkan dan mengelola target komputasi, lihat cara .

Kode berikut menunjukkan contoh sederhana menyiapkan target AmlCompute (kelas turunan ComputeTarget). Target ini membuat sumber daya komputasi jarak jauh runtime di objek Workspace Anda. Sumber daya diskalakan secara otomatis saat pekerjaan dikirimkan. Ini dihapus secara otomatis ketika eksekusi selesai.

Gunakan kembali model churn scikit-learn sederhana dan buat ke dalam filenya sendiri, train.py, di direktori saat ini. Di akhir file, buat direktori baru yang disebut outputs. Langkah ini membuat direktori di cloud (ruang kerja Anda) untuk menyimpan model terlatih Anda yang joblib.dump() diserialisasikan.

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Selanjutnya Anda membuat target komputasi dengan membuat instans objek RunConfiguration dan mengatur jenis dan ukuran. Contoh ini menggunakan ukuran sumber daya terkecil (1 inti CPU, memori 3,5 GB). Variabel list_vms berisi daftar komputer virtual yang didukung dan ukurannya.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Buat dependensi untuk lingkungan Python sumber daya komputasi jarak jauh dengan menggunakan kelas CondaDependencies. File train.py menggunakan scikit-learn dan numpy, yang perlu diinstal di lingkungan. Anda juga dapat menentukan versi dependensi. Gunakan objek dependencies untuk mengatur lingkungan di compute_config.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Sekarang Anda siap untuk mengirimkan eksperimen. Gunakan kelas ScriptRunConfig untuk melampirkan konfigurasi target komputasi, dan untuk menentukan jalur/file ke skrip pelatihan train.py. Kirim eksperimen dengan menentukan parameter config fungsi submit(). Panggil wait_for_completion pada eksekusi yang dihasilkan untuk melihat output eksekusi asinkron saat lingkungan diinisialisasi dan model dilatih.

Peringatan

Berikut ini adalah batasan sekeliling karakter tertentu saat digunakan dalam parameter ScriptRunConfig:

  • Karakter ", $, ;, dan \ diloloskan oleh ujung belakang, karena dianggap sebagai karakter khusus untuk memisahkan perintah bash.
  • Karakter (, ), %, !, ^, <, >, &, dan | diloloskan untuk eksekusi lokal di Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

Setelah proses selesai, file model terlatih churn-model.pkl tersedia di ruang kerja Anda.

Lingkungan

namespace: azureml.core.environment

Lingkungan Azure Machine Learning menentukan paket Python, variabel lingkungan, dan pengaturan perangkat lunak di sekitar skrip pelatihan dan penilaian Anda. Selain Python, Anda juga dapat mengonfigurasi PySpark, Docker, dan R untuk lingkungan. Secara internal, lingkungan menghasilkan gambar Docker yang digunakan untuk menjalankan proses pelatihan dan penilaian pada target komputasi. Lingkungan adalah entitas terkelola dan versi dalam ruang kerja Azure Machine Learning Anda yang memungkinkan alur kerja pembelajaran mesin yang dapat direproduksi, dapat diaudit, dan portabel di berbagai target komputasi dan jenis komputasi.

Anda dapat menggunakan objek Environment untuk:

  • Kembangkan skrip pelatihan Anda.
  • Gunakan kembali lingkungan yang sama pada Azure Machine Learning Compute untuk pelatihan model dalam skala besar.
  • Sebarkan model Anda dengan lingkungan yang sama tanpa terikat dengan jenis komputasi tertentu.

Kode berikut mengimpor kelas Environment dari SDK dan membuat instans objek lingkungan.

from azureml.core.environment import Environment
Environment(name="myenv")

Tambahkan paket ke lingkungan dengan menggunakan file Conda, pip, atau roda privat. Tentukan setiap dependensi paket dengan menggunakan kelas CondaDependency untuk menambahkannya ke PythonSectionlingkungan .

Contoh berikut menambahkan ke lingkungan. Ini menambahkan versi 1.17.0 dari numpy. Ini juga menambahkan paket pillow ke lingkungan, myenv. Contohnya menggunakan metode add_conda_package() dan metode add_pip_package().

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Untuk mengirimkan eksekusi pelatihan, Anda perlu menggabungkan lingkungan Anda, target komputasi, dan skrip Python pelatihan Anda ke dalam konfigurasi eksekusi. Konfigurasi ini adalah objek pembungkus yang digunakan untuk mengirimkan eksekusi.

Saat Anda mengirimkan eksekusi pelatihan, pembangunan lingkungan baru dapat memakan waktu beberapa menit. Durasi tergantung pada ukuran dependensi yang diperlukan. Lingkungan di-cache oleh layanan. Jadi selama definisi lingkungan tetap tidak berubah, Anda hanya dikenakan waktu penyiapan penuh sekali.

Contoh berikut menunjukkan tempat Anda akan menggunakan ScriptRunConfig sebagai objek pembungkus Anda.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Jika Anda tidak menentukan lingkungan dalam konfigurasi eksekusi sebelum mengirimkan eksekusi, maka lingkungan default dibuat untuk Anda.

Lihat bagian Penyebaran Model untuk menggunakan lingkungan untuk menyebarkan layanan web.

Alur, PythonScriptStep

namespace: azureml.pipeline.core.pipeline.Pipeline
namespace: azureml.pipeline.steps.python_script_step.PythonScriptStep

Alur Azure Machine Learning adalah alur kerja otomatis dari tugas pembelajaran mesin lengkap. Subtugas dienkapsulasi sebagai serangkaian langkah dalam alur. Alur Azure Machine Learning bisa sesering satu langkah yang memanggil skrip Python. Alur mencakup fungsionalitas untuk:

  • Persiapan data termasuk mengimpor, memvalidasi dan membersihkan, munging dan transformasi, normalisasi, dan penahapan
  • Konfigurasi pelatihan termasuk parameterisasi argumen, jalur file, dan konfigurasi pengelogan/pelaporan
  • Melatih dan memvalidasi secara efisien dan berulang kali, yang mungkin termasuk menentukan subset data tertentu, sumber daya komputasi perangkat keras yang berbeda, pemrosesan terdistribusi, dan pemantauan kemajuan
  • Penyebaran, termasuk penerapan versi, penskalaan, provisi, dan kontrol akses
  • Menerbitkan alur ke titik akhir REST untuk dieksekusi ulang dari pustaka HTTP apa pun

PythonScriptStep adalah langkah dasar bawaan untuk menjalankan Skrip Python pada target komputasi. Dibutuhkan nama skrip dan parameter opsional lainnya seperti argumen untuk skrip, target komputasi, input, dan output. Kode berikut adalah contoh sederhana dari PythonScriptStep. Untuk contoh skrip , lihat sub-bagian tutorial .

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Setelah setidaknya satu langkah dibuat, langkah-langkah dapat ditautkan bersama dan diterbitkan sebagai alur otomatis sederhana.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Untuk contoh komprehensif membangun alur kerja alur, ikuti tutorial lanjutan .

Pola untuk membuat dan menggunakan alur

Alur Azure Machine Learning dikaitkan dengan ruang kerja Azure Machine Learning dan langkah alur dikaitkan dengan target komputasi yang tersedia dalam ruang kerja tersebut. Untuk informasi selengkapnya, lihat artikel ini tentang ruang kerja atau penjelasan ini tentang target komputasi .

Pola umum untuk langkah-langkah alur adalah:

  1. Tentukan ruang kerja, komputasi, dan penyimpanan
  2. Mengonfigurasi data input dan output Anda menggunakan
    1. Himpunan Data yang menyediakan datastore Azure yang sudah ada
    2. PipelineDataset yang merangkum data tabular yang ditik
    3. pipelineData yang digunakan untuk data file atau direktori menengah yang ditulis oleh satu langkah dan dimaksudkan untuk digunakan oleh langkah lain
  3. Tentukan satu atau beberapa langkah alur
  4. Membuat instans alur menggunakan ruang kerja dan langkah-langkah Anda
  5. Membuat eksperimen tempat Anda mengirimkan alur
  6. Memantau hasil eksperimen

Notebook ini adalah contoh yang baik dari pola ini. pekerjaan

Untuk informasi selengkapnya tentang Alur Azure Machine Learning, dan khususnya perbedaannya dengan jenis alur lainnya, lihat artikel ini.

AutoMLConfig

namespace: azureml.train.automl.automlconfig.AutoMLConfig

Gunakan kelas AutoMLConfig untuk mengonfigurasi parameter untuk pelatihan pembelajaran mesin otomatis. Pembelajaran mesin otomatis melakukan iterasi atas banyak kombinasi algoritma pembelajaran mesin dan pengaturan hiperparameter. Kemudian menemukan model yang paling sesuai berdasarkan metrik akurasi yang Anda pilih. Konfigurasi memungkinkan untuk menentukan:

  • Jenis tugas (klasifikasi, regresi, prakiraan)
  • Jumlah iterasi algoritma dan waktu maksimum per iterasi
  • Metrik akurasi untuk dioptimalkan
  • Algoritma untuk memblokir/mengizinkan daftar
  • Jumlah validasi silang
  • Target komputasi
  • Data pelatihan

Nota

Gunakan automl tambahan dalam penginstalan Anda untuk menggunakan pembelajaran mesin otomatis.

Untuk panduan terperinci dan contoh penyiapan eksperimen pembelajaran mesin otomatis, lihat tutorial dan cara.

Kode berikut mengilustrasikan pembuatan objek konfigurasi pembelajaran mesin otomatis untuk model klasifikasi, dan menggunakannya saat Anda mengirimkan eksperimen.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Gunakan objek automl_config untuk mengirimkan eksperimen.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Setelah Anda mengirimkan eksperimen, output menunjukkan akurasi pelatihan untuk setiap iterasi saat selesai. Setelah eksekusi selesai, objek AutoMLRun (yang memperluas kelas Run) dikembalikan. Dapatkan model yang paling pas dengan menggunakan fungsi get_output() untuk mengembalikan objek Model.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Penyebaran model

namespace: azureml.core.model.InferenceConfig
namespace: azureml.core.webservice.webservice.Webservice

Kelas InferenceConfig adalah untuk pengaturan konfigurasi yang menjelaskan lingkungan yang diperlukan untuk menghosting model dan layanan web.

Webservice adalah kelas induk abstrak untuk membuat dan menyebarkan layanan web untuk model Anda. Untuk panduan terperinci tentang mempersiapkan penyebaran model dan menyebarkan layanan web, lihat cara ini.

Anda dapat menggunakan lingkungan saat menyebarkan model sebagai layanan web. Lingkungan memungkinkan alur kerja yang dapat direproduksi dan terhubung di mana Anda dapat menyebarkan model menggunakan pustaka yang sama di komputasi pelatihan dan komputasi inferensi Anda. Secara internal, lingkungan diimplementasikan sebagai gambar Docker. Anda dapat menggunakan gambar yang disediakan oleh Microsoft, atau menggunakan gambar Docker kustom Anda sendiri. Jika sebelumnya Anda menggunakan kelas ContainerImage untuk penyebaran Anda, lihat kelas DockerSection untuk menyelesaikan alur kerja serupa dengan lingkungan.

Untuk menyebarkan layanan web, gabungkan lingkungan, komputasi inferensi, skrip penilaian, dan model terdaftar di objek penyebaran Anda, deploy().

Contoh berikut, mengasumsikan Anda sudah menyelesaikan pelatihan yang dijalankan menggunakan lingkungan, myenv, dan ingin menyebarkan model tersebut ke Azure Container Instances.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

Contoh ini membuat layanan web Azure Container Instances, yang terbaik untuk pengujian skala kecil dan penyebaran cepat. Untuk menyebarkan model Anda sebagai layanan web skala produksi, gunakan Azure Kubernetes Service (AKS). Untuk informasi selengkapnya, lihat kelas AksCompute.

Dataset

namespace: azureml.core.dataset.Dataset
namespace: azureml.data.file_dataset.FileDataset
namespace: azureml.data.tabular_dataset.TabularDataset

Kelas Dataset adalah sumber daya dasar untuk menjelajahi dan mengelola data dalam Azure Machine Learning. Anda dapat menjelajahi data Anda dengan statistik ringkasan, dan menyimpan Himpunan Data ke ruang kerja AML Anda untuk mendapatkan kemampuan penerapan versi dan reproduksi. Himpunan data mudah digunakan oleh model selama pelatihan. Untuk contoh penggunaan terperinci, lihat panduan cara .

  • TabularDataset mewakili data dalam format tabular yang dibuat dengan mengurai file atau daftar file.
  • FileDataset mereferensikan satu atau beberapa file di penyimpanan data atau dari URL publik.

Contoh berikut menunjukkan cara membuat TabularDataset yang menunjuk ke satu jalur di datastore.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

Contoh berikut menunjukkan cara membuat FileDataset mereferensikan beberapa URL file.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Langkah berikutnya

Coba langkah-langkah berikutnya ini untuk mempelajari cara menggunakan Azure Machine Learning SDK untuk Python:

  • Ikuti tutorial untuk mempelajari cara membangun, melatih, dan menyebarkan model di Python.

  • Cari kelas dan modul dalam dokumentasi referensi di situs ini dengan menggunakan daftar isi di sebelah kiri.