Sdílet prostřednictvím

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

  • Článek

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

V tomto článku se naučíte trénovat, ladit hyperparametry a nasazovat model PyTorch pomocí sady Azure Machine Learning Python SDK v2.

Pomocí ukázkových skriptů klasifikujete obrázky kuřete a krůtí k vytvoření neurální sítě hlubokého učení (DNN) na základě kurzu přenosu PyTorch. Transfer learning je technika, která využívá znalosti získané z řešení jednoho problému na jiný, ale související problém. Přenos učení zkracuje proces trénování tím, že vyžaduje méně dat, času a výpočetních prostředků než trénování od začátku. Další informace o přenosu učení najdete v tématu Hluboké učení a strojové učení.

Bez ohledu na to, jestli trénujete model PyTorch hlubokého učení od základů nebo přenesete existující model do cloudu, využijte Azure Machine Learning k horizontálnímu navýšení kapacity opensourcových trénovacích úloh pomocí elastických cloudových výpočetních prostředků. Pomocí služby Azure Machine Learning můžete vytvářet, nasazovat, nasazovat, verze a monitorovat modely na úrovni produkčního prostředí.

Požadavky

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

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 musíte připojit ke svému pracovnímu prostoru Azure Machine Learning. Pracovní prostor 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.

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 to nepomůže, podívejte se na balíček azure.identity nebo nastavte ověřování pro 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 vašeho pracovního prostoru, aby se zobrazila vaše skupina prostředků a ID předplatného.
  3. Zkopírujte do kódu hodnoty vaší skupiny 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ý můžete použít ke správě jiný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 čeká na první volání. V tomto článku k tomu dochází 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 výpočetní cluster s Linuxem. Úplný seznam velikostí a cen virtuálních počítačů najdete na stránce s cenami služby Azure Machine Learning. Vzhledem k tomu, že pro tento příklad potřebujeme cluster GPU, vybereme STANDARD_NC6 model 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 potřebujete 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 znovu použijete kurátorované prostředí AzureML-acpt-pytorch-2.2-cuda12.1Azure Machine Learning . Použijte nejnovější verzi tohoto prostředí pomocí direktivy @latest .

curated_env_name = "AzureML-acpt-pytorch-2.2-cuda12.1@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 zadali. Naučíte se sestavit trénovací úlohu konfigurací příkazu pro spuštění trénovacího skriptu. Pak odešlete úlohu trénování, která se spustí ve službě Azure Machine Learning.

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

Datovou sadu můžete použít v tomto komprimovaném souboru. Tato datová sada se skládá z přibližně 120 trénovacích obrázků pro dvě třídy (krůty a kuřata) s 100 ověřovacími obrázky pro každou třídu. Obrázky jsou podmnožinou datové sady Open Images v5. Trénovací skript pytorch_train.py stáhne a extrahuje datovou sadu.

Příprava trénovacího skriptu

V části Požadavky jsme zadali trénovací skript pytorch_train.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 stáhne data, trénuje model a zaregistruje model.

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 provádění 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 Input

job = command(
    inputs=dict(
        num_epochs=30, learning_rate=0.001, momentum=0.9, output_dir="./outputs"
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",  # location of source code
    command="python pytorch_train.py --num_epochs ${{inputs.num_epochs}} --output_dir ${{inputs.output_dir}}",
    experiment_name="pytorch-birds",
    display_name="pytorch-birds-image",
)
  • Vstupy pro tento příkaz zahrnují počet epoch, rychlost učení, dynamiku a výstupní adresář.
  • Pro hodnoty parametrů:
    1. Zadejte výpočetní cluster gpu_compute_target = "gpu-cluster" , který jste vytvořili pro spuštění tohoto příkazu.
    2. Zadejte kurátorované prostředí, které jste inicializovali dříve.
    3. Pokud dokončený poznámkový blok nepoužíváte ve složce Ukázky, zadejte umístění souboru pytorch_train.py .
    4. Nakonfigurujte samotnou akci příkazového řádku – v tomto případě příkaz je python pytorch_train.py. Vstupy a výstupy v příkazu můžete získat prostřednictvím zápisu ${{ ... }} .
    5. Nakonfigurujte metadata, jako je zobrazovaný název a název experimentu, kde je experiment kontejnerem 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.

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 na 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á 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

Vytrénovali jste model jednou sadou 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 předané trénovací úloze speciálními vstupy z azure.ml.sweep balíčku.

Vzhledem k tomu, že trénovací skript používá plán rychlosti učení k rozpadu rychlosti učení každých několik epoch, můžete ladit počáteční rychlost učení a parametry dynamiky.

from azure.ai.ml.sweep import Uniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
job_for_sweep = job(
    learning_rate=Uniform(min_value=0.0005, max_value=0.005),
    momentum=Uniform(min_value=0.9, max_value=0.99),
)

Pak můžete pro úlohu příkazu nakonfigurovat úklid pomocí některých parametrů specifických pro úklid, například primární metriky ke sledování a algoritmu 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 best_val_acc.

Definujeme také zásady předčasného ukončení, tj BanditPolicy. , pro ukončení špatně fungujících spuštění v rané fázi. Ukončí BanditPolicy všechna spuštění, která nespadají do faktoru slack naší primární metriky hodnocení. Tuto zásadu použijete každou epochu (protože hlásíme metriku best_val_acc každé epochy a evaluation_interval=1). Všimněte si, že odložíme první vyhodnocení zásad až po prvních 10 epochách (delay_evaluation=10).

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute="gpu-cluster",
    sampling_algorithm="random",
    primary_metric="best_val_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(
        slack_factor=0.15, evaluation_interval=1, delay_evaluation=10
    ),
)

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

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í 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 "outputs"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/".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
        )
    )

Nasazení modelu jako online koncového bodu

Model teď 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 = "aci-birds-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import ManagedOnlineEndpoint

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify turkey/chickens using transfer learning with PyTorch",
    auth_mode="key",
    tags={"data": "birds", "method": "transfer learning", "framework": "pytorch"},
)

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

print(f"Endpoint {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

Model teď můžete 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 aci-blue . Pro nasazení můžete také použít jakýkoli jiný název, například aci-green nebo aci-red .

Kód pro nasazení modelu do koncového bodu:

  • Nasadí nejlepší verzi modelu, který jste zaregistrovali dříve.
  • Vyhodnocí model pomocí souboru score.py .
  • Použije kurátorované prostředí (které jste zadali dříve) k odvozování.
from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
)

online_deployment_name = "aci-blue"

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name=online_deployment_name,
    endpoint_name=online_endpoint_name,
    model=model,
    environment=curated_env_name,
    code_configuration=CodeConfiguration(code="./score/", scoring_script="score.py"),
    instance_type="Standard_NC6s_v3",
    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 použijeme k predikci ukázkový obrázek. Nejprve zobrazíme obrázek.

# install pillow if PIL cannot imported
%pip install pillow
import json
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline
plt.imshow(Image.open("test_img.jpg"))

Vytvořte funkci pro formátování a změnu velikosti obrázku.

# install torch and torchvision if needed
%pip install torch
%pip install torchvision

import torch
from torchvision import transforms


def preprocess(image_file):
    """Preprocess the input image."""
    data_transforms = transforms.Compose(
        [
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )

    image = Image.open(image_file)
    image = data_transforms(image).float()
    image = torch.tensor(image)
    image = image.unsqueeze(0)
    return image.numpy()

Naformátujte obrázek a převeďte ho na soubor JSON.

image_data = preprocess("test_img.jpg")
input_data = json.dumps({"data": image_data.tolist()})
with open("request.json", "w") as outfile:
    outfile.write(input_data)

Koncový bod pak můžete vyvolat pomocí tohoto KÓDU JSON a vytisknout výsledek.

# test the blue deployment
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="request.json",
    deployment_name=online_deployment_name,
)

print(result)

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

Pokud už koncový bod nepotřebujete, odstraňte ho, abyste přestali používat prostředek. 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á.

Související obsah

V tomto článku jste natrénovali a zaregistrovali neurální síť hlubokého učení pomocí PyTorchu ve službě Azure Machine Learning. 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.