Apa itu SDK Azure Machine Learning untuk Python?

  • Artikel

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

Area kunci SDK meliputi:

  • Jelajahi, persiapkan, dan kelola siklus hidup himpunan data Anda yang digunakan dalam eksperimen pembelajaran mesin.
  • Mengelola sumber daya cloud untuk memantau, mencatat, dan mengatur eksperimen pembelajaran mesin Anda.
  • Melatih 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 berulang melalui algoritme dan pengaturan hiperparameter untuk menemukan model terbaik untuk menjalankan prediksi.
  • Sebarkan layanan web untuk mengubah model terlatih Anda menjadi layanan RESTful yang dapat dikonsumsi dalam aplikasi apa pun.

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

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

SDK Azure Machine Learning untuk Python menyediakan fitur stabil dan eksperimental di 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 daripada fitur eksperimental.
Fitur eksperimental Perkembangan

Fitur-fitur ini adalah kemampuan yang baru dikembangkan & pembaruan yang mungkin belum siap atau sepenuhnya diuji untuk penggunaan produksi. Sementara fitur biasanya fungsional, mereka dapat mencakup beberapa perubahan yang melanggar. Fitur eksperimental digunakan untuk mengatasi bug yang merusak SDK, dan hanya akan menerima pembaruan selama periode pengujian. Fitur eksperimental juga disebut sebagai fitur yang ada 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 baris dalam referensi SDK dan dilambangkan dengan teks seperti, (pratinjau) di seluruh dokumentasi Azure Machine Learning.

Ruang kerja

Kumpulan nama XML: 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 dengan objek yang mudah dikonsumsi dalam layanan.

Lihat semua parameter metode buat Ruang kerja untuk menggunakan kembali instans yang ada (Azure Storage, Azure Key Vault, App-Insights, dan Azure Container Registry-ACR) serta ubah 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() statik 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.

Eksperimen

Kumpulan nama XML: azureml.core.experiment.Experiment

Kelas Experiment adalah sumber daya cloud dasar lainnya yang mewakili kumpulan percobaan (model individual berjalan). Kode berikut mengambil objek Experiment dari dalam Workspace berdasarkan nama, atau membuat objek Experiment baru jika namanya 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 terdapat di Workspace.

list_experiments = Experiment.list(ws)

Gunakan fungsi get_runs untuk mengambil daftar objek Run (percobaan) 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 Jupyter notebook, 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.

jalankan

Kumpulan nama XML: azureml.core.run.Run

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

  • Menyimpan dan mengambil metrik dan data.
  • Menggunakan tag dan hierarki turunan untuk memudahkan pencarian berjalan di masa lalu.
  • Mendaftarkan file model yang disimpan untuk penyebaran.
  • Menyimpan, memodifikasi, dan mengambil properti eksekusi.

Buat objek Run dengan mengirimkan objek Experiment 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 statik untuk mendapatkan daftar semua objek Run dari Experiment. Tentukan parameter tags yang akan difilter berdasarkan 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
  • Status
  • Waktu mulai dan akhir
  • Menghitung target (lokal versus cloud)
  • Dependensi dan versi yang digunakan dalam eksekusi
  • Data khusus pelatihan (berbeda tergantung pada jenis model)

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

Model

Kumpulan nama XML: azureml.core.model.Model

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

Pendaftaran model memungkinkan Anda untuk menyimpan dan membuat versi model 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 akan meningkatkan versinya. Azure Machine Learning mendukung model apa pun yang dapat dimuat melalui Python 3, bukan hanya model Azure Machine Learning.

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

Buat pengklasifikasi sederhana, clf, untuk memprediksi kehilangan pelanggan berdasarkan usia mereka. Kemudian cadangan 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 model terdaftar di ruang kerja Anda, mudah untuk mengelola, mengunduh, dan mengatur model Anda. Untuk mengambil model (misalnya, di lingkungan lain) objek 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 membangun konfigurasi sebar yang mengatur inti CPU dan parameter memori untuk target komputasi. Anda kemudian melampirkan gambar Anda.

ComputeTarget, RunConfiguration, dan ScriptRunConfig

Kumpulan nama XML: azureml.core.compute.ComputeTarget
Kumpulan nama XML: azureml.core.runconfig.RunConfiguration
Kumpulan nama XML: 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 adalah komputer lokal atau sumber daya cloud, seperti Azure Machine Learning Compute, Azure HDInsight, atau mesin virtual jarak jauh.

Gunakan target komputasi untuk memanfaatkan mesin virtual yang kuat untuk pelatihan model, dan siapkan target komputasi persisten atau target yang dipanggil runtime sementara. Untuk panduan lengkap tentang penyiapan dan pengelolaan target komputasi, lihat panduan cara kerja.

Kode berikut menunjukkan contoh sederhana untuk menyiapkan AmlCompute target (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 diserialkan joblib.dump().

# 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 mesin 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 dipasang 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. Kirimkan eksperimen dengan menentukan parameter config fungsi submit(). Panggil wait_for_completion pada eksekusi yang dihasilkan untuk melihat output eksekusi asinkron saat lingkungan diinsialisasi dan model dilatih.

Peringatan

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

  • Karakter ", $, ;, dan \ melarikan diri oleh ujung belakang, karena mereka dianggap karakter khusus untuk memisahkan perintah bash.
  • Karakter (, ), %, !, ^, <, >, &, dan | melarikan diri untuk eksekusi lokal pada 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 eksekusi selesai, churn-model.pkl file model terlatih tersedia di ruang kerja Anda.

Lingkungan

Kumpulan nama XML: azureml.core.environment

Lingkungan Azure Machine Learning menentukan paket Python, variabel lingkungan, dan pengaturan perangkat lunak seputar 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 yang memungkinkan alur kerja pembelajaran mesin yang dapat direproduksi, diaudit, dan portabel di berbagai target komputasi dan jenis komputasi.

Anda dapat menggunakan objek Environment untuk:

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

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

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

Tambahkan paket ke lingkungan menggunakan file Conda, pip, atau wheel pribadi. Tentukan setiap dependensi paket dengan menggunakan kelas CondaDependency untuk menambahkannya ke lingkungan PythonSection.

Contoh berikut ditambahkan ke lingkungan. Contoh tersebut menambahkan versi 1.17.0 dari numpy. Ini juga menambahkan paket pillow ke lingkungan, myenv. Contohnya masing-masing 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 pelatihan run, Anda perlu menggabungkan lingkungan Anda, menghitung target, dan skrip Python pelatihan Anda ke dalam konfigurasi run. Konfigurasi ini adalah objek wrapper yang digunakan untuk mengirimkan run.

Saat Anda mengirimkan pelatihan run, proses 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 pengaturan penuh sekali.

Contoh berikut menunjukkan di mana 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 akan dibuat untuk Anda.

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

Alur, PythonScriptStep

Kumpulan nama XML: azureml.pipeline.core.pipeline.Pipeline
Kumpulan nama XML: azureml.pipeline.steps.python_script_step.PythonScriptStep

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

  • Persiapan data termasuk mengimpor, memvalidasi dan membersihkan, munging dan transformasi, normalisasi, serta penahapan
  • Konfigurasi pelatihan termasuk parameter argumen, filepath, dan konfigurasi pencatatan/pelaporan
  • Melatih dan memvalidasi secara efisien dan berulang, yang mungkin termasuk menentukan subset data tertentu, sumber daya komputasi perangkat keras yang berbeda, pemrosesan terdistribusi, dan pemantauan kemajuan
  • Penerapan, termasuk penerapan versi, penskalaan, penyediaan, dan kontrol akses
  • Menerbitkan alur ke titik akhir REST untuk dijalankan 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 yang sederhana dari PythonScriptStep. Untuk contoh skrip train.py, lihat sub-bagian turorial.

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 lengkap 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 target komputasi ini.

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 diketik
    3. PipelineData yang digunakan untuk file perantara atau data direktori yang ditulis oleh satu langkah dan dimaksudkan untuk dikonsumsi oleh yang lain
  3. Menentukan satu atau beberapa langkah alur
  4. Buat instans alur menggunakan ruang kerja dan langkah Anda
  5. Membuat eksperimen tempat Anda mengirimkan alur
  6. Memantau hasil eksperimen

Buku catatan ini adalah contoh yang baik dari pola ini. tugas

Untuk informasi selengkapnya tentang Alur Azure Machine Learning, dan khususnya bagaimana mereka berbeda dari jenis alur lainnya, lihat artikel ini.

AutoMLConfig

kumpulan nama XML: azureml.train.automl.automlconfig.AutoMLConfig

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

  • Jenis tugas (klasifikasi, regresi, prakiraan)
  • Jumlah perulangan algoritma dan waktu maksimum per perulangan
  • Metrik akurasi untuk mengoptimalkan
  • Algoritma untuk daftar blokir/daftar yang diizinkan
  • Jumlah validasi silang
  • Menghitung target
  • Data pelatihan

Catatan

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

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

Kode berikut mengilustrasikan membangun 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 perulangan saat selesai. Setelah eksekusi selesai, objek AutoMLRun (yang memperluas kelas Run) dikembalikan. Dapatkan model yang paling cocok dengan menggunakan fungsi get_output() untuk mengembalikan objek Model.

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

Penyebaran model

Kumpulan nama XML: azureml.core.model.InferenceConfig
Kumpulan nama XML: azureml.core.webservice.webservice.Webservice

Kelas InferenceConfig untuk pengaturan konfigurasi yang menggambarkan lingkungan yang diperlukan untuk meng-host model dan layanan web.

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

Anda dapat menggunakan lingkungan saat Anda 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 menggunakan lingkungan, myenv, dan ingin menyebarkan model itu 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 lebih selengkapnya, lihat Kelas AksCompute.

Himpunan data

Kumpulan nama XML: azureml.core.dataset.Dataset
Kumpulan nama XML: azureml.data.file_dataset.FileDataset
Kumpulan nama XML: azureml.data.tabular_dataset.TabularDataset

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

  • TabularDataset mewakili data dalam format tabular yang dibuat dengan menguraikan file atau daftar file yang disediakan.
  • FileDataset mereferensikan satu atau beberapa file di datastore atau URL publik Anda.

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 referensi 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 selanjutnya untuk mempelajari cara menggunakan SDK Azure Machine Learning 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.