Zelfstudie: ML-pijplijnen voor productie maken met Python SDK v2 (preview) in een Jupyter-notebook

VAN TOEPASSING OP: Python SDK azure-ai-ml v2 (preview)

Belangrijk

SDK v2 is momenteel beschikbaar als openbare preview. De preview-versie wordt aangeboden zonder Service Level Agreement en wordt niet aanbevolen voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Supplemental Terms of Use for Microsoft Azure Previews (Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews) voor meer informatie.

Notitie

Zie Zelfstudie: Een Azure Machine Learning-pijplijn bouwen voor afbeeldingsclassificatie voor een zelfstudie die gebruikmaakt van SDK v1 voor het bouwen van een pijplijn

In deze zelfstudie gebruikt u Azure Machine Learning (Azure ML) om een machine learning-project (ML) voor productie te maken met behulp van AzureML Python SDK v2 (preview).

U leert hoe u de AzureML Python SDK v2 gebruikt voor het volgende:

  • Verbinding maken met uw Azure ML-werkruimte
  • Azure ML-gegevensassets maken
  • Herbruikbare Azure ML-onderdelen maken
  • Azure ML-pijplijnen maken, valideren en uitvoeren
  • Het zojuist getrainde model implementeren als eindpunt
  • Het Azure ML-eindpunt aanroepen voor deductie

Vereisten

  • Voltooi de quickstart: Aan de slag met Azure Machine Learning om:
    • Maak een werkruimte.
    • Maak een rekenproces in de cloud dat u wilt gebruiken voor uw ontwikkelomgeving.
    • Maak een rekencluster in de cloud dat u wilt gebruiken voor het trainen van uw model.

De SDK installeren

U voert de volgende installatie van het experiment uit en voert stappen uit in Azure Machine Learning-studio. Deze geconsolideerde interface bevat machine learning-hulpprogramma's voor het uitvoeren van datawetenschap-scenario's voor datawetenschappers van alle vaardigheidsniveaus.

Eerst installeert u de v2 SDK op uw rekeninstantie:

  1. Meld u aan bij Azure Machine Learning Studio.

  2. Selecteer het abonnement en de werkruimte die u hebt gemaakt als onderdeel van de vereisten.

  3. Selecteer Aan de linkerkant Compute.

  4. Zoek in de lijst met rekenexemplaren het exemplaar dat u hebt gemaakt.

  5. Selecteer Terminal om de terminalsessie op het rekenproces te openen.

  6. Installeer in het terminalvenster Python SDK v2 (preview) met deze opdracht:

    pip install --pre azure-ai-ml
    

    Zie De Python SDK v2 installeren voor meer informatie.

De opslagplaats azureml-examples klonen

  1. Voer nu in de terminal de opdracht uit:

    git clone --depth 1 https://github.com/Azure/azureml-examples
    
  2. Selecteer aan de linkerkant Notebooks.

  3. Selecteer nu aan de linkerkant de bestanden

    Schermopname van de map zelfstudies voor Klonen.

  4. Er wordt een lijst met mappen weergegeven, met de verschillende gebruikers die toegang hebben tot de werkruimte. Selecteer uw map. U vindt dat azureml-samples zijn gekloond.

Het gekloonde notebook openen

  1. Open de map met zelfstudies die is gekloond in de sectie Gebruikersbestanden .

  2. Selecteer het bestand e2e-ml-workflow.ipynb in uw map azureml-examples/tutorials/e2e-ds-experience/ .

    Schermopname van de map met geopende zelfstudies.

  3. Selecteer op de bovenste balk het rekenproces dat u hebt gemaakt tijdens de quickstart: Aan de slag met Azure Machine Learning om het notebook uit te voeren.

Belangrijk

De rest van dit artikel bevat dezelfde inhoud als die u ziet in de notebook.

Schakel nu over naar de Jupyter Notebook als u de code wilt uitvoeren terwijl u verder leest. Als u één codecel in een notebook wilt uitvoeren, klikt u op de codecel en drukt u op Shift+Enter. Of voer het hele notitieblok uit door Alles uitvoeren te kiezen vanaf de bovenste werkbalk

Introductie

In deze zelfstudie maakt u een Azure ML-pijplijn om een model te trainen voor standaardvoorspelling van tegoed. De pijplijn verwerkt de gegevensvoorbereiding, training en registratie van het getrainde model. Vervolgens voert u de pijplijn uit, implementeert u het model en gebruikt u het.

In de onderstaande afbeelding ziet u de pijplijn, zoals u deze ziet in de AzureML-portal zodra deze is verzonden. Het is een vrij eenvoudige pijplijn die we gebruiken om u door de AzureML SDK v2 te leiden.

De twee stappen zijn de eerste gegevensvoorbereiding en tweede training.

Diagram toont een overzicht van de pijplijn.

De pijplijnbronnen instellen

Het Azure ML-framework kan worden gebruikt vanuit de CLI, Python SDK of studio-interface. In dit voorbeeld gebruikt u de AzureML Python SDK v2 om een pijplijn te maken.

Voordat u de pijplijn maakt, stelt u de resources in die door de pijplijn worden gebruikt:

  • De gegevensasset voor training
  • De softwareomgeving voor het uitvoeren van de pijplijn
  • Een rekenresource naar de locatie waar de taak wordt uitgevoerd

Verbinding maken met de werkruimte

Voordat we de code induiken, moet u verbinding maken met uw Azure ML-werkruimte. De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Voer in de volgende cel uw abonnements-id, de naam van de resourcegroep en de naam van de werkruimte in. Uw abonnements-id zoeken:

  1. Selecteer in de rechterbovenhoek Azure Machine Learning-studio werkbalk de naam van uw werkruimte.
  2. U ziet de waarden die u nodig hebt voor <SUBSCRIPTION_ID>, <RESOURCE_GROUP> en <AML_WORKSPACE_NAME>.
  3. Kopieer een waarde en sluit het venster en plak dit in uw code. Open het hulpprogramma opnieuw om de volgende waarde op te halen.

Schermopname van het vinden van waarden die nodig zijn voor uw code.

# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

Het resultaat is een handler voor de werkruimte die u gebruikt om andere resources en taken te beheren.

Belangrijk

Het maken van MLClient maakt geen verbinding met de werkruimte. De initialisatie van de client is lui, het wacht tot de eerste keer dat het een aanroep moet doen (in het onderstaande notebook, dat gebeurt tijdens de registratie van de gegevensset).

Gegevens registreren vanuit een externe URL

De gegevens die u voor training gebruikt, bevinden zich meestal op een van de onderstaande locaties:

  • Lokale machine
  • Web
  • Big Data Storage-services (bijvoorbeeld Azure Blob, Azure Data Lake Storage, SQL)

Azure ML gebruikt een Data object om een herbruikbare definitie van gegevens te registreren en gegevens in een pijplijn te gebruiken. In de onderstaande sectie gebruikt u enkele gegevens uit de web-URL als voorbeeld. Gegevens uit andere bronnen kunnen ook worden gemaakt. Data assets van andere bronnen kunnen ook worden gemaakt.

from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes

web_path = "https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls"

credit_data = Data(
    name="creditcard_defaults",
    path=web_path,
    type=AssetTypes.URI_FILE,
    description="Dataset for credit card defaults",
    tags={"source_type": "web", "source": "UCI ML Repo"},
    version="1.0.0",
)

Met deze code hebt u zojuist een Data asset gemaakt, klaar om te worden gebruikt als invoer door de pijplijn die u in de volgende secties definieert. Daarnaast kunt u de gegevens registreren bij uw werkruimte, zodat deze herbruikbaar worden in pijplijnen.

Als u de gegevensasset registreert, kunt u het volgende doen:

  • De gegevensasset opnieuw gebruiken en delen in toekomstige pijplijnen
  • Versies gebruiken om de wijziging in de gegevensasset bij te houden
  • Gebruik de gegevensasset van Azure ML Designer. Dit is de GUI van Azure ML voor het ontwerpen van pijplijnen

Omdat dit de eerste keer is dat u een aanroep naar de werkruimte maakt, wordt u mogelijk gevraagd om te verifiëren. Zodra de verificatie is voltooid, ziet u het bericht over voltooiing van de gegevenssetregistratie.

credit_data = ml_client.data.create_or_update(credit_data)
print(
    f"Dataset with name {credit_data.name} was registered to workspace, the dataset version is {credit_data.version}"
)

In de toekomst kunt u dezelfde gegevensset ophalen uit de werkruimte met behulp van credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>').

Een rekenresource maken om uw pijplijn uit te voeren

Elke stap van een Azure ML-pijplijn kan een andere rekenresource gebruiken voor het uitvoeren van de specifieke taak van die stap. Dit kunnen machines met één of meerdere knooppunten zijn met Linux of windows, of een specifieke rekeninfrastructuur zoals Spark.

In deze sectie richt u een Linux-rekencluster in. Bekijk de volledige lijst met VM-grootten en prijzen .

Voor deze zelfstudie hebt u alleen een basiscluster nodig. Daarom gebruiken we een Standard_DS3_v2 model met 2 vCPU-kernen, 7 GB RAM en maken we een Azure ML Compute.

Tip

Als u al een rekencluster hebt, vervangt u 'cpu-cluster' in de onderstaande code door de naam van uw cluster. Dit zorgt ervoor dat u geen andere kunt maken.

from azure.ai.ml.entities import AmlCompute

cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="cpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )

    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.begin_create_or_update(cpu_cluster)

print(
    f"AMLCompute with name {cpu_cluster.name} is created, the compute size is {cpu_cluster.size}"
)

Een taakomgeving maken voor pijplijnstappen

Tot nu toe hebt u een ontwikkelomgeving gemaakt op het rekenproces, uw ontwikkelcomputer. U hebt ook een omgeving nodig die moet worden gebruikt voor elke stap van de pijplijn. Elke stap kan een eigen omgeving hebben of u kunt enkele algemene omgevingen gebruiken voor meerdere stappen.

In dit voorbeeld maakt u een Conda-omgeving voor uw taken met behulp van een Conda Yaml-bestand. Maak eerst een map waarin het bestand moet worden opgeslagen.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Maak nu het bestand in de map met afhankelijkheden.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0

De specificatie bevat enkele gebruikelijke pakketten die u in uw pijplijn (numpy, pip) gaat gebruiken, samen met enkele azure ML-specifieke pakketten (azureml-defaults, azureml-mlflow).

De Azure ML-pakketten zijn niet verplicht om Azure ML-taken uit te voeren. Door deze pakketten toe te voegen, kunt u echter communiceren met Azure ML voor het vastleggen van metrische gegevens en het registreren van modellen, allemaal binnen de Azure ML-taak. U gebruikt deze later in deze zelfstudie in het trainingsscript.

Gebruik het yaml-bestand om deze aangepaste omgeving in uw werkruimte te maken en te registreren:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
    version="1.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

De trainingspijplijn bouwen

Nu u alle assets hebt die nodig zijn om uw pijplijn uit te voeren, is het tijd om de pijplijn zelf te bouwen met behulp van de Azure ML Python SDK v2.

Azure ML-pijplijnen zijn herbruikbare ML-werkstromen die meestal uit verschillende onderdelen bestaan. De typische levensduur van een onderdeel is:

  • Schrijf de yaml-specificatie van het onderdeel of maak het programmatisch met behulp van ComponentMethod.
  • U kunt het onderdeel desgewenst registreren met een naam en versie in uw werkruimte, zodat het opnieuw kan worden gebruikt en kan worden gedeeld.
  • Laad dat onderdeel uit de pijplijncode.
  • De pijplijn implementeren met behulp van de invoer, uitvoer en parameters van het onderdeel
  • Verzend de pijplijn.

Onderdeel 1 maken: gegevensvoorbereiding (met behulp van programmatische definitie)

Laten we beginnen met het maken van het eerste onderdeel. Dit onderdeel verwerkt de voorverwerking van de gegevens. De voorverwerkingstaak wordt uitgevoerd in het python-bestand data_prep.py .

Maak eerst een bronmap voor het onderdeel data_prep:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Met dit script wordt de eenvoudige taak uitgevoerd om de gegevens op te splitsen in gegevenssets trainen en testen. Azure ML koppelt gegevenssets als mappen aan de berekeningen. Daarom hebben we een hulpfunctie select_first_file gemaakt voor toegang tot het gegevensbestand in de gekoppelde invoermap.

MLFlow wordt gebruikt om de parameters en metrische gegevens te registreren tijdens de pijplijnuitvoering.

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_excel(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Nu u een script hebt dat de gewenste taak kan uitvoeren, maakt u er een Azure ML-onderdeel van.

U gebruikt commandcomponent voor algemeen gebruik waarmee opdrachtregelacties kunnen worden uitgevoerd. Met deze opdrachtregelactie kunt u systeemopdrachten rechtstreeks aanroepen of een script uitvoeren. De invoer/uitvoer wordt opgegeven op de opdrachtregel via de ${{ ... }} notatie.

from azure.ai.ml import command
from azure.ai.ml import Input, Output

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Registreer eventueel het onderdeel in de werkruimte voor toekomstig hergebruik.

Onderdeel 2 maken: training (met yaml-definitie)

Het tweede onderdeel dat u maakt, verbruikt de training en testgegevens, traint een model op basis van een structuur en retourneert het uitvoermodel. U gebruikt azure ML-logboekregistratiemogelijkheden om de leervoortgang vast te leggen en te visualiseren.

U hebt de CommandComponent klasse gebruikt om uw eerste onderdeel te maken. Deze keer gebruikt u de yaml-definitie om het tweede onderdeel te definiëren. Elke methode heeft zijn eigen voordelen. Een yaml-definitie kan daadwerkelijk worden ingecheckt langs de code en zou een leesbare geschiedenistracering bieden. De programmatische methode die wordt gebruikt CommandComponent , kan eenvoudiger zijn met ingebouwde klassedocumentatie en het voltooien van code.

Maak de map voor dit onderdeel:

import os

train_src_dir = "./components/train"
os.makedirs(train_src_dir, exist_ok=True)

Zoals u in dit trainingsscript kunt zien, wordt het modelbestand opgeslagen en geregistreerd bij de werkruimte zodra het model is getraind. U kunt nu het geregistreerde model gebruiken in deductie-eindpunten.

Voor de omgeving van deze stap gebruikt u een van de ingebouwde (gecureerde) Azure ML-omgevingen. De tag azuremlgeeft aan dat het systeem moet zoeken naar de naam in gecureerde omgevingen.

Maak eerst het YAML-bestand met een beschrijving van het onderdeel:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:21
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Maak en registreer nu het onderdeel:

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(path=os.path.join(train_src_dir, "train.yml"))
# Now we register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create (register) the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

De pijplijn maken van onderdelen

Nu beide onderdelen zijn gedefinieerd en geregistreerd, kunt u beginnen met het implementeren van de pijplijn.

Hier gebruikt u invoergegevens, split ratio en geregistreerde modelnaam als invoervariabelen. Roep vervolgens de onderdelen aan en verbind ze via hun invoer-/uitvoer-id's. De uitvoer van elke stap kan worden geopend via de .outputs eigenschap.

De Python-functies die worden geretourneerd door load_component() te werken als een gewone Python-functie die we in een pijplijn gebruiken om elke stap aan te roepen.

Als u de pijplijn wilt coderen, gebruikt u een specifieke @dsl.pipeline decorator die de Azure ML-pijplijnen identificeert. In de decorator kunnen we de beschrijving van de pijplijn en standaardresources, zoals compute en opslag, opgeven. Net als bij een Python-functie kunnen pijplijnen invoer hebben. Vervolgens kunt u meerdere exemplaren van één pijplijn met verschillende invoer maken.

Hier hebben we invoergegevens gebruikt, split ratio en geregistreerde modelnaam als invoervariabelen. Vervolgens roepen we de onderdelen aan en verbinden ze via hun invoer-/uitvoer-id's. De uitvoer van elke stap kan worden geopend via de .outputs eigenschap.

# the dsl decorator tells the sdk that we are defining an Azure ML pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute=cpu_compute_target,
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Gebruik nu uw pijplijndefinitie om een pijplijn te instantiëren met uw gegevensset, splitssnelheid en de naam die u hebt gekozen voor uw model.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    # pipeline_job_data_input=credit_data,
    pipeline_job_data_input=Input(type="uri_file", path=web_path),
    pipeline_job_test_train_ratio=0.2,
    pipeline_job_learning_rate=0.25,
    pipeline_job_registered_model_name=registered_model_name,
)

De taak verzenden

Het is nu tijd om de taak te verzenden om te worden uitgevoerd in Azure ML. Deze keer gebruikt u deze keercreate_or_update.ml_client.jobs

Hier geeft u ook een experimentnaam door. Een experiment is een container voor alle iteraties die één voor een bepaald project doet. Alle taken die onder dezelfde experimentnaam worden ingediend, worden naast elkaar weergegeven in Azure ML Studio.

Zodra de pijplijn is voltooid, registreert de pijplijn een model in uw werkruimte als gevolg van de training.

import webbrowser

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
# open the pipeline in web browser
webbrowser.open(pipeline_job.services["Studio"].endpoint)

Er wordt een uitvoer van False verwacht uit de bovenstaande cel. U kunt de voortgang van uw pijplijn bijhouden met behulp van de koppeling die in de bovenstaande cel is gegenereerd.

Wanneer u voor elk onderdeel selecteert, ziet u meer informatie over de resultaten van dat onderdeel. Er zijn twee belangrijke onderdelen om in deze fase naar te kijken:

  • Outputs+logs>user_logs>std_log.txt In deze sectie ziet u de scriptuitvoering sdtout.

    Schermopname van std_log.txt.

  • Outputs+logs>Metric In deze sectie worden verschillende geregistreerde metrische gegevens weergegeven. In dit voorbeeld. mlflow autologging, heeft automatisch de metrische trainingsgegevens geregistreerd.

    Schermopname van geregistreerde metrics.txt.

Het model implementeren als een online-eindpunt

Implementeer nu uw machine learning-model als een webservice in de Azure-cloud, een online endpoint. Voor het implementeren van een machine learning-service hebt u meestal het volgende nodig:

  • De modelassets (opgeslagen, metagegevens) die u wilt implementeren. U hebt deze assets al geregistreerd in uw trainingsonderdeel.
  • Code die moet worden uitgevoerd als een service. De code voert het model uit op een bepaalde invoeraanvraag. Dit invoerscript ontvangt gegevens die zijn verzonden naar een geïmplementeerde webservice en geeft deze door aan het model en retourneert vervolgens het antwoord van het model op de client. Het script is specifiek voor uw model. Het invoerscript moet de gegevens begrijpen die het model verwacht en retourneert. Wanneer u een MLFlow-model gebruikt, zoals in deze zelfstudie, wordt dit script automatisch voor u gemaakt

Een nieuw online-eindpunt maken

Nu u een geregistreerd model en een deductiescript hebt, is het tijd om uw online-eindpunt te maken. De eindpuntnaam moet uniek zijn in de hele Azure-regio. Voor deze zelfstudie maakt u een unieke naam met behulp van UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.begin_create_or_update(endpoint)

print(f"Endpint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Zodra u een eindpunt hebt gemaakt, kunt u het ophalen zoals hieronder:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Het model implementeren op het eindpunt

Zodra het eindpunt is gemaakt, implementeert u het model met het invoerscript. Elk eindpunt kan meerdere implementaties hebben en verkeer naar deze implementaties doorsturen met behulp van regels. Hier maakt u één implementatie die 100% van het binnenkomende verkeer verwerkt. We hebben een kleurnaam gekozen voor de implementatie, bijvoorbeeld blauwe, groene, rode implementaties, die willekeurig zijn.

U kunt de pagina Modellen in Azure ML Studio controleren om de nieuwste versie van uw geregistreerde model te identificeren. U kunt ook met de onderstaande code het meest recente versienummer ophalen dat u kunt gebruiken.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)

Implementeer de nieuwste versie van het model.

Notitie

Verwacht dat deze implementatie ongeveer 6 tot 8 minuten duurt.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment)

Testen met een voorbeeldquery

Nu het model is geïmplementeerd op het eindpunt, kunt u hiermee deductie uitvoeren.

Maak een voorbeeldaanvraagbestand volgens het ontwerp dat wordt verwacht in de uitvoeringsmethode in het scorescript.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)
%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}
# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Resources opschonen

Als u het eindpunt niet gaat gebruiken, verwijdert u het om te stoppen met het gebruik van de resource. Zorg ervoor dat er geen andere implementaties een eindpunt gebruiken voordat u het verwijdert.

Notitie

Verwacht dat deze stap ongeveer 6 tot 8 minuten duurt.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Volgende stappen

Meer informatie over Azure ML-logboekregistratie.