Megosztás a következőn keresztül:

Keras-modellek nagy léptékű betanítása az Azure Machine Learning használatával

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)

Ebből a cikkből megtudhatja, hogyan futtathatja a Keras-betanítási szkripteket az Azure Machine Learning Python SDK v2 használatával.

A cikkben szereplő példakód az Azure Machine Learning használatával tanít be, regisztrál és helyez üzembe egy TensorFlow háttérrendszerrel készült Keras-modellt. A TensorFlow tetején futó Keras Python-kódtárral létrehozott mély neurális hálózat (DNN) modell a népszerű MNIST-adatkészlet kézzel írt számjegyeit sorolja be.

A Keras egy magas szintű neurális hálózati API, amely képes más népszerű DNN-keretrendszerek futtatására a fejlesztés egyszerűsítése érdekében. Az Azure Machine Learning segítségével gyorsan kibővítheti a betanítási feladatokat rugalmas felhőalapú számítási erőforrások használatával. Emellett nyomon követheti a betanítási futtatásokat, a verziómodelleket, a modellek üzembe helyezését és sok mást is.

Akár az alapoktól fejleszti a Keras-modellt, akár meglévő modellt hoz a felhőbe, az Azure Machine Learning segíthet éles üzemre kész modellek létrehozásában.

Feljegyzés

Ha a TensorFlow-ba beépített Keras API tf.keras-t használja, és nem az önálló Keras-csomagot, tekintse meg inkább a TensorFlow-modellek betanítása című témakört.

Előfeltételek

A cikk előnyeinek kihasználásához a következőkre lesz szüksége:

Az útmutató egy kész Jupyter Notebook-verzióját is megtalálhatja a GitHub-minták oldalán.

Ahhoz, hogy a cikkben szereplő kód futtatásával GPU-fürtöt hozzon létre, kvótanövelést kell kérnie a munkaterülethez.

A feladat beállítása

Ez a szakasz betanításra állítja be a feladatot a szükséges Python-csomagok betöltésével, a munkaterülethez való csatlakozással, egy számítási erőforrás létrehozásával egy parancsfeladat futtatásához, valamint a feladat futtatásához szükséges környezet létrehozásával.

Csatlakozás a munkaterülethez

Először csatlakoznia kell az Azure Machine Learning-munkaterülethez. Az Azure Machine Learning-munkaterület a szolgáltatás legfelső szintű erőforrása. Központosított helyet biztosít az Azure Machine Learning használatakor létrehozott összes összetevővel való munkához.

A munkaterülethez való hozzáférést használjuk DefaultAzureCredential . Ennek a hitelesítő adatnak képesnek kell lennie a legtöbb Azure SDK-hitelesítési forgatókönyv kezelésére.

Ha DefaultAzureCredential nem működik az Ön számára, tekintse meg azure-identity reference documentation vagy Set up authentication keresse meg a további elérhető hitelesítő adatokat.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Ha inkább böngészőt használ a bejelentkezéshez és a hitelesítéshez, törölje a következő kódot, és használja helyette.

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

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

Ezután szerezze be a munkaterület leíróját az előfizetés azonosítójának, az erőforráscsoport nevének és a munkaterület nevének megadásával. A paraméterek megkeresése:

  1. Keresse meg a munkaterület nevét az Azure Machine Learning Studio eszköztárának jobb felső sarkában.
  2. Válassza ki a munkaterület nevét az erőforráscsoport és az előfizetés azonosítójának megjelenítéséhez.
  3. Másolja az erőforráscsoport és az előfizetés azonosítójának értékeit a kódba.
# 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>",
)

A szkript futtatásának eredménye egy munkaterületi leíró, amelyet más erőforrások és feladatok kezelésére fog használni.

Feljegyzés

  • A létrehozás MLClient nem fogja csatlakoztatni az ügyfelet a munkaterülethez. Az ügyfél inicializálása lusta, és az első alkalommal vár, amikor hívást kell kezdeményeznie. Ebben a cikkben ez a számítás létrehozása során fog történni.

Számítási erőforrás létrehozása a feladat futtatásához

Az Azure Machine Learningnek számítási erőforrásra van szüksége egy feladat futtatásához. Ez az erőforrás lehet egy- vagy többcsomópontos gép Linux vagy Windows operációs rendszerrel, vagy egy adott számítási háló, például a Spark.

A következő példaszkriptben kiépítünk egy Linuxot compute cluster. A virtuális gépek méreteinek és árainak teljes listáját tartalmazó oldal látható Azure Machine Learning pricing . Mivel ehhez a példához GPU-fürtre van szükségünk, válasszunk egy STANDARD_NC6 modellt, és hozzunk létre egy Azure Machine Learning-számítást.

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

Feladatkörnyezet létrehozása

Azure Machine Learning-feladat futtatásához környezetre lesz szüksége. Az Azure Machine Learning-környezet magában foglalja a számítógép-tanulási betanítási szkript számítási erőforráson való futtatásához szükséges függőségeket (például szoftveres futtatókörnyezetet és kódtárakat). Ez a környezet hasonló a helyi gépen lévő Python-környezethez.

Az Azure Machine Learning lehetővé teszi, hogy válogatott (vagy kész) környezetet használjon, vagy egyéni környezetet hozzon létre Docker-rendszerkép vagy Conda-konfiguráció használatával. Ebben a cikkben egy egyéni Conda-környezetet fog létrehozni a feladatokhoz Egy Conda YAML-fájl használatával.

Egyéni környezet létrehozása

Az egyéni környezet létrehozásához meg kell határoznia a Conda-függőségeket egy YAML-fájlban. Először hozzon létre egy könyvtárat a fájl tárolásához. Ebben a példában elneveztük a könyvtárat dependencies.

import os

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

Ezután hozza létre a fájlt a függőségek könyvtárában. Ebben a példában elneveztük a fájlt conda.yml.

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

A specifikáció tartalmaz néhány szokásos csomagot (például numpy és pip), amelyeket a feladathoz fog használni.

Ezután a YAML-fájllal hozza létre és regisztrálja ezt az egyéni környezetet a munkaterületen. A környezet futásidőben egy Docker-tárolóba lesz csomagolva.

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

További információ a környezetek létrehozásáról és használatáról: Szoftverkörnyezetek létrehozása és használata az Azure Machine Learningben.

A betanítási feladat konfigurálása és elküldése

Ebben a szakaszban a betanításhoz szükséges adatok bevezetésével kezdjük. Ezután bemutatjuk, hogyan futtathat betanítási feladatokat egy általunk biztosított betanítási szkripttel. A betanítási feladat összeállításához konfigurálja a betanítási szkript futtatására szolgáló parancsot. Ezután elküldi a betanítási feladatot az Azure Machine Learningben való futtatáshoz.

A betanítási adatok beszerzése

A kézzel írt számjegyek módosított Nemzeti Szabványügyi és Technológiai Intézetének (MNIST) adatbázisából származó adatokat fogja használni. Ezek az adatok Yan LeCun webhelyéről származnak, és egy Azure-tárfiókban találhatók.

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

Az MNIST-adatkészletről a Yan LeCun webhelyén talál további információt.

A betanítási szkript előkészítése

Ebben a cikkben a betanítási szkriptet keras_mnist.py. A gyakorlatban képesnek kell lennie bármilyen egyéni betanítási szkriptet használni, és anélkül futtatni az Azure Machine Learningben, hogy módosítania kellene a kódot.

A megadott betanítási szkript a következőket teszi:

  • kezeli az adatok előfeldolgozását, az adatok tesztelésre és betanításra való felosztását;
  • modell betanítása az adatok használatával; és
  • A kimeneti modellt adja vissza.

A folyamat futtatása során az MLFlow használatával naplózza a paramétereket és a metrikákat. Az MLFlow nyomon követésének engedélyezéséről az ML-kísérletek és modellek nyomon követése az MLflow-nal című témakörben olvashat.

A betanítási szkriptben keras_mnist.pylétrehozunk egy egyszerű mély neurális hálózatot (DNN). Ez a DNN a következő:

  • Egy bemeneti réteg 28 * 28 = 784 neuronokkal. Minden neuron egy kép képpontot jelöl.
  • Két rejtett réteg. Az első rejtett réteg 300 neuron, a második rejtett réteg 100 neuron.
  • Egy kimeneti réteg 10 neuronnal. Minden neuron egy célzott címkét jelöl 0 és 9 között.

Egy mély neurális hálózatot ábrázoló ábra 784 neuronnal a bemeneti rétegben, két rejtett réteggel és 10 neuronnal a kimeneti rétegben.

A betanítási feladat létrehozása

Most, hogy rendelkezik a feladat futtatásához szükséges összes eszközzel, itt az ideje, hogy az Azure Machine Learning Python SDK 2-s v2 használatával hozza létre. Ebben a példában létrehozunk egy command.

Az Azure Machine Learning command egy erőforrás, amely megadja a betanítási kód felhőben való végrehajtásához szükséges összes részletet. Ezek a részletek tartalmazzák a bemeneteket és kimeneteket, a használandó hardver típusát, a telepíteni kívánt szoftvereket és a kód futtatásának módját. A command parancsok végrehajtásához szükséges információkat tartalmazza.

A parancs konfigurálása

Az általános célt command fogja használni a betanítási szkript futtatásához és a kívánt feladatok elvégzéséhez. Hozzon létre egy objektumot Command a betanítási feladat konfigurációs adatainak megadásához.

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

  • A parancs bemenetei közé tartozik az adatok helye, a köteg mérete, az első és a második réteg neuronjainak száma és a tanulási sebesség. Figyelje meg, hogy közvetlenül bemenetként haladtunk át a webes elérési úton.

  • A paraméterértékek esetében:

    • adja meg a parancs futtatásához létrehozott számítási fürtöt gpu_compute_target = "gpu-cluster" ;
    • adja meg az Azure Machine Learning-feladat futtatásához létrehozott egyéni környezetet keras-env ;
    • konfigurálja magát a parancssori műveletet – ebben az esetben a parancs a következő python keras_mnist.py: . A parancs bemeneteit és kimeneteit a ${{ ... }} jelölésen keresztül érheti el; és
    • konfigurálja a metaadatokat, például a megjelenítendő nevet és a kísérlet nevét; ahol egy kísérlet egy tároló egy adott projekten végzett összes iterációhoz. Az azonos kísérletnévvel elküldött összes feladat egymás mellett szerepelne az Azure Machine Learning Studióban.

  • Ebben a példában a UserIdentity parancs futtatásához használja a parancsot. A felhasználói identitás használata azt jelenti, hogy a parancs az ön identitásával futtatja a feladatot, és hozzáfér az adatokhoz a blobból.

Feladat küldése

Itt az ideje, hogy elküldje a feladatot az Azure Machine Learningben való futtatáshoz. Ezúttal a következőt ml_client.jobsfogja használnicreate_or_update: .

ml_client.jobs.create_or_update(job)

Miután végzett, a feladat regisztrál egy modellt a munkaterületen (a betanítás eredményeként), és egy hivatkozást ad ki a feladat Azure Machine Learning Studióban való megtekintéséhez.

Figyelmeztetés

Az Azure Machine Learning a teljes forráskönyvtár másolásával futtat betanítási szkripteket. Ha olyan bizalmas adatokkal rendelkezik, amelyeket nem szeretne feltölteni, használjon .ignore fájlt , vagy ne vegye fel azokat a forráskönyvtárba.

Mi történik a feladat végrehajtása során?

A feladat végrehajtása során a következő szakaszokon megy keresztül:

  • Előkészítés: A rendszer létrehoz egy Docker-rendszerképet a megadott környezetnek megfelelően. A rendszerképet a rendszer feltölti a munkaterület tárolóregisztrációs adatbázisára, és gyorsítótárazza a későbbi futtatásokhoz. A naplók a feladatelőzményekbe is streamelhetők, és megtekinthetők a folyamat figyeléséhez. Ha egy válogatott környezet van megadva, a rendszer a gyorsítótárazott rendszerképet fogja használni a válogatott környezethez.

  • Skálázás: A fürt megkísérli a vertikális felskálázást, ha a futtatás végrehajtásához több csomópontra van szükség, mint amennyi jelenleg elérhető.

  • Futtatás: A szkriptmappa src összes szkriptje fel lesz töltve a számítási célba, az adattárak csatlakoztatva vannak vagy másolódnak, és a szkript végrehajtása megtörténik. Az stdout és a ./logs mappa kimenetei a feladatelőzményekbe kerülnek, és a feladat figyelésére használhatók.

Modell hiperparamétereinek finomhangolása

A modellt egy paraméterkészlettel képezte be, most lássuk, hogy tovább javíthatja-e a modell pontosságát. Az Azure Machine Learning képességeivel hangolhatja és optimalizálhatja a modell hiperparamétereit sweep .

A modell hiperparamétereinek finomhangolásához adja meg azt a paraméterteret, amelyben a betanítás során keresni szeretne. Ezt úgy teheti meg, hogy lecseréli a betanítási feladatnak átadott paraméterek egy részét (batch_size, first_layer_neuronsés second_layer_neuronslearning_rate) a azure.ml.sweep csomag speciális bemeneteivel.

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

Ezután konfigurálja a takarítást a parancsfeladaton, bizonyos takarítási paraméterekkel, például a figyelendő elsődleges metrikával és a használandó mintavételezési algoritmussal.

Az alábbi kódban véletlenszerű mintavételezést használunk a hiperparaméterek különböző konfigurációs készleteinek kipróbálására, hogy maximalizáljuk az elsődleges metrikát. validation_acc

Meghatározunk egy korai felmondási szabályzatot is – a BanditPolicy. Ez a szabályzat úgy működik, hogy két iterációnként ellenőrzi a feladatot. Ha az elsődleges metrika az validation_accelső tíz százalékos tartományon kívül esik, az Azure Machine Learning leállítja a feladatot. Ez menti a modellt attól, hogy folytassa a hiperparaméterek felderítését, amelyek nem ígérik, hogy segítenek elérni a célmetrikát.

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

Most már a korábbiakhoz hasonlóan küldheti el ezt a feladatot. Ezúttal egy takarítási feladatot fog futtatni, amely átsöpri a vonatfeladatot.

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)

A feladatot a feladat futtatása során megjelenő studio felhasználói felület hivatkozásával figyelheti.

A legjobb modell megkeresése és regisztrálása

Miután az összes futtatás befejeződött, megtalálhatja a modellt a legnagyobb pontossággal előállító futtatásokat.

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

Ezután regisztrálhatja ezt a modellt.

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

A modell üzembe helyezése online végpontként

Miután regisztrálta a modellt, üzembe helyezheti online végpontként, vagyis webszolgáltatásként az Azure-felhőben.

Gépi tanulási szolgáltatás üzembe helyezéséhez általában a következőkre lesz szüksége:

  • Az üzembe helyezni kívánt modellegységek. Ezek az eszközök tartalmazzák a modell azon fájlját és metaadatait, amelyeket már regisztrált a betanítási feladatban.
  • Néhány szolgáltatásként futtatandó kód. A kód egy adott bemeneti kérésen (belépési szkripten) hajtja végre a modellt. Ez a bejegyzésszkript fogadja az üzembe helyezett webszolgáltatásnak küldött adatokat, és továbbítja azokat a modellnek. Miután a modell feldolgozta az adatokat, a szkript visszaadja a modell válaszát az ügyfélnek. A szkript a modellre jellemző, és ismernie kell a modell által várt és visszaadott adatokat. MLFlow-modell használata esetén az Azure Machine Learning automatikusan létrehozza ezt a szkriptet.

További információ az üzembe helyezésről: Gépi tanulási modell üzembe helyezése és pontszáma felügyelt online végponttal Python SDK v2 használatával.

Új online végpont létrehozása

A modell üzembe helyezésének első lépéseként létre kell hoznia az online végpontot. A végpont nevének egyedinek kell lennie a teljes Azure-régióban. Ebben a cikkben egy univerzálisan egyedi azonosítót (UUID) használó egyedi nevet fog létrehozni.

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

Miután létrehozta a végpontot, az alábbiak szerint kérdezheti le:

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

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

A modell üzembe helyezése a végponton

A végpont létrehozása után üzembe helyezheti a modellt a belépési szkripttel. Egy végpont több üzembe helyezéssel is rendelkezhet. A szabályok használatával a végpont ezután átirányíthatja a forgalmat ezekre az üzemelő példányokra.

Az alábbi kódban egyetlen üzembe helyezést fog létrehozni, amely a bejövő forgalom 100%-át kezeli. Megadottunk egy tetszőleges színnevet (tff-blue) az üzembe helyezéshez. Az üzembe helyezéshez bármilyen más nevet is használhat, például tff-green vagy tff-red . A modell végponton való üzembe helyezéséhez szükséges kód a következő:

  • a korábban regisztrált modell legjobb verzióját telepíti;
  • pontszámot ad a modellnek a score.py fájl használatával; és
  • a korábban létrehozott egyéni környezetet használja a következtetés végrehajtásához.
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()

Feljegyzés

Az üzembe helyezés várhatóan egy kis időt vesz igénybe.

Az üzembe helyezett modell tesztelése

Most, hogy üzembe helyezte a modellt a végponton, előrejelezheti az üzembe helyezett modell kimenetét a invoke végponton található metódus használatával.

A végpont teszteléséhez tesztadatokra van szükség. Töltsük le helyileg a betanítási szkriptben használt tesztadatokat.

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

Töltse be ezeket egy tesztadatkészletbe.

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)

Válasszon 30 véletlenszerű mintát a tesztkészletből, és írja be őket egy JSON-fájlba.

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)

Ezután meghívhatja a végpontot, kinyomtathatja a visszaadott előrejelzéseket, és ábrázolhatja őket a bemeneti rendszerképekkel együtt. A hibásan besorolt minták kiemeléséhez használjon piros betűszínt és fordított képet (feketén fehér).

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

Feljegyzés

Mivel a modell pontossága magas, előfordulhat, hogy néhányszor futtatnia kell a cellát, mielőtt helytelenül besorolt mintát látna.

Az erőforrások eltávolítása

Ha nem használja a végpontot, törölje az erőforrás használatának leállításához. A törlés előtt győződjön meg arról, hogy más üzemelő példányok nem használják a végpontot.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Feljegyzés

Várjon egy kis időt a törlés befejezésére.

Következő lépések

Ebben a cikkben betanított és regisztrált egy Keras-modellt. A modellt egy online végponton is üzembe helyezte. Az Azure Machine Learningről további információt az alábbi cikkekben talál.