Trénování modelů Keras ve velkém měřítku pomocí služby Azure Machine Learning

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

V tomto článku se dozvíte, jak spustit trénovací skripty Kerasu pomocí sady Azure Machine Learning Python SDK v2.

Ukázkový kód v tomto článku používá Azure Machine Learning k trénování, registraci a nasazení modelu Keras vytvořeného pomocí back-endu TensorFlow. Model, hluboké neurální sítě (DNN) vytvořené pomocí knihovny Keras Python běžící nad TensorFlow, klasifikuje ručně psané číslice z oblíbené datové sady MNIST.

Keras je rozhraní API pro neurální síť vysoké úrovně, které umožňuje zjednodušit vývoj s využitím dalších oblíbených architektur DNN. Pomocí služby Azure Machine Learning můžete rychle škálovat trénovací úlohy pomocí výpočetních prostředků elastického cloudu. Můžete také sledovat trénovací běhy, modely verzí, nasazovat modely a mnoho dalšího.

Bez ohledu na to, jestli vyvíjíte model Kerasu od základů, nebo přenesete existující model do cloudu, může vám Azure Machine Learning pomoct se sestavováním modelů připravených pro produkční prostředí.

Poznámka:

Pokud používáte rozhraní Keras API tf.keras integrované do TensorFlow, nikoli samostatný balíček Keras, přečtěte si místo toho trénování modelů TensorFlow.

Požadavky

Pokud chcete využít výhod tohoto článku, budete muset:

• Přístup k předplatnému Azure Pokud ho ještě nemáte, vytvořte si bezplatný účet.
• Spusťte kód v tomto článku pomocí výpočetní instance služby Azure Machine Learning nebo vlastního poznámkového bloku Jupyter.
  • Výpočetní instance Služby Azure Machine Learning – není potřeba stahovat ani instalovat
    • Dokončete vytváření prostředků, abyste mohli začít vytvářet vyhrazený server poznámkových bloků předem načtený se sadou SDK a ukázkovým úložištěm.
    • Ve složce hloubkového učení na serveru poznámkového bloku najděte dokončený a rozbalený poznámkový blok tak, že přejdete do tohoto adresáře: úlohy Pythonu > v2 > sdk s > jedním krokem > tensorflow > train-hyperparameter-tune-deploy-with-keras.>
  • Server poznámkového bloku Jupyter
    • Nainstalujte sadu Azure Machine Learning SDK (v2).
• Stáhněte si trénovací skripty keras_mnist.py a utils.py.

Dokončenou verzi poznámkového bloku Jupyter najdete také na stránce ukázek GitHubu.

Než budete moct spustit kód v tomto článku a vytvořit cluster GPU, budete muset požádat o navýšení kvóty pro váš pracovní prostor.

Nastavení úlohy

Tato část nastaví úlohu pro trénování načtením požadovaných balíčků Pythonu, připojením k pracovnímu prostoru, vytvořením výpočetního prostředku pro spuštění úlohy příkazu a vytvořením prostředí pro spuštění úlohy.

Připojení k pracovnímu prostoru

Nejprve se budete muset připojit ke svému pracovnímu prostoru Azure Machine Learning. Pracovní prostor Azure Machine Learning je prostředek nejvyšší úrovně služby. Poskytuje centralizované místo pro práci se všemi artefakty, které vytvoříte při použití služby Azure Machine Learning.

Používáme DefaultAzureCredential k získání přístupu k pracovnímu prostoru. Tyto přihlašovací údaje by měly být schopné zpracovávat většinu scénářů ověřování sady Azure SDK.

Pokud DefaultAzureCredential vám nefunguje, podívejte se nebo Set up authentication vyhledejte azure-identity reference documentation další dostupné přihlašovací údaje.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Pokud chcete k přihlášení a ověření použít prohlížeč, měli byste zrušit komentář k následujícímu kódu a místo toho ho použít.

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

# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()

Dále získejte popisovač pracovního prostoru zadáním ID předplatného, názvu skupiny prostředků a názvu pracovního prostoru. Vyhledání těchto parametrů:

1. V pravém horním rohu panelu nástrojů studio Azure Machine Learning vyhledejte název pracovního prostoru.
2. Vyberte název pracovního prostoru, aby se zobrazila vaše skupina prostředků a ID předplatného.
3. Zkopírujte hodnoty pro skupinu prostředků a ID předplatného do kódu.

# 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 spuštění tohoto skriptu je popisovač pracovního prostoru, který použijete ke správě dalších prostředků a úloh.

Poznámka:

• Při vytváření MLClient se klient nepřipojí k pracovnímu prostoru. Inicializace klienta je opožděná a při prvním volání bude čekat. V tomto článku k tomu dojde během vytváření výpočetních prostředků.

Vytvoření výpočetního prostředku pro spuštění úlohy

Azure Machine Learning potřebuje výpočetní prostředek ke spuštění úlohy. Tento prostředek může být počítač 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 následujícím ukázkovém skriptu zřídíme Linux compute cluster. Azure Machine Learning pricing Zobrazí se stránka s úplným seznamem velikostí a cen virtuálních počítačů. Vzhledem k tomu, že pro tento příklad potřebujeme cluster GPU, vybereme model STANDARD_NC6 a vytvoříme výpočetní prostředí Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

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

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

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC6s_v3",
        # 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
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

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

Vytvoření prostředí úlohy

Ke spuštění úlohy Azure Machine Learning budete potřebovat prostředí. Prostředí Azure Machine Learning zapouzdřuje závislosti (například modul runtime softwaru a knihovny) potřebné ke spuštění trénovacího skriptu strojového učení na výpočetním prostředku. Toto prostředí se podobá prostředí Pythonu na místním počítači.

Azure Machine Learning umožňuje buď použít kurátorované (nebo připravené) prostředí, nebo vytvořit vlastní prostředí pomocí image Dockeru nebo konfigurace Conda. V tomto článku vytvoříte vlastní prostředí Conda pro vaše úlohy pomocí souboru Conda YAML.

Vytvoření vlastního prostředí

Pokud chcete vytvořit vlastní prostředí, definujete závislosti Conda v souboru YAML. Nejprve vytvořte adresář pro uložení souboru. V tomto příkladu jsme pojmenovali adresář dependencies.

import os

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

Potom vytvořte soubor v adresáři závislostí. V tomto příkladu jsme soubor conda.ymlpojmenovali .

%%writefile {dependencies_dir}/conda.yaml
name: keras-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - pip:
    - protobuf~=3.20
    - numpy==1.22
    - tensorflow-gpu==2.2.0
    - keras<=2.3.1
    - matplotlib
    - azureml-mlflow==1.42.0

Specifikace obsahuje některé obvyklé balíčky (například numpy a pip), které použijete ve své úloze.

Dále pomocí souboru YAML vytvořte a zaregistrujte toto vlastní prostředí ve vašem pracovním prostoru. Prostředí se zabalí do kontejneru Dockeru za běhu.

from azure.ai.ml.entities import Environment

custom_env_name = "keras-env"

job_env = Environment(
    name=custom_env_name,
    description="Custom environment for keras image classification",
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
job_env = ml_client.environments.create_or_update(job_env)

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

Další informace o vytváření a používání prostředí najdete v tématu Vytváření a používání softwarových prostředí ve službě Azure Machine Learning.

Konfigurace a odeslání trénovací úlohy

V této části začneme představením dat pro trénování. Pak se podíváme, jak spustit trénovací úlohu pomocí trénovacího skriptu, který jsme poskytli. Naučíte se sestavit trénovací úlohu konfigurací příkazu pro spuštění trénovacího skriptu. Potom odešlete úlohu trénování, která se spustí ve službě Azure Machine Learning.

Získání trénovacích dat

Použijete data z databáze MNIST (Modified National Institute of Standards and Technology) ručně psaných číslic. Tato data pocházejí z webu Yan LeCun a jsou uložená v účtu úložiště Azure.

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

Další informace o datové sadě MNIST naleznete na webu Yan LeCun.

Příprava trénovacího skriptu

V tomto článku jsme poskytli trénovací skript keras_mnist.py. V praxi byste měli být schopni vzít libovolný vlastní trénovací skript tak, jak je, a spouštět ho ve službě Azure Machine Learning, aniž byste museli upravovat kód.

Zadaný trénovací skript provede následující akce:

• zpracovává předběžné zpracování dat a rozděluje data na testovací a trénovací data;
• trénuje model pomocí dat; a
• vrátí výstupní model.

Během spuštění kanálu použijete MLFlow k protokolování parametrů a metrik. Informace o povolení sledování MLFlow najdete v tématu Sledování experimentů a modelů ML pomocí MLflow.

V trénovacím skriptu keras_mnist.pyvytvoříme jednoduchou hlubokou neurální síť (DNN). Tato síť DNN má:

• Vstupní vrstva s 28 * 28 = 784 neurony. Každý neuron představuje obrazový pixel.
• Dvě skryté vrstvy. První skrytá vrstva má 300 neuronů a druhá skrytá vrstva má 100 neuronů.
• Výstupní vrstva s 10 neurony. Každý neuron představuje cílový popisek od 0 do 9.

Sestavení trénovací úlohy

Teď, když máte všechny prostředky potřebné ke spuštění úlohy, je čas ji sestavit pomocí sady Azure Machine Learning Python SDK v2. V tomto příkladu vytvoříme .command

Azure Machine Learning command je prostředek, který určuje všechny podrobnosti potřebné ke spuštění trénovacího kódu v cloudu. Mezi tyto podrobnosti patří vstupy a výstupy, typ hardwaru, který se má použít, software k instalaci a způsob spuštění kódu. Obsahuje command informace pro spuštění jednoho příkazu.

Konfigurace příkazu

Ke spuštění trénovacího skriptu a provedení požadovaných úloh použijete obecný účel command . Vytvořte Command objekt pro zadání podrobností konfigurace vaší trénovací úlohy.

from azure.ai.ml import command
from azure.ai.ml import UserIdentityConfiguration
from azure.ai.ml import Input

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

job = command(
    inputs=dict(
        data_folder=Input(type="uri_folder", path=web_path),
        batch_size=50,
        first_layer_neurons=300,
        second_layer_neurons=100,
        learning_rate=0.001,
    ),
    compute=gpu_compute_target,
    environment=f"{job_env.name}:{job_env.version}",
    code="./src/",
    command="python keras_mnist.py --data-folder ${{inputs.data_folder}} --batch-size ${{inputs.batch_size}} --first-layer-neurons ${{inputs.first_layer_neurons}} --second-layer-neurons ${{inputs.second_layer_neurons}} --learning-rate ${{inputs.learning_rate}}",
    experiment_name="keras-dnn-image-classify",
    display_name="keras-classify-mnist-digit-images-with-dnn",
)

• Vstupy pro tento příkaz zahrnují umístění dat, velikost dávky, počet neuronů v první a druhé vrstvě a rychlost učení. Všimněte si, že jsme webovou cestu předali přímo jako vstup.

• Pro hodnoty parametrů:

  • zadejte výpočetní cluster gpu_compute_target = "gpu-cluster" , který jste vytvořili pro spuštění tohoto příkazu;
  • zadejte vlastní prostředí keras-env , které jste vytvořili pro spuštění úlohy Azure Machine Learning;
  • nakonfigurujte samotnou akci příkazového řádku – v tomto případě příkaz je python keras_mnist.py. Ke vstupům a výstupům v příkazu můžete přistupovat prostřednictvím zápisu ${{ ... }} a
  • konfigurovat metadata, jako je zobrazovaný název a název experimentu; kde 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 se zobrazí vedle sebe v studio Azure Machine Learning.

• V tomto příkladu UserIdentity použijete ke spuštění příkazu příkaz. Použití identity uživatele znamená, že příkaz použije vaši identitu ke spuštění úlohy a přístupu k datům z objektu blob.

Odeslání úlohy

Teď je čas odeslat úlohu, která se má spustit ve službě Azure Machine Learning. Tentokrát použijete create_or_update .ml_client.jobs

ml_client.jobs.create_or_update(job)

Po dokončení úloha zaregistruje v pracovním prostoru model (v důsledku trénování) a vypíše odkaz pro zobrazení úlohy v studio Azure Machine Learning.

Upozorňující

Azure Machine Learning spouští trénovací skripty zkopírováním celého zdrojového adresáře. Pokud máte citlivá data, která nechcete nahrát, použijte soubor .ignore nebo je nezahrňte do zdrojového adresáře.

Co se stane během provádění úlohy

Při spuštění úlohy prochází následujícími fázemi:

• Příprava: Image Dockeru se vytvoří podle definovaného prostředí. Image se nahraje do registru kontejneru pracovního prostoru a pro pozdější spuštění se ukládá do mezipaměti. Protokoly se také streamují do historie úloh a dají se zobrazit za účelem monitorování průběhu. Pokud je zadané kurátorované prostředí, použije se image uložená v mezipaměti, která toto kurátorované prostředí zálohuje.

• Škálování: Cluster se pokusí vertikálně navýšit kapacitu, pokud ke spuštění vyžaduje více uzlů, než je aktuálně k dispozici.

• Spuštěno: Všechny skripty ve složce skriptu src se nahrají do cílového výpočetního objektu, úložiště dat se připojí nebo zkopírují a skript se spustí. Výstupy ze stdoutu a složky ./logs se streamují do historie úloh a dají se použít k monitorování úlohy.

Ladění hyperparametrů modelu

Model jste vytrénovali pomocí jedné sady parametrů. Teď se podíváme, jestli můžete ještě více zlepšit přesnost modelu. Hyperparametry modelu můžete vyladit a optimalizovat pomocí funkcí služby Azure Machine Learning sweep .

Pokud chcete vyladit hyperparametry modelu, definujte prostor parametrů, ve kterém se má během trénování hledat. Provedete to tak, že nahradíte některé parametry (batch_size, first_layer_neurons, second_layer_neuronsa learning_rate) předané trénovací úloze speciálními vstupy z azure.ml.sweep balíčku.

from azure.ai.ml.sweep import Choice, LogUniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
job_for_sweep = job(
    batch_size=Choice(values=[25, 50, 100]),
    first_layer_neurons=Choice(values=[10, 50, 200, 300, 500]),
    second_layer_neurons=Choice(values=[10, 50, 200, 500]),
    learning_rate=LogUniform(min_value=-6, max_value=-1),
)

Pak nakonfigurujete uklidit úlohu příkazu pomocí některých parametrů specifických pro úklid, jako je primární metrika, která se má sledovat, a algoritmus vzorkování, který se má použít.

V následujícím kódu použijeme náhodné vzorkování k vyzkoušení různých konfiguračních sad hyperparametrů při pokusu o maximalizaci naší primární metriky validation_acc.

Definujeme také zásady předčasného ukončení , tj BanditPolicy. Tato zásada funguje kontrolou úlohy každé dvě iterace. Pokud primární metrika validation_accspadá mimo horní desetiprocentní rozsah, Azure Machine Learning tuto úlohu ukončí. Tím se model ušetří od pokračování v prozkoumání hyperparametrů, které nemají žádný slib, že by pomohly dosáhnout cílové metriky.

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute=gpu_compute_target,
    sampling_algorithm="random",
    primary_metric="Accuracy",
    goal="Maximize",
    max_total_trials=20,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(slack_factor=0.1, evaluation_interval=2),
)

Teď můžete tuto úlohu odeslat jako předtím. Tentokrát spustíte úlohu uklidení, která přemístit vaši úlohu trénu.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Úlohu můžete monitorovat pomocí odkazu uživatelského rozhraní studia, který se zobrazí během spuštění úlohy.

Vyhledání a registrace nejlepšího modelu

Po dokončení všech spuštění můžete najít běh, který vytvořil model s nejvyšší přesností.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "keras_dnn_mnist_model"
        path="azureml://jobs/{}/outputs/artifacts/paths/keras_dnn_mnist_model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="mlflow_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Tento model pak můžete zaregistrovat.

registered_model = ml_client.models.create_or_update(model=model)

Nasazení modelu jako online koncového bodu

Po registraci modelu ho můžete nasadit jako online koncový bod – to znamená jako webová služba v cloudu Azure.

K nasazení služby machine learning obvykle potřebujete:

• Prostředky modelu, které chcete nasadit. Mezi tyto prostředky patří soubor a metadata modelu, které jste už zaregistrovali ve své trénovací úloze.
• Nějaký kód, který se má spustit jako služba. Kód spustí model na daném vstupním požadavku (vstupním skriptu). Tento vstupní skript obdrží data odeslaná do nasazené webové služby a předá je do modelu. Jakmile model zpracuje data, skript vrátí klientovi odpověď modelu. Skript je specifický pro váš model a musí rozumět datům, která model očekává a vrací. Když použijete model MLFlow, Azure Machine Learning automaticky vytvoří tento skript za vás.

Další informace o nasazení najdete v tématu Nasazení a určení skóre modelu strojového učení pomocí spravovaného online koncového bodu pomocí sady Python SDK v2.

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

Jako první krok k nasazení modelu potřebujete vytvořit online koncový bod. Název koncového bodu musí být jedinečný v celé oblasti Azure. V tomto článku vytvoříte jedinečný název pomocí univerzálního jedinečného identifikátoru (UUID).

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "keras-dnn-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="Classify handwritten digits using a deep neural network (DNN) using Keras",
    auth_mode="key",
)

endpoint = ml_client.begin_create_or_update(endpoint).result()

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

Po vytvoření koncového bodu ho můžete načíst následujícím způsobem:

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 můžete model nasadit pomocí vstupního skriptu. Koncový bod může mít více nasazení. Pomocí pravidel pak koncový bod může směrovat provoz do těchto nasazení.

V následujícím kódu vytvoříte jedno nasazení, které zpracovává 100 % příchozího provozu. Pro nasazení jsme zadali libovolný název barvy (tff-blue). Pro nasazení můžete také použít jakýkoli jiný název, například tff-green nebo tff-red . Kód pro nasazení modelu do koncového bodu provede následující:

• nasadí nejlepší verzi modelu, který jste zaregistrovali dříve;
• vyhodnocí model pomocí score.py souboru; a
• používá k odvozování vlastní prostředí (které jste vytvořili dříve).

from azure.ai.ml.entities import ManagedOnlineDeployment, CodeConfiguration

model = registered_model

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="keras-blue-deployment",
    endpoint_name=online_endpoint_name,
    model=model,
    # code_configuration=CodeConfiguration(code="./src", scoring_script="score.py"),
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

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

Poznámka:

Očekáváme, že dokončení tohoto nasazení bude chvíli trvat.

Testování nasazeného modelu

Teď, když jste model nasadili do koncového bodu, můžete pomocí metody na koncovém bodu předpovědět výstup nasazeného modelu invoke .

K otestování koncového bodu potřebujete nějaká testovací data. Místně si stáhněte testovací data, která jsme použili v našem trénovacím skriptu.

import urllib.request

data_folder = os.path.join(os.getcwd(), "data")
os.makedirs(data_folder, exist_ok=True)

urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-images-idx3-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"),
)
urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-labels-idx1-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"),
)

Načtěte je do testovací datové sady.

from src.utils import load_data

X_test = load_data(os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"), False)
y_test = load_data(
    os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"), True
).reshape(-1)

Vyberte 30 náhodných vzorků z testovací sady a zapište je do souboru JSON.

import json
import numpy as np

# find 30 random samples from test set
n = 30
sample_indices = np.random.permutation(X_test.shape[0])[0:n]

test_samples = json.dumps({"input_data": X_test[sample_indices].tolist()})
# test_samples = bytes(test_samples, encoding='utf8')

with open("request.json", "w") as outfile:
    outfile.write(test_samples)

Pak můžete vyvolat koncový bod, vytisknout vrácené předpovědi a vykreslit je spolu se vstupními obrázky. K zvýraznění chybně klasifikovaných ukázek použijte červenou barvu písma a invertovaný obrázek (bílý černobílý).

import matplotlib.pyplot as plt

# predict using the deployed model
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./request.json",
    deployment_name="keras-blue-deployment",
)

# compare actual value vs. the predicted values:
i = 0
plt.figure(figsize=(20, 1))

for s in sample_indices:
    plt.subplot(1, n, i + 1)
    plt.axhline("")
    plt.axvline("")

    # use different color for misclassified sample
    font_color = "red" if y_test[s] != result[i] else "black"
    clr_map = plt.cm.gray if y_test[s] != result[i] else plt.cm.Greys

    plt.text(x=10, y=-10, s=result[i], fontsize=18, color=font_color)
    plt.imshow(X_test[s].reshape(28, 28), cmap=clr_map)

    i = i + 1
plt.show()

Poznámka:

Vzhledem k tomu, že je přesnost modelu vysoká, je možné, že před zobrazením chybně klasifikované ukázky budete muset buňku spustit několikrát.

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

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

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Poznámka:

Očekáváme, že dokončení tohoto vyčištění nějakou dobu trvá.

Další kroky

V tomto článku jste natrénovali a zaregistrovali model Keras. Model jste také nasadili do online koncového bodu. Další informace o službě Azure Machine Learning najdete v těchto dalších článcích.

• Sledování metrik spuštění během trénování
• Ladění hyperparametrů
• Referenční architektura pro distribuované trénování hlubokého učení v Azure