Trénování modelů TensorFlow ve velkém s využitím služby Azure Machine Learning

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

V tomto článku se dozvíte, jak spouštět trénovací skripty TensorFlow ve velkém měřítku pomocí sady Azure Machine Learning Python SDK v2.

Ukázkový kód v tomto článku trénuje model TensorFlow ke klasifikaci ručně psaných číslic pomocí hluboké neurální sítě (DNN); zaregistrovat model; a nasadí ho do online koncového bodu.

Bez ohledu na to, jestli vyvíjíte model TensorFlow od základů nebo přinášíte existující model do cloudu, můžete pomocí azure Machine Learning škálovat opensourcové trénovací úlohy s využitím výpočetních prostředků elastického cloudu. Pomocí služby Azure Machine Learning můžete vytvářet, nasazovat, vytvářet verze a monitorovat produkční modely.

Požadavky

Pokud chcete tento článek využít, 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 – nevyžaduje stahování ani instalaci
      • Dokončete rychlý start: Začínáme se službou Azure Machine Learning a vytvořte vyhrazený server poznámkového bloku s předem načteným sadou SDK a ukázkovým úložištěm.
      • Ve složce s ukázkami hlubokého učení na serveru poznámkového bloku vyhledejte dokončený a rozbalený poznámkový blok tak, že přejdete do tohoto adresáře: v2 > sdk > python > jobs > single-step > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow.
    • Server poznámkového bloku Jupyter
  • Stáhněte si následující soubory:

Dokončenou Jupyter Notebook verzi tohoto průvodce najdete také na stránce s ukázkami na GitHubu.

Před spuštěním kódu v tomto článku pro vytvoření clusteru 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í příkazové úlohy a vytvořením prostředí pro spuštění úlohy.

Připojení k pracovnímu prostoru

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

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

Pokud DefaultAzureCredential vám to nepomůže, podívejte azure-identity reference documentationSet up authentication se na nebo na 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 odkomentovat následující kód a použít ho.

# 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 do kódu hodnoty skupina prostředků a ID předplatného.
# 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

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

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

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

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_NC6",
        # 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í úloh

Ke spuštění úlohy AzureML budete potřebovat prostředí. Prostředí AzureML 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í je podobné prostředí Pythonu na místním počítači.

AzureML umožňuje buď použít kurátorované (nebo připravené) prostředí, které je užitečné pro běžné scénáře trénování a odvozování, nebo vytvořit vlastní prostředí pomocí image Dockeru nebo konfigurace Conda.

V tomto článku znovu použijete kurátorované prostředí AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpuAzureML. Použijete nejnovější verzi tohoto prostředí pomocí direktivy .@latest

curated_env_name = "AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu@latest"

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

V této části začneme představením dat pro trénování. Pak probereme, jak spustit trénovací úlohu pomocí trénovacího skriptu, který jsme vám poskytli. Naučíte se sestavit trénovací úlohu nakonfigurováním příkazu pro spuštění trénovacího skriptu. Pak odešlete trénovací úlohu ke spuštění v AzureML.

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

Použijete data ručně psaných číslic z databáze MNIST (Modified National Institute of Standards and Technology). Zdrojem těchto dat je web společnosti Yan LeCun a je uložený v účtu úložiště Azure.

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

Další informace o datové sadě MNIST najdete na webu společnosti Yan LeCun.

Příprava trénovacího skriptu

V tomto článku jsme poskytli trénovací skript tf_mnist.py. V praxi byste měli být schopni vzít libovolný vlastní trénovací skript tak, jak je, a spustit ho s AzureML, aniž byste museli upravovat kód.

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

  • zpracovává předzpracování dat a rozděluje je na testovací a trénovací data;
  • trénuje model s využitím údajů; A
  • vrátí výstupní model.

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

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

  • Vstupní vrstva s 28 * 28 = 784 neuronů. 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é označení od 0 do 9.

Diagram znázorňující hlubokou neurální síť se 784 neurony ve vstupní vrstvě, dvěma skrytými vrstvami a 10 neurony ve výstupní vrstvě

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 AzureML Python SDK v2. V tomto příkladu commandvytvoříme .

AzureML 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é účely command . Vytvořte objekt pro Command zadání podrobností konfigurace 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=64,
        first_layer_neurons=256,
        second_layer_neurons=128,
        learning_rate=0.01,
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",
    command="python tf_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="tf-dnn-image-classify",
    display_name="tensorflow-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 webovou cestu jsme předali přímo jako vstup.

  • Hodnoty parametrů:

    • zadejte výpočetní cluster gpu_compute_target = "gpu-cluster" , který jste vytvořili pro spuštění tohoto příkazu.
    • poskytovat kurátorované prostředí curated_env_name , které jste deklarovali dříve;
    • nakonfigurujte samotnou akci příkazového řádku – v tomto případě je python tf_mnist.pypříkazem . 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é se u určitého projektu provádí. Všechny úlohy odeslané pod stejným názvem experimentu by se ve studiu AzureML zobrazovaly vedle sebe.
  • V tomto příkladu UserIdentity použijete ke spuštění příkazu . 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 ke spuštění v AzureML. Tentokrát použijete na create_or_updateml_client.jobs.

ml_client.jobs.create_or_update(job)

Po dokončení úloha zaregistruje model ve vašem pracovním prostoru (v důsledku trénování) a vypíše odkaz pro zobrazení úlohy ve studiu AzureML.

Upozornění

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 ho nezahrnujte do zdrojového adresáře.

Co se stane při provádění úlohy

Úloha se spouští v následujících fázích:

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

  • Š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ění: Všechny skripty ve složce script 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 složky stdout a ./logs se streamují do historie úloh a dají se použít k monitorování úlohy.

Ladění hyperparametrů modelu

Teď, když jste se seznámili s tím, jak provést trénovací běh TensorFlow pomocí sady SDK, pojďme se podívat, jestli můžete přesnost modelu dále vylepšit. Hyperparametry modelu můžete ladit a optimalizovat pomocí funkcí služby Azure Machine Learning sweep .

Pokud chcete vyladit hyperparametry modelu, definujte prostor parametrů, ve kterém se má hledat během trénování. Uděláte to tak, že některé parametry (batch_size, , first_layer_neuronssecond_layer_neuronsa learning_rate) předané trénovací úloze nahradíte 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=[32, 64, 128]),
    first_layer_neurons=Choice(values=[16, 64, 128, 256, 512]),
    second_layer_neurons=Choice(values=[16, 64, 256, 512]),
    learning_rate=LogUniform(min_value=-6, max_value=-1),
)

Pak nakonfigurujete uklidit pro úlohu příkazu pomocí některých parametrů specifických pro úklid, jako je primární metrika, kterou chcete 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ů ve snaze maximalizovat naši primární metriku validation_acc.

Definujeme také zásady předčasného BanditPolicyukončení – . Tato zásada funguje tak, že kontroluje úlohu každé dvě iterace. Pokud primární metrika validation_accspadá mimo rozsah prvních deseti procent, AzureML úlohu ukončí. Model tak nebude pokračovat ve zkoumání hyperparametrů, které nevykazují žá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="validation_acc",
    goal="Maximize",
    max_total_trials=8,
    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 úklidu, která vaši úlohu vlaku uklidí.

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 na uživatelské 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í najdete spuštění, které vytvořilo 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 "model"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

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

Pak můžete tento model zaregistrovat.

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

Nasazení modelu jako online koncového bodu

Jakmile model zaregistrujete, můžete ho nasadit jako online koncový bod – to znamená jako webovou službu v cloudu Azure.

K nasazení služby strojového učení budete obvykle potřebovat:

  • Prostředky modelu, které chcete nasadit. Mezi tyto prostředky patří soubor modelu a metadata, 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í skript). Tento vstupní skript přijme data odeslaná do nasazené webové služby a předá je 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, AzureML tento skript automaticky vytvoří za vás.

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

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

Jako první krok k nasazení modelu musíte vytvořit online koncový bod. Název koncového bodu musí být jedinečný v celé oblasti Azure. Pro účely tohoto článku vytvoříte jedinečný název pomocí universálně jedinečného identifikátoru (UUID).

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "tff-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 TensorFlow",
    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í zaváděcího skriptu. Koncový bod může mít několik nasazení. Pomocí pravidel pak může koncový bod směrovat provoz do těchto nasazení.

V následujícím kódu vytvoříte jedno nasazení, které zpracuje 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.
  • boduje model pomocí score.py souboru a
  • používá k odvozování stejné kurátorované prostředí (které jste deklarovali dříve).
model = registered_model

from azure.ai.ml.entities import CodeConfiguration

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

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

Poznámka

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

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

Teď, když jste nasadili model do koncového bodu, můžete předpovědět výstup nasazeného modelu pomocí invoke metody na koncovém bodu. Pokud chcete odvozování spustit, použijte ukázkový soubor sample-request.json požadavku ze složky požadavku .

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

Vrácené předpovědi pak můžete vytisknout a vykreslit je spolu se vstupními obrázky. Pomocí červené barvy písma a invertovaného obrázku (bílý na černém) zvýrazněte chybně klasifikované ukázky.

# compare actual value vs. the predicted values:
import matplotlib.pyplot as plt

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á, možná budete muset buňku spustit několikrát, než se zobrazí chybně klasifikovaný vzorek.

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

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

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Poznámka

Očekávejte, že dokončení tohoto čištění bude chvíli trvat.

Další kroky

V tomto článku jste vytrénovali a zaregistrovali model TensorFlow. 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.