Självstudie: Skapa ML-pipelines för produktion med Python SDK v2 i en Jupyter-notebook-fil

GÄLLER FÖR: Python SDK azure-ai-ml v2 (aktuell)

Anteckning

En självstudiekurs som använder SDK v1 för att skapa en pipeline finns i Självstudie: Skapa en Azure Machine Learning-pipeline för bildklassificering

I den här självstudien använder du Azure Machine Learning för att skapa ett produktionsklart maskininlärningsprojekt (ML) med Hjälp av Azure Machine Learning Python SDK v2.

Du får lära dig hur du använder Azure Machine Learning Python SDK v2 för att:

• Ansluta till din Azure Machine Learning-arbetsyta
• Skapa Azure Machine Learning-datatillgångar
• Skapa återanvändbara Azure Machine Learning-komponenter
• Skapa, validera och köra Azure Machine Learning-pipelines
• Distribuera den nyligen tränade modellen som en slutpunkt
• Anropa Azure Machine Learning-slutpunkten för slutsatsdragning

Förutsättningar

• Slutför snabbstarten: Kom igång med Azure Machine Learning för att:
  • Skapa en arbetsyta.
  • Skapa en molnbaserad beräkningsinstans som ska användas för din utvecklingsmiljö.
  • Skapa ett molnbaserat beräkningskluster som ska användas för att träna din modell.
• Slutför snabbstarten: Kör Jupyter Notebooks i Studio för att klona mappen SDK v2/tutorials .

Öppna anteckningsboken

1. Öppna mappen tutorials som klonades i avsnittet Filer från snabbstarten: Kör Jupyter Notebooks i studio.

2. Välj filen e2e-ml-workflow.ipynb från mappen tutorials/azureml-examples/tutorials/e2e-ds-experience/ .

   

3. I det övre fältet väljer du den beräkningsinstans som du skapade under snabbstarten: Kom igång med Azure Machine Learning för att använda för att köra notebook-filen.

Viktigt

Resten av den här artikeln innehåller samma innehåll som du ser i anteckningsboken.

Växla till Jupyter Notebook nu om du vill köra koden medan du läser vidare. Om du vill köra en enda kodcell i en notebook-fil klickar du på kodcellen och trycker på Skift+Retur. Du kan också köra hela anteckningsboken genom att välja Kör alla i det övre verktygsfältet

Introduktion

I den här självstudien skapar du en Azure Machine Learning-pipeline för att träna en modell för kreditstandardförutsägelse. Pipelinen hanterar förberedelse, träning och registrering av den tränade modellen. Sedan kör du pipelinen, distribuerar modellen och använder den.

Bilden nedan visar pipelinen som du ser i Azure Machine Learning-portalen när den har skickats. Det är en ganska enkel pipeline som vi använder för att gå igenom Azure Machine Learning SDK v2.

De två stegen är den första dataförberedelsen och den andra träningen.

Konfigurera pipelineresurserna

Azure Machine Learning-ramverket kan användas från CLI, Python SDK eller studiogränssnittet. I det här exemplet använder du Azure Machine Learning Python SDK v2 för att skapa en pipeline.

Innan du skapar pipelinen konfigurerar du de resurser som pipelinen ska använda:

• Datatillgången för träning
• Programvarumiljön för att köra pipelinen
• En beräkningsresurs där jobbet ska köras

Ansluta till arbetsytan

Innan vi går in i koden måste du ansluta till din Azure Machine Learning-arbetsyta. Arbetsytan är resursen på den översta nivån i Azure Machine Learning, och är en central plats där du kan arbeta med alla artefakter du skapar när du använder 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()

I nästa cell anger du ditt prenumerations-ID, resursgruppsnamn och arbetsytenamn. Så här hittar du ditt prenumerations-ID:

1. I det övre högra Azure Machine Learning-studio verktygsfältet väljer du namnet på arbetsytan.
2. Du ser de värden du behöver för <SUBSCRIPTION_ID>, <RESOURCE_GROUP> och <AML_WORKSPACE_NAME>.
3. Kopiera ett värde och stäng sedan fönstret och klistra in det i koden. Öppna verktyget igen för att hämta nästa värde.

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

Resultatet är en hanterare för arbetsytan som du ska använda för att hantera andra resurser och jobb.

Viktigt

Att skapa MLClient ansluter inte till arbetsytan. Klientinitieringen är lat. Den väntar för första gången den behöver göra ett anrop (i notebook-filen nedan sker det under registreringen av datauppsättningen).

Registrera data från en extern URL

De data som du använder för träning finns vanligtvis på någon av platserna nedan:

• Lokal dator
• Webb
• Big Data Storage-tjänster (till exempel Azure Blob, Azure Data Lake Storage, SQL)

Azure Machine Learning använder ett Data objekt för att registrera en återanvändbar definition av data och använda data i en pipeline. I avsnittet nedan använder du vissa data från webb-URL:en som ett exempel. Data från andra källor kan också skapas. Data tillgångar från andra källor kan också skapas.

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

Den här koden har precis skapat en Data tillgång som är redo att användas som indata av pipelinen som du ska definiera i nästa avsnitt. Dessutom kan du registrera data på din arbetsyta så att de kan återanvändas i pipelines.

Genom att registrera datatillgången kan du:

• Återanvänd och dela datatillgången i framtida pipelines
• Använda versioner för att spåra ändringen av datatillgången
• Använd datatillgången från Azure Machine Learning-designern, som är Azure Machine Learnings GUI för pipelineredigering

Eftersom det är första gången du anropar arbetsytan kan du bli ombedd att autentisera. När autentiseringen är klar visas meddelandet om att registreringen av datamängden har slutförts.

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

I framtiden kan du hämta samma datauppsättning från arbetsytan med hjälp av credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>').

Skapa en beräkningsresurs för att köra din pipeline

Varje steg i en Azure Machine Learning-pipeline kan använda en annan beräkningsresurs för att köra det specifika jobbet i det steget. Det kan vara datorer med en eller flera noder med Linux eller Windows OS, eller en specifik beräkningsinfrastruktur som Spark.

I det här avsnittet etablerar du ett Linux-beräkningskluster. Se den fullständiga listan över vm-storlekar och priser .

I den här självstudien behöver du bara ett grundläggande kluster, så vi använder en Standard_DS3_v2-modell med 2 vCPU-kärnor, 7 GB RAM-minne och skapa en Azure Machine Learning Compute.

Tips

Om du redan har ett beräkningskluster ersätter du "cpu-cluster" i koden nedan med namnet på klustret. Detta gör att du inte kan skapa en till.

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

Skapa en jobbmiljö för pipelinesteg

Hittills har du skapat en utvecklingsmiljö på beräkningsinstansen, utvecklingsdatorn. Du behöver också en miljö som ska användas för varje steg i pipelinen. Varje steg kan ha en egen miljö, eller så kan du använda några vanliga miljöer för flera steg.

I det här exemplet skapar du en conda-miljö för dina jobb med hjälp av en conda yaml-fil. Skapa först en katalog som filen ska lagras i.

import os

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

Skapa nu filen i katalogen beroenden.

%%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

Specifikationen innehåller några vanliga paket som du använder i din pipeline (numpy, pip) tillsammans med vissa Azure Machine Learning-specifika paket (azureml-defaults, azureml-mlflow).

Azure Machine Learning-paketen är inte obligatoriska för att köra Azure Machine Learning-jobb. Om du lägger till de här paketen kan du dock interagera med Azure Machine Learning för att logga mått och registrera modeller, allt i Azure Machine Learning-jobbet. Du använder dem i träningsskriptet senare i den här självstudien.

Använd yaml-filen för att skapa och registrera den här anpassade miljön på din arbetsyta:

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/openmpi4.1.0-ubuntu20.04:latest",
    version="0.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}"
)

Skapa träningspipelinen

Nu när du har alla tillgångar som krävs för att köra din pipeline är det dags att skapa själva pipelinen med hjälp av Azure Machine Learning Python SDK v2.

Azure Machine Learning-pipelines är återanvändbara ML-arbetsflöden som vanligtvis består av flera komponenter. Den typiska livslängden för en komponent är:

• Skriv yaml-specifikationen för komponenten eller skapa den programmatiskt med hjälp av ComponentMethod.
• Du kan också registrera komponenten med ett namn och en version på arbetsytan för att göra den återanvändbar och delbar.
• Läs in komponenten från pipelinekoden.
• Implementera pipelinen med komponentens indata, utdata och parametrar
• Skicka pipelinen.

Skapa komponent 1: dataförberedelse (med programmeringsdefinition)

Vi börjar med att skapa den första komponenten. Den här komponenten hanterar förbearbetning av data. Förbearbetningsaktiviteten utförs i python-filen data_prep.py .

Skapa först en källmapp för komponenten data_prep:

import os

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

Det här skriptet utför den enkla uppgiften att dela upp data i tränings- och testdatauppsättningar. Azure Machine Learning monterar datauppsättningar som mappar till beräkningen. Därför skapade vi en extra select_first_file funktion för att komma åt datafilen i den monterade indatamappen.

MLFlow används för att logga parametrar och mått under pipelinekörningen.

%%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 när du har ett skript som kan utföra den önskade uppgiften skapar du en Azure Machine Learning-komponent från den.

Du använder kommandokomponenten för generell användning som kan köra kommandoradsåtgärder. Den här kommandoradsåtgärden kan anropa systemkommandon direkt eller köra ett skript. Indata/utdata anges på kommandoraden via notationen ${{ ... }} .

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

Du kan också registrera komponenten på arbetsytan för framtida återanvändning.

Skapa komponent 2: träning (med yaml-definition)

Den andra komponenten som du skapar använder tränings- och testdata, tränar en trädbaserad modell och returnerar utdatamodellen. Du använder loggningsfunktionerna i Azure Machine Learning för att registrera och visualisera inlärningsstatusen.

Du använde CommandComponent klassen för att skapa din första komponent. Den här gången använder du yaml-definitionen för att definiera den andra komponenten. Varje metod har sina egna fördelar. En yaml-definition kan faktiskt checkas in längs koden och ge en läsbar historikspårning. Den programmatiska metoden som använder CommandComponent kan vara enklare med inbyggd klassdokumentation och kodkomplettering.

Skapa katalogen för den här komponenten:

import os

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

Skapa träningsskriptet i katalogen:

%%writefile {train_src_dir}/train.py
import argparse
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import os
import pandas as pd
import mlflow


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

os.makedirs("./outputs", exist_ok=True)


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

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))

    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Som du ser i det här träningsskriptet sparas modellfilen och registreras på arbetsytan när modellen har tränats. Nu kan du använda den registrerade modellen i slutsatsdragningsslutpunkter.

För miljön i det här steget använder du en av de inbyggda (utvalda) Azure Machine Learning-miljöerna. Taggen azureml, instruerar systemet att leta efter namnet i utvalda miljöer.

Skapa först yaml-filen som beskriver komponenten:

%%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-1.0-ubuntu20.04-py38-cpu:1
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>

Skapa och registrera komponenten:

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

# Loading the component from the yml file
train_component = load_component(source=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"
)

Skapa pipelinen från komponenter

Nu när båda komponenterna har definierats och registrerats kan du börja implementera pipelinen.

Här använder du indata, delningsförhållande och registrerat modellnamn som indatavariabler. Anropa sedan komponenterna och anslut dem via deras indata-/utdataidentifierare. Utdata för varje steg kan nås via egenskapen .outputs .

Python-funktionerna som returneras av load_component() arbete som en vanlig Python-funktion som vi använder i en pipeline för att anropa varje steg.

För att koda pipelinen använder du en specifik @dsl.pipeline dekoratör som identifierar Azure Machine Learning-pipelines. I dekoratören kan vi ange pipelinebeskrivningen och standardresurser som beräkning och lagring. Precis som en Python-funktion kan pipelines ha indata. Du kan sedan skapa flera instanser av en enda pipeline med olika indata.

Här använde vi indata, delningsförhållande och registrerat modellnamn som indatavariabler. Sedan anropar vi komponenterna och ansluter dem via deras indata-/utdataidentifierare. Utdata för varje steg kan nås via egenskapen .outputs .

# 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,
    }

Använd nu din pipelinedefinition för att instansiera en pipeline med din datauppsättning, delningshastighet och det namn som du valde för din modell.

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=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

Skicka jobbet

Nu är det dags att skicka jobbet som ska köras i Azure Machine Learning. Den här gången ska du använda create_or_update på ml_client.jobs.

Här skickar du också ett experimentnamn. Ett experiment är en container för alla iterationer man gör i ett visst projekt. Alla jobb som skickas under samma experimentnamn visas bredvid varandra i Azure Machine Learning-studio.

När du är klar registrerar pipelinen en modell på din arbetsyta som ett resultat av träningen.

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.studio_url)

Utdata från "False" förväntas från cellen ovan. Du kan spåra pipelinens förlopp med hjälp av länken som genereras i cellen ovan.

När du väljer för varje komponent visas mer information om resultatet av komponenten. Det finns två viktiga delar att leta efter i det här skedet:

• Outputs+logs>user_logs>std_log.txt Det här avsnittet visar skriptkörningens sdtout.

  

• Outputs+logs>Metric Det här avsnittet visar olika loggade mått. I det här exemplet. mlflow autologging, har automatiskt loggat träningsmåtten.

  

Distribuera modellen som en onlineslutpunkt

Distribuera nu din maskininlärningsmodell som en webbtjänst i Azure-molnet, en online endpoint. För att distribuera en maskininlärningstjänst behöver du vanligtvis:

• De modelltillgångar (arkiverade, metadata) som du vill distribuera. Du har redan registrerat dessa tillgångar i träningskomponenten.
• Kod som ska köras som en tjänst. Koden kör modellen på en angiven indatabegäran. Det här postskriptet tar emot data som skickas till en distribuerad webbtjänst och skickar dem till modellen och returnerar sedan modellens svar till klienten. Skriptet är specifikt för din modell. Inmatningsskriptet måste förstå de data som modellen förväntar sig och returnerar. När du använder en MLFlow-modell, som i den här självstudien, skapas skriptet automatiskt åt dig

Skapa en ny onlineslutpunkt

Nu när du har en registrerad modell och ett slutsatsdragningsskript är det dags att skapa din onlineslutpunkt. Slutpunktsnamnet måste vara unikt i hela Azure-regionen. I den här självstudien skapar du ett unikt namn med hjälp av 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_result = ml_client.begin_create_or_update(endpoint).result()

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

När du har skapat en slutpunkt kan du hämta den enligt nedan:

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

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

Distribuera modellen till slutpunkten

När slutpunkten har skapats distribuerar du modellen med postskriptet. Varje slutpunkt kan ha flera distributioner och direkttrafik till dessa distributioner kan anges med hjälp av regler. Här skapar du en enda distribution som hanterar 100 % av den inkommande trafiken. Vi har valt ett färgnamn för distributionen, till exempel blå, grön, röd distribution, vilket är godtyckligt.

Du kan kontrollera sidan Modeller på Azure Machine Learning-studio för att identifiera den senaste versionen av din registrerade modell. Alternativt hämtar koden nedan det senaste versionsnumret som du kan använda.

# 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)]
)

Distribuera den senaste versionen av modellen.

Anteckning

Förvänta dig att den här distributionen tar cirka 6 till 8 minuter.

# 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_F4s_v2",
    instance_count=1,
)

blue_deployment_results = ml_client.online_deployments.begin_create_or_update(
    blue_deployment
).result()

print(
    f"Deployment {blue_deployment_results.name} provisioning state: {blue_deployment_results.provisioning_state}"
)

Testa med en exempelfråga

Nu när modellen har distribuerats till slutpunkten kan du köra slutsatsdragning med den.

Skapa en exempelbegärandefil som följer den design som förväntas i körningsmetoden i poängskriptet.

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

Rensa resurser

Om du inte ska använda slutpunkten tar du bort den för att sluta använda resursen. Kontrollera att inga andra distributioner använder en slutpunkt innan du tar bort den.

Anteckning

Förvänta dig att det här steget tar cirka 6 till 8 minuter.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Nästa steg

Läs mer om Azure Machine Learning-loggning.