Cara menyebarkan alur untuk melakukan penilaian batch dengan pra-pemrosesan

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

Dalam artikel ini, Anda akan mempelajari cara menyebarkan alur inferensi (atau penilaian) di bawah titik akhir batch. Alur melakukan penilaian melalui model terdaftar sambil juga menggunakan kembali komponen pra-pemrosesan dari kapan model dilatih. Menggunakan kembali komponen pra-pemrosesan yang sama memastikan bahwa pra-pemrosesan yang sama diterapkan selama penilaian.

Anda akan belajar untuk:

• Membuat alur yang menggunakan kembali komponen yang ada dari ruang kerja
• Menyebarkan alur ke titik akhir
• Mengonsumsi prediksi yang dihasilkan oleh alur

Tentang contoh ini

Contoh ini menunjukkan kepada Anda cara menggunakan kembali kode praproscesing dan parameter yang dipelajari selama pra-pemrosesan sebelum Anda menggunakan model Anda untuk inferensi. Dengan menggunakan kembali kode pra-pemrosesan dan parameter yang dipelajari, kami dapat memastikan bahwa transformasi yang sama (seperti normalisasi dan pengodean fitur) yang diterapkan ke data input selama pelatihan juga diterapkan selama inferensi. Model yang digunakan untuk inferensi akan melakukan prediksi pada data tabular dari Himpunan Data Penyakit Jantung UCI.

Visualisasi alur adalah sebagai berikut:

Contoh dalam artikel ini didasarkan pada sampel kode yang terkandung dalam repositori azureml-examples . Untuk menjalankan perintah secara lokal tanpa harus menyalin/menempelkan YAML dan file lainnya, pertama-tama kloning repositori lalu ubah direktori ke folder:

Azure CLI

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Python

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python

File untuk contoh ini ada di:

cd endpoints/batch/deploy-pipelines/batch-scoring-with-preprocessing

Ikuti di buku catatan Jupyter

Anda dapat mengikuti versi Python SDK dari contoh ini dengan membuka notebook sdk-deploy-and-test.ipynb di repositori kloning.

Prasyarat

Sebelum mengikuti langkah-langkah dalam artikel ini, pastikan Anda memiliki prasyarat berikut:

• Langganan Azure. Jika Anda tidak memiliki langganan Azure, buat akun gratis sebelum Anda memulai. Coba versi gratis atau berbayar Azure Machine Learning.

• Ruang kerja Azure Machine Learning. Jika Anda tidak memilikinya, gunakan langkah-langkah dalam artikel Mengelola ruang kerja Azure Pembelajaran Mesin untuk membuatnya.

• Pastikan Anda memiliki izin berikut di ruang kerja:

  • Membuat atau mengelola titik akhir dan penyebaran batch: Gunakan peran Pemilik, Kontributor, atau Kustom yang memungkinkan Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

  • Membuat penyebaran ARM di grup sumber daya ruang kerja: Gunakan peran Pemilik, Kontributor, atau Kustom yang memungkinkan Microsoft.Resources/deployments/write dalam grup sumber daya tempat ruang kerja disebarkan.

• Anda perlu menginstal perangkat lunak berikut untuk bekerja dengan Azure Pembelajaran Mesin:

  Azure CLI

  Azure CLI dan mlekstensi untuk Azure Pembelajaran Mesin.

  az extension add -n ml
  

  Catatan

  Penyebaran komponen alur untuk Titik Akhir Batch diperkenalkan dalam ekstensi versi 2.7 ml untuk Azure CLI. Gunakan az extension update --name ml untuk mendapatkan versi terakhirnya.

  Python

  SDK Azure Machine Learning untuk Python.

  pip install azure-ai-ml
  

  Catatan

  ModelBatchDeployment Kelas dan PipelineComponentBatchDeployment diperkenalkan dalam SDK versi 1.7.0. Gunakan pip install -U azure-ai-ml untuk mendapatkan versi terakhirnya.

Menyambungkan ke ruang kerja Anda

Ruang kerja adalah sumber daya tingkat teratas untuk Azure Machine Learning, menyediakan tempat terpusat untuk bekerja dengan semua artefak yang Anda buat saat Anda menggunakan Azure Machine Learning. Di bagian ini, kita akan menyambungkan ke ruang kerja tempat Anda akan melakukan tugas penyebaran.

Azure CLI

Teruskan nilai untuk ID langganan, ruang kerja, lokasi, dan grup sumber daya Anda dalam kode berikut:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Python

1. Impor pustaka yang diperlukan:

   from azure.ai.ml import MLClient, Input, load_component
   from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
   from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
   from azure.ai.ml.dsl import pipeline
   from azure.identity import DefaultAzureCredential
   

2. Konfigurasikan detail ruang kerja dan dapatkan handel ke ruang kerja:

   Teruskan nilai untuk ID langganan, ruang kerja, dan grup sumber daya Anda dalam kode berikut:

   subscription_id = "<subscription>"
   resource_group = "<resource-group>"
   workspace = "<workspace>"
   
   ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
   

Membuat alur inferensi

Di bagian ini, kita akan membuat semua aset yang diperlukan untuk alur inferensi kita. Kita akan mulai dengan membuat lingkungan yang mencakup pustaka yang diperlukan untuk komponen alur. Selanjutnya, kita akan membuat kluster komputasi tempat penyebaran batch akan berjalan. Setelah itu, kita akan mendaftarkan komponen, model, dan transformasi yang kita butuhkan untuk membangun alur inferensi kita. Akhirnya, kita akan membangun dan menguji alur.

Buat lingkungan

Komponen dalam contoh ini akan menggunakan lingkungan dengan XGBoost pustaka dan scikit-learn . File environment/conda.yml berisi konfigurasi lingkungan:

lingkungan/conda.yml

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip
- pip:
  - mlflow
  - azureml-mlflow
  - datasets
  - jobtools
  - cloudpickle==1.6.0
  - dask==2023.2.0
  - scikit-learn==1.1.2
  - xgboost==1.3.3
name: mlflow-env

Buat lingkungan sebagai berikut:

1. Tentukan lingkungan:

   Azure CLI

   lingkungan/xgboost-sklearn-py38.yml

   $schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
   name: xgboost-sklearn-py38
   image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
   conda_file: conda.yml
   description: An environment for models built with XGBoost and Scikit-learn.
   

   Python

   environment = Environment(
       name="xgboost-sklearn-py38",
       description="An environment for models built with XGBoost and Scikit-learn.",
       image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
       conda_file="environment/conda.yml",
   )

2. Buat lingkungan:

   Azure CLI

   az ml environment create -f environment/xgboost-sklearn-py38.yml
   

   Python

   try:
       ml_client.environments.create_or_update(environment)
   except ResourceExistsError:
       pass

Membuat kluster komputasi

Titik akhir dan penyebaran batch berjalan pada kluster komputasi. Mereka dapat berjalan pada kluster komputasi Azure Pembelajaran Mesin apa pun yang sudah ada di ruang kerja. Oleh karena itu, beberapa penyebaran batch dapat berbagi infrastruktur komputasi yang sama. Dalam contoh ini, kita akan mengerjakan kluster komputasi Azure Pembelajaran Mesin yang disebut batch-cluster. Mari kita verifikasi bahwa komputasi ada di ruang kerja atau membuatnya sebaliknya.

Azure CLI

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Python

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="Batch endpoints compute cluster",
        min_instances=0,
        max_instances=5,
    )
    ml_client.begin_create_or_update(compute_cluster).result()

Mendaftarkan komponen dan model

Kita akan mendaftarkan komponen, model, dan transformasi yang kita butuhkan untuk membangun alur inferensi kita. Kita dapat menggunakan kembali beberapa aset ini untuk rutinitas pelatihan.

Tip

Dalam tutorial ini, kita akan menggunakan kembali model dan komponen pra-pemrosesan dari alur pelatihan sebelumnya. Anda dapat melihat bagaimana alur dibuat dengan mengikuti contoh Cara menyebarkan alur pelatihan dengan titik akhir batch.

1. Daftarkan model yang akan digunakan untuk prediksi:

   Azure CLI

   az ml model create --name heart-classifier --type mlflow_model --path model
   

   Python

   model_name = "heart-classifier"
   model_local_path = "model"
   
   model = ml_client.models.create_or_update(
       Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
   )

2. Model terdaftar tidak dilatih langsung pada data input. Sebagai gantinya, data input telah diolah sebelumnya (atau diubah) sebelum pelatihan, menggunakan komponen persiapan. Kita juga perlu mendaftarkan komponen ini. Daftarkan komponen persiapan:

   Azure CLI

   az ml component create -f components/prepare/prepare.yml
   

   Python

   prepare_data = load_component(source="components/prepare/prepare.yml")
   
   ml_client.components.create_or_update(prepare_data)

   Tip

   Setelah mendaftarkan komponen persiapan, Anda sekarang dapat mereferensikannya dari ruang kerja. Misalnya, azureml:uci_heart_prepare@latest akan mendapatkan versi terakhir dari komponen persiapan.

3. Sebagai bagian dari transformasi data dalam komponen persiapan, data input dinormalisasi untuk memusatkan prediktor dan membatasi nilainya dalam rentang [-1, 1]. Parameter transformasi diambil dalam transformasi scikit-learn yang juga dapat kita daftarkan untuk diterapkan nanti ketika kita memiliki data baru. Daftarkan transformasi sebagai berikut:

   Azure CLI

   az ml model create --name heart-classifier-transforms --type custom_model --path transformations
   

   Python

   transformation_name = "heart-classifier-transforms"
   transformation_local_path = "transformations"
   
   transformations = ml_client.models.create_or_update(
       Model(
           name=transformation_name,
           path=transformation_local_path,
           type=AssetTypes.CUSTOM_MODEL,
       )
   )

4. Kami akan melakukan inferensi untuk model terdaftar, menggunakan komponen lain bernama score yang menghitung prediksi untuk model tertentu. Kami akan mereferensikan komponen langsung dari definisinya.

   Tip

   Praktik terbaik adalah mendaftarkan komponen dan mereferensikannya dari alur. Namun, dalam contoh ini, kita akan mereferensikan komponen langsung dari definisinya untuk membantu Anda melihat komponen mana yang digunakan kembali dari alur pelatihan dan mana yang baru.

Membangun alur

Sekarang saatnya untuk mengikat semua elemen bersama-sama. Alur inferensi yang akan kami sebarkan memiliki dua komponen (langkah):

• preprocess_job: Langkah ini membaca data input dan mengembalikan data yang disiapkan dan transformasi yang diterapkan. Langkah ini menerima dua input:
  • data: folder yang berisi data input untuk dinilai
  • transformations: (opsional) Jalur ke transformasi yang akan diterapkan, jika tersedia. Ketika disediakan, transformasi dibaca dari model yang ditunjukkan di jalur. Namun, jika jalur tidak disediakan, transformasi akan dipelajari dari data input. Namun, untuk inferensi, Anda tidak dapat mempelajari parameter transformasi (dalam contoh ini, koefisien normalisasi) dari data input karena Anda perlu menggunakan nilai parameter yang sama yang dipelajari selama pelatihan. Karena input ini bersifat opsional, preprocess_job komponen dapat digunakan selama pelatihan dan penilaian.
• score_job: Langkah ini akan melakukan inferensi pada data yang diubah, menggunakan model input. Perhatikan bahwa komponen menggunakan model MLflow untuk melakukan inferensi. Akhirnya, skor ditulis kembali dalam format yang sama seperti yang dibaca.

Azure CLI

Konfigurasi alur ditentukan dalam pipeline.yml file:

pipeline.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
type: pipeline

name: batch_scoring_uci_heart
display_name: Batch Scoring for UCI heart
description: This pipeline demonstrates how to make batch inference using a model from the Heart Disease Data Set problem, where pre and post processing is required as steps. The pre and post processing steps can be components reusable from the training pipeline.

inputs:
  input_data:
    type: uri_folder
  score_mode:
    type: string
    default: append

outputs: 
  scores:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: azureml:uci_heart_prepare@latest
    inputs:
      data: ${{parent.inputs.input_data}}
      transformations: 
        path: azureml:heart-classifier-transforms@latest
        type: custom_model
    outputs:
      prepared_data:
  
  score_job:
    type: command
    component: components/score/score.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      model:
        path: azureml:heart-classifier@latest
        type: mlflow_model
      score_mode: ${{parent.inputs.score_mode}}
    outputs:
      scores: 
        mode: upload
        path: ${{parent.outputs.scores}}

Python

prepare_data = ml_client.components.get("uci_heart_prepare", label="latest")
score_data = load_component(source="components/score/score.yml")

Mari kita buat alur dalam fungsi:

@pipeline()
def uci_heart_classifier_scorer(
    input_data: Input(type=AssetTypes.URI_FOLDER), score_mode: str
):
    """This pipeline demonstrates how to make batch inference using a model from the Heart Disease Data Set problem, where pre and post processing is required as steps. The pre and post processing steps can be components reusable from the training pipeline."""
    prepared_data = prepare_data(
        data=input_data,
        transformations=Input(type=AssetTypes.CUSTOM_MODEL, path=transformations.id),
    )
    scored_data = score_data(
        data=prepared_data.outputs.prepared_data,
        model=Input(type=AssetTypes.MLFLOW_MODEL, path=model.id),
        score_mode=score_mode,
    )

    return {"scores": scored_data.outputs.scores}

Visualisasi alur adalah sebagai berikut:

Menguji alur

Mari kita uji alur dengan beberapa data sampel. Untuk melakukannya, kita akan membuat pekerjaan menggunakan alur dan kluster komputasi yang batch-cluster dibuat sebelumnya.

Azure CLI

File berikut pipeline-job.yml berisi konfigurasi untuk pekerjaan alur:

pipeline-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: uci-classifier-score-job
description: |-
  This pipeline demonstrate how to make batch inference using a model from the Heart \
  Disease Data Set problem, where pre and post processing is required as steps. The \
  pre and post processing steps can be components reused from the training pipeline.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
  score_mode: append
outputs: 
  scores:
    mode: upload

Python

pipeline_job = uci_heart_classifier_scorer(
    input_data=Input(type="uri_folder", path="data/unlabeled/"), score_mode="append"
)

Sekarang, kita akan mengonfigurasi beberapa pengaturan eksekusi untuk menjalankan pengujian:

pipeline_job.settings.default_datastore = "workspaceblobstore"
pipeline_job.settings.default_compute = "batch-cluster"

Buat pekerjaan pengujian:

Azure CLI

az ml job create -f pipeline-job.yml --set inputs.input_data.path=data/unlabeled

Python

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="uci-heart-score-pipeline"
)
pipeline_job_run

Membuat titik akhir batch

1. Berikan nama untuk titik akhir. Nama titik akhir batch harus unik di setiap wilayah karena namanya digunakan untuk membangun URI pemanggilan. Untuk memastikan keunikan, tambahkan karakter berikutnya ke nama yang ditentukan dalam kode berikut.

   Azure CLI

   ENDPOINT_NAME="uci-classifier-score"
   

   Python

   endpoint_name = "uci-classifier-score"

2. Konfigurasikan titik akhir:

   Azure CLI

   File endpoint.yml berisi konfigurasi titik akhir.

   endpoint.yml

   $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
   name: uci-classifier-score
   description: Batch scoring endpoint of the Heart Disease Data Set prediction task.
   auth_mode: aad_token
   

   Python

   endpoint = BatchEndpoint(
       name=endpoint_name,
       description="Batch scoring endpoint of the Heart Disease Data Set prediction task",
   )

3. Buat titik akhir:

   Azure CLI

   az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml
   

   Python

   ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

4. Kueri URI titik akhir:

   Azure CLI

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

   endpoint = ml_client.batch_endpoints.get(name=endpoint_name)
   print(endpoint)

Menyebarkan komponen alur

Untuk menyebarkan komponen alur, kita harus membuat penyebaran batch. Penyebaran adalah sekumpulan sumber daya yang diperlukan untuk menghosting aset yang melakukan pekerjaan aktual.

1. Konfigurasikan penyebaran

   Azure CLI

   File deployment.yml berisi konfigurasi penyebaran. Anda dapat memeriksa skema YAML titik akhir batch lengkap untuk properti tambahan.

   deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-prepros-xgb
   endpoint_name: uci-classifier-batch
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Alur kami didefinisikan dalam fungsi. Untuk mengubahnya menjadi komponen, Anda akan menggunakan component properti darinya. Komponen alur adalah grafik komputasi yang dapat digunakan kembali yang dapat disertakan dalam penyebaran batch atau digunakan untuk menyusun alur yang lebih kompleks.

   pipeline_component = ml_client.components.create_or_update(
       uci_heart_classifier_scorer().component
   )

   Sekarang kita dapat menentukan penyebaran:

   deployment = PipelineComponentBatchDeployment(
       name="uci-classifier-prepros-xgb",
       description="A sample deployment with pre and post processing done before and after inference.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

2. Membuat penyebaran

   Azure CLI

   Jalankan kode berikut untuk membuat penyebaran batch di bawah titik akhir batch dan atur sebagai penyebaran default.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment.yml --set-default
   

   Tip

   Perhatikan penggunaan --set-default bendera untuk menunjukkan bahwa penyebaran baru ini sekarang menjadi default.

   Python

   Perintah ini akan memulai pembuatan penyebaran dan mengembalikan respons konfirmasi saat pembuatan penyebaran berlanjut.

   ml_client.batch_deployments.begin_create_or_update(deployment).result()

   Setelah dibuat, mari kita konfigurasikan penyebaran baru ini sebagai yang default:

   endpoint = ml_client.batch_endpoints.get(endpoint_name)
   endpoint.defaults.deployment_name = deployment.name
   ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

3. Penyebaran Anda siap digunakan.

Menguji penyebarannya

Setelah penyebaran dibuat, penyebaran siap untuk menerima pekerjaan. Ikuti langkah-langkah berikut untuk mengujinya:

1. Penyebaran kami mengharuskan kami menunjukkan satu input data dan satu input harfiah.

   Azure CLI

   File inputs.yml berisi definisi untuk aset data input:

   inputs.yml

   inputs:
     input_data:
       type: uri_folder
       path: data/unlabeled
     score_mode:
       type: string
       default: append
   outputs:
     scores:
       type: uri_folder
       mode: upload
   

   Python

   Definisi aset data input:

   input_data = Input(type="uri_folder", path="data/unlabeled/")
   score_mode = Input(type="string", default="append")

   Tip

   Untuk mempelajari selengkapnya tentang cara menunjukkan input, lihat Membuat pekerjaan dan memasukkan data untuk titik akhir batch.

2. Anda dapat memanggil penyebaran default sebagai berikut:

   Azure CLI

   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   Tip

   Apa perbedaan antara inputs dan input kapan Anda memanggil titik akhir?

   Secara umum, Anda dapat menggunakan kamus inputs = {} dengan invoke metode untuk memberikan jumlah input yang diperlukan secara arbitrer ke titik akhir batch yang berisi penyebaran model atau penyebaran alur.

   Untuk penyebaran model, Anda dapat menggunakan input sebagai cara yang lebih pendek untuk menentukan lokasi data input untuk penyebaran, karena penyebaran model selalu hanya mengambil satu input data.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       inputs={"input_data": input_data, "score_mode": score_mode},
   )

3. Anda dapat memantau kemajuan acara dan mengalirkan log menggunakan:

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Untuk menunggu pekerjaan selesai, jalankan kode berikut:

   ml_client.jobs.stream(name=job.name)

Akses output pekerjaan

Setelah pekerjaan selesai, kita dapat mengakses output-nya. Pekerjaan ini hanya berisi satu output bernama scores:

Azure CLI

Anda dapat mengunduh hasil terkait menggunakan az ml job download.

az ml job download --name $JOB_NAME --output-name scores

Python

Unduh hasilnya:

ml_client.jobs.download(name=job.name, download_path=".", output_name="scores")

Baca data yang dinilai:

import pandas as pd
import glob

output_files = glob.glob("named-outputs/scores/*.csv")
score = pd.concat((pd.read_csv(f) for f in output_files))
score

Outputnya terlihat sebagai berikut:

usia	Jenis Kelamin	...	Thal	prediction
0.9338	1	...	2	0
1.3782	1	...	3	1
1.3782	1	...	4	0
-1.954	1	...	3	0

Output berisi prediksi ditambah data yang disediakan untuk komponen skor , yang telah diproscesikan sebelumnya. Misalnya, kolom age telah dinormalisasi, dan kolom thal berisi nilai pengodean asli. Dalam praktiknya, Anda mungkin ingin menghasilkan prediksi saja dan kemudian menyatukannya dengan nilai asli. Pekerjaan ini telah diserahkan kepada pembaca.

Membersihkan sumber daya

Setelah selesai, hapus sumber daya terkait dari ruang kerja:

Azure CLI

Jalankan kode berikut untuk menghapus titik akhir batch dan penyebaran yang mendasarinya. --yes digunakan untuk mengonfirmasi penghapusan.

az ml batch-endpoint delete -n $ENDPOINT_NAME --yes

Python

Hapus titik akhir:

ml_client.batch_endpoints.begin_delete(endpoint_name)

(Opsional) Hapus komputasi, kecuali Anda berencana untuk menggunakan kembali kluster komputasi Anda dengan penyebaran nanti.

Azure CLI

az ml compute delete -n batch-cluster

Python

ml_client.compute.begin_delete(name="batch-cluster")

Langkah berikutnya

• Membuat titik akhir batch dari pekerjaan alur
• Mengakses data dari pekerjaan titik akhir batch
• Memecahkan masalah titik akhir batch