Jak wdrożyć potok w celu przeprowadzania oceniania wsadowego przy użyciu przetwarzania wstępnego

DOTYCZY: Rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji 2 (current)Zestaw PYTHON SDK azure-ai-ml v2 (bieżąca)

W tym artykule dowiesz się, jak wdrożyć potok wnioskowania (lub oceniania) w punkcie końcowym wsadowym. Potok wykonuje ocenianie zarejestrowanego modelu, a także ponowne używanie składnika przetwarzania wstępnego z momentu wytrenowania modelu. Ponowne używanie tego samego składnika przetwarzania wstępnego gwarantuje, że podczas oceniania jest stosowane to samo wstępne przetwarzanie.

Dowiesz się, jak wykonywać następujące czynności:

• Tworzenie potoku, który ponownie używa istniejących składników z obszaru roboczego
• Wdrażanie potoku w punkcie końcowym
• Korzystanie z przewidywań generowanych przez potok

Informacje o tym przykładzie

W tym przykładzie pokazano, jak ponownie używać kodu przetwarzania wstępnego i parametrów poznanych podczas przetwarzania wstępnego przed użyciem modelu do wnioskowania. Dzięki ponownemu użyciu kodu wstępnego przetwarzania i poznanych parametrów możemy zapewnić, że te same przekształcenia (takie jak normalizacja i kodowanie cech), które zostały zastosowane do danych wejściowych podczas trenowania, są również stosowane podczas wnioskowania. Model używany do wnioskowania przeprowadzi przewidywania na danych tabelarycznych z zestawu danych dotyczących chorób serca UCI.

Wizualizacja potoku jest następująca:

Przykład w tym artykule jest oparty na przykładach kodu zawartych w repozytorium azureml-examples . Aby uruchomić polecenia lokalnie bez konieczności kopiowania lub wklejania kodu YAML i innych plików, użyj następujących poleceń, aby sklonować repozytorium i przejść do folderu dla języka kodowania:

Interfejs wiersza polecenia platformy Azure

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

Pliki dla tego przykładu znajdują się w następujących elementach:

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

Postępuj zgodnie z instrukcjami w notesach Jupyter

Następnie możesz skorzystać z wersji zestawu SDK języka Python w tym przykładzie, otwierając notes sdk-deploy-and-test.ipynb w sklonowanym repozytorium.

Wymagania wstępne

• Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

• Obszar roboczy usługi Azure Machine Learning. Aby utworzyć obszar roboczy, zobacz Zarządzanie obszarami roboczymi usługi Azure Machine Learning.

• Następujące uprawnienia w obszarze roboczym usługi Azure Machine Learning:

  • Do tworzenia punktów końcowych i wdrożeń wsadowych lub zarządzania nimi: użyj roli właściciela, współautora lub niestandardowej, która została przypisana Microsoft.MachineLearningServices/workspaces/batchEndpoints/* do uprawnień.
  • Aby utworzyć wdrożenia usługi Azure Resource Manager w grupie zasobów obszaru roboczego: użyj roli właściciel, współautor lub niestandardowa, która została przypisana Microsoft.Resources/deployments/write do uprawnienia w grupie zasobów, w której wdrożono obszar roboczy.

• Interfejs wiersza polecenia usługi Azure Machine Learning lub zestaw AZURE Machine Learning SDK dla języka Python:

  Interfejs wiersza polecenia platformy Azure

  Uruchom następujące polecenie, aby zainstalować interfejs wiersza polecenia platformy Azure i ml rozszerzenie usługi Azure Machine Learning:

  az extension add -n ml
  

  Wdrożenia składników potoku dla punktów końcowych wsadowych są wprowadzane w wersji 2.7 ml rozszerzenia dla interfejsu wiersza polecenia platformy Azure. Użyj polecenia , az extension update --name ml aby pobrać najnowszą wersję.

  Python

  Uruchom następujące polecenie, aby zainstalować zestaw AZURE Machine Learning SDK dla języka Python:

  pip install azure-ai-ml
  

  Klasy ModelBatchDeployment i PipelineComponentBatchDeployment są wprowadzane w wersji 1.7.0 zestawu SDK. Użyj polecenia , pip install -U azure-ai-ml aby pobrać najnowszą wersję.

---

Nawiązywanie połączenia z obszarem roboczym

Obszar roboczy to zasób najwyższego poziomu dla usługi Azure Machine Learning. Zapewnia scentralizowane miejsce do pracy ze wszystkimi artefaktami tworzonymi podczas korzystania z usługi Azure Machine Learning. W tej sekcji nawiąż połączenie z obszarem roboczym, w którym wykonujesz zadania wdrażania.

Interfejs wiersza polecenia platformy Azure

W poniższym poleceniu wprowadź identyfikator subskrypcji, nazwę obszaru roboczego, nazwę grupy zasobów i lokalizację:

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

Python

1. Zaimportuj wymagane biblioteki:

   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. Skonfiguruj szczegóły obszaru roboczego i uzyskaj dojście do obszaru roboczego:

   W poniższym poleceniu wprowadź identyfikator subskrypcji, nazwę grupy zasobów i nazwę obszaru roboczego:

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

Tworzenie potoku wnioskowania

W tej sekcji utworzymy wszystkie zasoby wymagane dla potoku wnioskowania. Zaczniemy od utworzenia środowiska zawierającego niezbędne biblioteki dla składników potoku. Następnie utworzymy klaster obliczeniowy, na którym zostanie uruchomione wdrożenie wsadowe. Następnie zarejestrujemy składniki, modele i przekształcenia, które musimy utworzyć w potoku wnioskowania. Na koniec skompilujemy i przetestujemy potok.

Tworzenie środowiska

Składniki w tym przykładzie będą używać środowiska z bibliotekami XGBoost i scikit-learn . Plik environment/conda.yml zawiera konfigurację środowiska:

środowisko/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

Utwórz środowisko w następujący sposób:

1. Zdefiniuj środowisko:

   Interfejs wiersza polecenia platformy Azure

   środowisko/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. Utwórz środowisko:

   Interfejs wiersza polecenia platformy Azure

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

   Python

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

Tworzenie klastra obliczeniowego

Punkty końcowe i wdrożenia usługi Batch są uruchamiane w klastrach obliczeniowych. Mogą one działać w dowolnym klastrze obliczeniowym usługi Azure Machine Learning, który już istnieje w obszarze roboczym. W związku z tym wiele wdrożeń wsadowych może współużytkować tę samą infrastrukturę obliczeniową. W tym przykładzie będziemy pracować nad klastrem obliczeniowym usługi Azure Machine Learning o nazwie batch-cluster. Sprawdźmy, czy środowisko obliczeniowe istnieje w obszarze roboczym lub utwórz je w inny sposób.

Interfejs wiersza polecenia platformy Azure

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()

Rejestrowanie składników i modeli

Zarejestrujemy składniki, modele i przekształcenia, które musimy utworzyć w potoku wnioskowania. Niektóre z tych zasobów można użyć ponownie na potrzeby procedur szkoleniowych.

Napiwek

W tym samouczku użyjemy ponownie modelu i składnika przetwarzania wstępnego z wcześniejszego potoku trenowania. Możesz zobaczyć, jak zostały utworzone, postępując zgodnie z przykładem Jak wdrożyć potok trenowania z punktami końcowymi wsadowymi.

1. Zarejestruj model do użycia na potrzeby przewidywania:

   Interfejs wiersza polecenia platformy Azure

   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. Zarejestrowany model nie został wytrenowany bezpośrednio na danych wejściowych. Zamiast tego dane wejściowe zostały wstępnie przetworzone (lub przekształcone) przed rozpoczęciem trenowania przy użyciu składnika prepare. Musimy również zarejestrować ten składnik. Zarejestruj składnik prepare:

   Interfejs wiersza polecenia platformy Azure

   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)

   Napiwek

   Po zarejestrowaniu składnika prepare możesz teraz odwołać się do niego z obszaru roboczego. Na przykład azureml:uci_heart_prepare@latest zostanie pobrana ostatnia wersja składnika prepare.

3. W ramach przekształceń danych w składniku przygotowywania dane wejściowe zostały znormalizowane w celu wyśrodkowania predyktorów i ograniczenia ich wartości w zakresie [-1, 1]. Parametry transformacji zostały przechwycone w transformacji scikit-learn, którą możemy również zarejestrować w celu zastosowania później, gdy mamy nowe dane. Zarejestruj przekształcenie w następujący sposób:

   Interfejs wiersza polecenia platformy Azure

   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. Przeprowadzimy wnioskowanie dla zarejestrowanego modelu przy użyciu innego składnika o nazwie score , który oblicza przewidywania dla danego modelu. Odwołujemy się do składnika bezpośrednio z jego definicji.

   Napiwek

   Najlepszym rozwiązaniem byłoby zarejestrowanie składnika i odwołanie do niego z potoku. Jednak w tym przykładzie odwołujemy się do składnika bezpośrednio z jego definicji, aby ułatwić sprawdzenie, które składniki są ponownie używane z potoku trenowania i które z nich są nowe.

Kompilowanie potoku

Teraz nadszedł czas, aby powiązać wszystkie elementy razem. Potok wnioskowania, który wdrożymy, ma dwa składniki (kroki):

• preprocess_job: ten krok odczytuje dane wejściowe i zwraca przygotowane dane oraz zastosowane przekształcenia. Krok odbiera dwa dane wejściowe:
  • data: folder zawierający dane wejściowe do oceny
  • transformations: (opcjonalnie) Ścieżka do przekształceń, które zostaną zastosowane, jeśli są dostępne. Po podaniu przekształcenia są odczytywane z modelu wskazanego na ścieżce. Jeśli jednak ścieżka nie zostanie podana, przekształcenia zostaną poznane na podstawie danych wejściowych. W przypadku wnioskowania nie można jednak nauczyć się parametrów transformacji (w tym przykładzie współczynników normalizacji) z danych wejściowych, ponieważ należy użyć tych samych wartości parametrów, które zostały poznane podczas trenowania. Ponieważ te dane wejściowe są opcjonalne, preprocess_job składnik może być używany podczas trenowania i oceniania.
• score_job: ten krok przeprowadzi wnioskowanie na przekształconych danych przy użyciu modelu wejściowego. Zwróć uwagę, że składnik używa modelu MLflow do wnioskowania. Na koniec wyniki są zapisywane w tym samym formacie, w jakim zostały odczytane.

Interfejs wiersza polecenia platformy Azure

Konfiguracja potoku jest zdefiniowana pipeline.yml w pliku:

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")

Skompilujmy potok w funkcji:

@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}

Wizualizacja potoku jest następująca:

Testowanie potoku

Przetestujmy potok przy użyciu przykładowych danych. W tym celu utworzymy zadanie przy użyciu potoku i utworzonego wcześniej klastra obliczeniowego batch-cluster .

Interfejs wiersza polecenia platformy Azure

Następujący pipeline-job.yml plik zawiera konfigurację zadania potoku:

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"
)

Teraz skonfigurujemy niektóre ustawienia uruchamiania, aby uruchomić test:

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

Utwórz zadanie testowe:

Interfejs wiersza polecenia platformy Azure

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

Tworzenie punktu końcowego wsadowego

1. Podaj nazwę punktu końcowego. Nazwa punktu końcowego partii musi być unikatowa w każdym regionie, ponieważ nazwa jest używana do konstruowania identyfikatora URI wywołania. Aby zapewnić unikatowość, dołącz wszystkie końcowe znaki do nazwy określonej w poniższym kodzie.

   Interfejs wiersza polecenia platformy Azure

   ENDPOINT_NAME="uci-classifier-score"
   

   Python

   endpoint_name = "uci-classifier-score"

2. Konfigurowanie punktu końcowego:

   Interfejs wiersza polecenia platformy Azure

   Plik endpoint.yml zawiera konfigurację punktu końcowego.

   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. Utwórz punkt końcowy:

   Interfejs wiersza polecenia platformy Azure

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

   Python

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

4. Wykonaj zapytanie dotyczące identyfikatora URI punktu końcowego:

   Interfejs wiersza polecenia platformy Azure

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

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

Wdrażanie składnika potoku

Aby wdrożyć składnik potoku, musimy utworzyć wdrożenie wsadowe. Wdrożenie to zestaw zasobów wymaganych do hostowania zasobu, który wykonuje rzeczywistą pracę.

1. Konfigurowanie wdrożenia

   Interfejs wiersza polecenia platformy Azure

   Plik deployment.yml zawiera konfigurację wdrożenia. Możesz sprawdzić pełny schemat YAML punktu końcowego wsadowego pod kątem dodatkowych właściwości.

   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

   Nasz potok jest definiowany w funkcji. Aby przekształcić go w składnik, użyjesz component właściwości . Składniki potoku to grafy obliczeniowe wielokrotnego użytku, które mogą być uwzględniane we wdrożeniach wsadowych lub używane do tworzenia bardziej złożonych potoków.

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

   Teraz możemy zdefiniować wdrożenie:

   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. Tworzenie wdrożenia

   Interfejs wiersza polecenia platformy Azure

   Uruchom następujący kod, aby utworzyć wdrożenie wsadowe w punkcie końcowym wsadowym i ustawić je jako domyślne wdrożenie.

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

   Napiwek

   Zwróć uwagę na użycie flagi --set-default , aby wskazać, że to nowe wdrożenie jest teraz domyślne.

   Python

   To polecenie spowoduje uruchomienie tworzenia wdrożenia i zwrócenie odpowiedzi potwierdzenia podczas tworzenia wdrożenia.

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

   Po utworzeniu skonfigurujmy to nowe wdrożenie jako domyślne:

   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. Wdrożenie jest gotowe do użycia.

Testowanie wdrożenia

Po utworzeniu wdrożenia można przystąpić do odbierania zadań. Wykonaj następujące kroki, aby go przetestować:

1. Nasze wdrożenie wymaga wskazania jednego danych wejściowych i jednego wejściowego literału.

   Interfejs wiersza polecenia platformy Azure

   Plik inputs.yml zawiera definicję zasobu danych wejściowych:

   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

   Definicja zasobu danych wejściowych:

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

   Napiwek

   Aby dowiedzieć się więcej na temat wskazywania danych wejściowych, zobacz Tworzenie zadań i danych wejściowych dla punktów końcowych wsadowych.

2. Wdrożenie domyślne można wywołać w następujący sposób:

   Interfejs wiersza polecenia platformy Azure

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

   Python

   Napiwek

   Jaka jest różnica między parametrem inputs i input podczas wywoływania punktu końcowego?

   Ogólnie rzecz biorąc, można użyć parametru słownika inputs = {} z invoke metodą , aby podać dowolną liczbę wymaganych danych wejściowych do punktu końcowego wsadowego, który zawiera wdrożenie modelu lub wdrożenie potoku.

   W przypadku wdrożenia modelu można użyć parametru input jako krótszego sposobu określania lokalizacji danych wejściowych dla wdrożenia. Takie podejście działa, ponieważ wdrożenie modelu zawsze przyjmuje tylko jedno dane wejściowe.

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

3. Możesz monitorować postęp wyświetlania i przesyłać strumieniowo dzienniki przy użyciu:

   Interfejs wiersza polecenia platformy Azure

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Aby poczekać na zakończenie zadania, uruchom następujący kod:

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

Uzyskiwanie dostępu do danych wyjściowych zadania

Po zakończeniu zadania możemy uzyskać dostęp do jego danych wyjściowych. To zadanie zawiera tylko jedno dane wyjściowe o nazwie scores:

Interfejs wiersza polecenia platformy Azure

Skojarzone wyniki można pobrać przy użyciu polecenia az ml job download.

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

Python

Pobierz wynik:

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

Odczytywanie ocenianych danych:

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

Dane wyjściowe wyglądają następująco:

wiek	płeć	...	thal	przewidywanie
0.9338	1	...	2	0
1.3782	1	...	3	1
1.3782	1	...	100	0
-1.954	1	...	3	0

Dane wyjściowe zawierają przewidywania oraz dane dostarczone do składnika score , który został wstępnie przetworzony. Na przykład kolumna age została znormalizowana, a kolumna thal zawiera oryginalne wartości kodowania. W praktyce prawdopodobnie chcesz wygenerować tylko przewidywanie, a następnie połączyć je z oryginalnymi wartościami. Ta praca została pozostawiona czytelnikowi.

Czyszczenie zasobów

Po zakończeniu usuń skojarzone zasoby z obszaru roboczego:

Interfejs wiersza polecenia platformy Azure

Uruchom następujący kod, aby usunąć punkt końcowy wsadowy i jego bazowe wdrożenie. --yes służy do potwierdzania usunięcia.

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

Python

Usuń punkt końcowy:

ml_client.batch_endpoints.begin_delete(endpoint_name)

(Opcjonalnie) Usuń zasoby obliczeniowe, chyba że planujesz ponownie użyć klastra obliczeniowego z późniejszymi wdrożeniami.

Interfejs wiersza polecenia platformy Azure

az ml compute delete -n batch-cluster

Python

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

Następne kroki

• Tworzenie punktów końcowych wsadowych na podstawie zadań potoku
• Uzyskiwanie dostępu do danych z zadań punktów końcowych wsadowych
• Rozwiązywanie problemów z punktami końcowymi usługi Batch