Kurz: Vytvoření produkčních kanálů ML pomocí sady Python SDK v2 v poznámkovém bloku Jupyter

PLATÍ PRO: Python SDK azure-ai-ml v2 (aktuální)

Poznámka

Kurz, který používá sadu SDK v1 k sestavení kanálu, najdete v tématu Kurz: Vytvoření kanálu Azure Machine Learning pro klasifikaci obrázků

V tomto kurzu použijete Azure Machine Learning (Azure ML) k vytvoření projektu strojového učení připraveného pro produkční prostředí (ML) pomocí sady AzureML Python SDK v2.

Naučíte se používat sadu AzureML Python SDK v2 k:

  • Připojení k pracovnímu prostoru Azure ML
  • Vytvoření datových prostředků Azure ML
  • Vytváření opakovaně použitelných komponent Azure ML
  • Vytváření, ověřování a spouštění kanálů Azure ML
  • Nasazení nově natrénovaného modelu jako koncového bodu
  • Volání koncového bodu Azure ML pro odvozování

Požadavky

Otevření poznámkového bloku

  1. Otevřete složku kurzů , která byla naklonována do oddílu Soubory z rychlého startu: Spusťte poznámkové bloky Jupyter v studiu.

  2. V kurzech/azureml-examples/tutorials/e2e-ds-experience/ vyberte soubor e2e-ml-workflow.ipynb/.

    Snímek obrazovky znázorňující otevřenou složku kurzů

  3. Na horním panelu vyberte výpočetní instanci, kterou jste vytvořili během rychlého startu: Začínáme se službou Azure Machine Learning , kterou chcete použít ke spuštění poznámkového bloku.

Důležité

Zbytek tohoto článku obsahuje stejný obsah jako v poznámkovém bloku.

Pokud chcete kód spustit během čtení, přepněte na Jupyter Notebook teď. Pokud chcete v poznámkovém bloku spustit jednu buňku kódu, klikněte na buňku kódu a stiskněte Shift+Enter. Nebo spusťte celý poznámkový blok výběrem možnosti Spustit vše z horního panelu nástrojů.

Úvod

V tomto kurzu vytvoříte kanál Azure ML pro trénování modelu pro výchozí predikci kreditu. Kanál zpracovává přípravu dat, trénování a registraci vytrénovaného modelu. Potom kanál spustíte, nasadíte model a použijete ho.

Následující obrázek ukazuje kanál, jak ho uvidíte na portálu AzureML po odeslání. Je to poměrně jednoduchý kanál, který vás provedeme sadou AzureML SDK verze 2.

Dva kroky jsou první příprava dat a druhý trénování.

Diagram znázorňuje přehled kanálu.

Nastavení prostředků kanálu

Rozhraní Azure ML je možné použít z rozhraní příkazového řádku, sady Python SDK nebo studia. V tomto příkladu použijete sadu AzureML Python SDK v2 k vytvoření kanálu.

Před vytvořením kanálu nastavíte prostředky, které kanál použije:

  • Datový prostředek pro trénování
  • Softwarové prostředí pro spuštění kanálu
  • Výpočetní prostředek, do kterého se úloha spustí

Připojení k pracovnímu prostoru

Než se podíváme do kódu, budete se muset připojit k pracovnímu prostoru Azure ML. Pracovní prostor je prostředek nejvyšší úrovně pro Azure Machine Learning, který nabízí centralizované místo, kde můžete pracovat se všemi artefakty, které vytvoříte při použití služby 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()

Do další buňky zadejte ID předplatného, název skupiny prostředků a název pracovního prostoru. Jak najít ID předplatného:

  1. V pravém horním studio Azure Machine Learning panelu nástrojů vyberte název pracovního prostoru.
  2. Zobrazí se hodnoty, které potřebujete pro <SUBSCRIPTION_ID>, <RESOURCE_GROUP> a <AML_WORKSPACE_NAME>.
  3. Zkopírujte hodnotu a zavřete okno a vložte ho do kódu. Dalším otevřením nástroje získáte další hodnotu.

Snímek obrazovky ukazuje, jak najít hodnoty potřebné pro váš kód.

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

Výsledkem je obslužná rutina pracovního prostoru, který použijete ke správě dalších prostředků a úloh.

Důležité

Vytvoření mlClient se nepřipojí k pracovnímu prostoru. Inicializace klienta je opožděná, bude čekat na první volání (v poznámkovém bloku níže, který se stane během registrace datové sady).

Registrace dat z externí adresy URL

Data, která používáte pro trénování, jsou obvykle v jednom z následujících umístění:

  • Místní počítač
  • Web
  • Služby Pro velké objemy dat (například Azure Blob, Azure Data Lake Storage, SQL)

Azure ML používá Data objekt k registraci opakovaně použitelné definice dat a využívání dat v rámci kanálu. V následující části použijete některá data z webové adresy URL jako jeden příklad. Data z jiných zdrojů je také možné vytvořit. Data prostředky z jiných zdrojů je možné vytvořit také.

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

Tento kód právě vytvořil Data prostředek, připravený k použití jako vstup kanálem, který definujete v dalších částech. Kromě toho můžete data zaregistrovat do svého pracovního prostoru, aby byla opakovaně použitelná napříč kanály.

Registrace datového prostředku vám umožní:

  • Opakované použití a sdílení datového prostředku v budoucích kanálech
  • Použití verzí ke sledování změny datového prostředku
  • Použijte datový prostředek z návrháře Azure ML, což je grafické uživatelské rozhraní Azure ML pro vytváření kanálů.

Vzhledem k tomu, že se jedná o první volání pracovního prostoru, můžete být požádáni o ověření. Po dokončení ověřování se zobrazí zpráva o dokončení registrace datové sady.

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

V budoucnu můžete ze stejného pracovního prostoru načíst stejnou datovou sadu pomocí credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>').

Vytvoření výpočetního prostředku pro spuštění kanálu

Každý krok kanálu Azure ML může pro spuštění konkrétní úlohy tohoto kroku použít jiný výpočetní prostředek. Může se jednat o počítače s jedním nebo více uzly s operačním systémem Linux nebo Windows nebo konkrétní výpočetní prostředky infrastruktury, jako je Spark.

V této části zřídíte výpočetní cluster s Linuxem. Prohlédněte si úplný seznam velikostí a cen virtuálních počítačů .

Pro účely tohoto kurzu potřebujete jenom základní cluster, takže použijeme model Standard_DS3_v2 se 2 jádry vCPU, 7 GB PAMĚTI RAM a vytvoříme výpočetní prostředí Azure ML.

Tip

Pokud už máte výpočetní cluster, nahraďte "cpu-cluster" v následujícím kódu názvem vašeho clusteru. Díky tomu nebudete vytvářet další.

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

Vytvoření prostředí úlohy pro kroky kanálu

Zatím jste vytvořili vývojové prostředí ve výpočetní instanci, ve vašem vývojovém počítači. Budete také potřebovat prostředí, které se má použít pro každý krok kanálu. Každý krok může mít vlastní prostředí nebo můžete použít některá běžná prostředí pro několik kroků.

V tomto příkladu vytvoříte prostředí conda pro vaše úlohy pomocí souboru conda yaml. Nejprve vytvořte adresář pro uložení souboru.

import os

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

Teď vytvořte soubor v adresáři závislostí.

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

Specifikace obsahuje některé obvyklé balíčky, které použijete v kanálu (numpy, pip), společně s některými konkrétními balíčky Azure ML (azureml-defaults, azureml-mlflow).

Balíčky Azure ML nejsou povinné ke spouštění úloh Azure ML. Přidání těchto balíčků vám ale umožní pracovat s Azure ML pro protokolování metrik a registraci modelů, a to vše v rámci úlohy Azure ML. Použijete je v trénovacím skriptu později v tomto kurzu.

Pomocí souboru yaml vytvořte a zaregistrujte toto vlastní prostředí ve vašem pracovním prostoru:

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

Sestavení trénovacího kanálu

Teď, když máte všechny prostředky potřebné ke spuštění kanálu, je čas vytvořit samotný kanál pomocí sady Azure ML Python SDK v2.

Kanály Azure ML jsou opakovaně použitelné pracovní postupy ML, které se obvykle skládají z několika komponent. Typickým životem komponenty je:

  • Napište specifikaci yaml komponenty nebo ji vytvořte programově pomocí ComponentMethod.
  • Volitelně můžete zaregistrovat komponentu s názvem a verzí v pracovním prostoru, aby byla opakovaně použitelná a sdílená.
  • Načtěte danou komponentu z kódu kanálu.
  • Implementace kanálu pomocí vstupů, výstupů a parametrů komponenty
  • Odešlete kanál.

Vytvoření komponenty 1: příprava dat (pomocí programové definice)

Začněme vytvořením první komponenty. Tato komponenta zpracovává předběžné zpracování dat. Úloha předběžného zpracování se provádí v souboru pythonu data_prep.py .

Nejprve vytvořte zdrojovou složku pro komponentu data_prep:

import os

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

Tento skript provádí jednoduchou úlohu rozdělení dat na trénovací a testovací datové sady. Azure ML připojí datové sady jako složky k výpočetním prostředkům, a proto jsme vytvořili pomocnou select_first_file funkci pro přístup k datovému souboru uvnitř připojené vstupní složky.

MlFlow se použije k protokolování parametrů a metrik během spuštění kanálu.

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

Teď, když máte skript, který může provést požadovanou úlohu, vytvořte z ní komponentu Azure ML.

Použijete příkaz CommandComponent pro obecné účely, který může spouštět akce příkazového řádku. Tato akce příkazového řádku může přímo volat systémové příkazy nebo spustit skript. Vstupy a výstupy se zadají na příkazovém řádku prostřednictvím zápisu ${{ ... }} .

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

Volitelně můžete komponentu zaregistrovat v pracovním prostoru pro budoucí opětovné použití.

Vytvoření komponenty 2: trénování (pomocí definice yaml)

Druhá komponenta, kterou vytvoříte, bude využívat trénovací a testovací data, vytrénovat stromový model a vrátit výstupní model. Pomocí funkcí protokolování Azure ML zaznamenáte a vizualizujete průběh učení.

Třídu jste použili CommandComponent k vytvoření první komponenty. Tentokrát použijete definici yaml k definování druhé komponenty. Každá metoda má své vlastní výhody. Definice yaml se dá ve skutečnosti vrátit se změnami v kódu a poskytnout čitelné sledování historie. Programová metoda použití CommandComponent může být jednodušší s integrovanou dokumentací třídy a dokončováním kódu.

Vytvořte adresář pro tuto komponentu:

import os

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

Jak vidíte v tomto trénovacím skriptu, po natrénování modelu se soubor modelu uloží a zaregistruje do pracovního prostoru. Teď můžete použít registrovaný model při odvozování koncových bodů.

Pro prostředí tohoto kroku použijete jedno z předdefinovaných (kurátorovaných) prostředí Azure ML. azuremlZnačka říká systému, aby používal název v kurátorovanýchprostředích

Nejprve vytvořte soubor yaml popisující komponentu:

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

Teď vytvořte a zaregistrujte komponentu:

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

Vytvoření kanálu z komponent

Teď, když jsou obě komponenty definované a registrované, můžete začít implementovat kanál.

Tady použijete vstupní data, poměr rozdělení a registrovaný název modelu jako vstupní proměnné. Potom volejte komponenty a připojte je pomocí jejich vstupů/výstupních identifikátorů. Výstupy jednotlivých kroků jsou přístupné prostřednictvím .outputs vlastnosti.

Funkce Pythonu vrácené load_component() prací jako libovolná běžná funkce Pythonu, kterou použijeme v rámci kanálu k volání jednotlivých kroků.

K kódování kanálu použijete konkrétní @dsl.pipeline dekorátor, který identifikuje kanály Azure ML. V dekorátoru můžeme zadat popis kanálu a výchozí prostředky, jako jsou výpočetní prostředky a úložiště. Stejně jako funkce Pythonu můžou kanály obsahovat vstupy. Pak můžete vytvořit více instancí jednoho kanálu s různými vstupy.

Tady jsme jako vstupní proměnné použili vstupní data, poměr rozdělení a registrovaný název modelu . Potom zavoláme komponenty a připojíme je pomocí jejich vstupů/výstupních identifikátorů. Výstupy jednotlivých kroků jsou přístupné prostřednictvím .outputs vlastnosti.

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

Teď pomocí definice kanálu vytvořte instanci kanálu s datovou sadou, rozdělte míru výběru a název, který jste vybrali pro svůj 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=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,
)

Odeslání úlohy

Teď je čas odeslat úlohu, která se má spustit v Azure ML. Tentokrát budete používat create_or_updateml_client.jobs.

Tady také předáte název experimentu. Experiment je kontejner pro všechny iterace, které provádí v určitém projektu. Všechny úlohy odeslané pod stejným názvem experimentu by byly uvedené vedle sebe v nástroji Azure ML Studio.

Po dokončení kanál zaregistruje v pracovním prostoru model v důsledku trénování.

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)

Výstup "False" se očekává z výše uvedené buňky. Průběh kanálu můžete sledovat pomocí odkazu vygenerovaného v buňce výše.

Když vyberete jednotlivé komponenty, zobrazí se další informace o výsledcích této komponenty. V této fázi je potřeba hledat dvě důležité části:

  • Outputs+logs>user_logs>std_log.txt V této části se zobrazí skript, který spouští sdtout.

    Snímek obrazovky std_log.txt

  • Outputs+logs>Metric Tato část zobrazuje různé protokolované metriky. V tomto příkladu. mlflow autologging, automaticky protokoloval trénovací metriky.

    Snímek obrazovky ukazuje protokolovaný metrics.txt.

Nasazení modelu jako online koncového bodu

Teď nasaďte model strojového učení jako webovou službu v cloudu Azure a online endpoint. K nasazení služby machine learning obvykle potřebujete:

  • Prostředky modelu (soubor, metadata), které chcete nasadit. Tyto prostředky jste už zaregistrovali ve své trénovací komponentě.
  • Nějaký kód, který se má spustit jako služba Kód spustí model na zadaném vstupním požadavku. Tento vstupní skript obdrží data odeslaná do nasazené webové služby a předá je do modelu a pak vrátí odpověď modelu klientovi. Skript je specifický pro váš model. Vstupní skript musí rozumět datům, která model očekává a vrací. Při použití modelu MLFlow, jak je uvedeno v tomto kurzu, se tento skript automaticky vytvoří za vás.

Vytvoření nového online koncového bodu

Teď, když máte zaregistrovaný model a odvozovací skript, je čas vytvořit online koncový bod. Název koncového bodu musí být jedinečný v celé oblasti Azure. V tomto kurzu vytvoříte jedinečný název pomocí 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}"
)

Po vytvoření koncového bodu ho můžete načíst takto:

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

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

Nasazení modelu do koncového bodu

Po vytvoření koncového bodu nasaďte model pomocí vstupního skriptu. Každý koncový bod může mít více nasazení a směrovat provoz do těchto nasazení pomocí pravidel. Tady vytvoříte jedno nasazení, které zpracovává 100 % příchozího provozu. Pro nasazení jsme zvolili název barvy, například modré, zelené, červené nasazení, což je libovolné.

Můžete zkontrolovat stránku Modely v nástroji Azure ML Studio a zjistit nejnovější verzi zaregistrovaného modelu. Případně níže uvedený kód načte nejnovější číslo verze, které můžete použít.

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

Nasaďte nejnovější verzi modelu.

Poznámka

Očekáváme, že toto nasazení trvá přibližně 6 až 8 minut.

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

Testování pomocí ukázkového dotazu

Teď, když je model nasazený do koncového bodu, můžete s ním spustit odvozování.

Vytvořte ukázkový soubor požadavku podle návrhu očekávaného v metodě spuštění ve skriptu skóre.

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

Vyčištění prostředků

Pokud koncový bod nebudete používat, odstraňte ho, abyste ho přestali používat. Před odstraněním se ujistěte, že žádná jiná nasazení nepoužívají koncový bod.

Poznámka

Tento krok může trvat přibližně 6 až 8 minut.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Další kroky

Přečtěte si další informace o protokolování Azure ML.