Träna PyTorch-modeller i stor skala med Azure Machine Learning

GÄLLER FÖR: Python SDK azure-ai-ml v2 (aktuell)

I den här artikeln lär du dig hur du tränar, finjusterar hyperparameter och distribuerar en PyTorch-modell med hjälp av Azure Machine Learning Python SDK v2.

Du använder exempelskript för att klassificera kyckling- och kalkonbilder för att skapa ett neuralt nätverk för djupinlärning (DNN) baserat på PyTorchs självstudie om överföringsinlärning. Överföringsinlärning är en teknik som tillämpar kunskap från att lösa ett problem på ett annat men relaterat problem. Överföringsinlärning förkortar träningsprocessen genom att kräva mindre data-, tids- och beräkningsresurser än träning från grunden. Mer information om överföringsinlärning finns i Djupinlärning jämfört med maskininlärning.

Oavsett om du tränar en PyTorch-modell för djupinlärning från grunden eller om du för in en befintlig modell i molnet kan du använda Azure Machine Learning för att skala ut träningsjobb med öppen källkod med hjälp av elastiska beräkningsresurser för molnet. Du kan skapa, distribuera, version och övervaka modeller i produktionsklass med Azure Machine Learning.

Förutsättningar

• En Azure-prenumeration. Om du inte redan har ett skapar du ett kostnadsfritt konto.
• Python 3.10 eller senare.
• Kör koden i den här artikeln med hjälp av antingen en Azure Machine Learning-beräkningsinstans eller en egen Jupyter-notebook-fil.
  • Azure Machine Learning-beräkningsinstans – inga nedladdningar eller installation krävs:
    • Slutför snabbstarten: Kom igång med Azure Machine Learning för att skapa en dedikerad notebook-server som är förinstallerad med SDK och exempellagringsplatsen.
    • Under fliken Exempel i avsnittet Notebooks på din arbetsyta, kan du hitta en färdig och utökad anteckningsbok genom att navigera till den här katalogen: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Jupyter Notebook-servern:
    • Installera Azure Machine Learning SDK (v2).
    • Ladda ned träningsskriptfilen pytorch_train.py.

Du hittar också en färdig Jupyter Notebook-version av den här guiden på sidan GitHub-exempel.

Konfigurera jobbet

Det här avsnittet konfigurerar jobbet för träning genom att läsa in nödvändiga Python-paket, ansluta till en arbetsyta, skapa en beräkningsresurs för att köra ett kommandojobb och skapa en miljö för att köra jobbet.

Anslut till arbetsytan

Anslut först till din Azure Machine Learning-arbetsyta. Arbetsytan är den översta resursen för tjänsten. Det ger en central plats där du kan arbeta med alla artefakter som du skapar när du använder Azure Machine Learning.

Använd DefaultAzureCredential för att komma åt arbetsytan. Den här autentiseringsuppgiften hanterar de flesta Azure SDKs-autentiseringsscenarier.

Om DefaultAzureCredential det inte fungerar för dig kan du läsa azure.identity-paketet eller Konfigurera autentisering för mer tillgängliga autentiseringsuppgifter.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

from azure.identity import InteractiveBrowserCredential
credential = InteractiveBrowserCredential()

Få därefter åtkomst till arbetsytan genom att ange ditt abonnemangs-ID, resursgruppsnamn och arbetsytenamn. Så här hittar du följande parametrar:

1. Leta efter namnet på arbetsytan i det övre högra hörnet av verktygsfältet i Azure Machine Learning Studio.
2. Välj namnet på arbetsytan för att visa resursgruppen och prenumerations-ID:t.
3. Kopiera värdena för resursgruppen och prenumerations-ID:t till koden.

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

Resultatet av att köra det här skriptet är en arbetsytereferens som du kan använda för att hantera andra resurser och jobb.

Skapa en beräkningsresurs för att köra jobbet

Azure Machine Learning behöver en beräkningsresurs för att köra ett jobb. Den här resursen kan vara enstaka datorer eller datorer med flera noder med Linux eller Windows OS, eller en specifik beräkningsinfrastruktur som Spark.

I följande exempelskript etablerar du ett Linux-beräkningskluster. En fullständig lista över vm-storlekar och priser finns på sidan med priser för Azure Machine Learning . Eftersom du behöver ett GPU-kluster för det här exemplet väljer du en Standard_NC4as_T4_v3 modell och skapar en Azure Machine Learning-beräkning.

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

Skapa en jobbmiljö

Om du vill köra ett Azure Machine Learning-jobb behöver du en miljö. En Azure Machine Learning-miljö kapslar in beroendena, till exempel programkörning och bibliotek, som behövs för att köra maskininlärningsträningsskriptet på beräkningsresursen. Den här miljön liknar en Python-miljö på den lokala datorn.

Med Azure Machine Learning kan du antingen använda en kuraterad (eller färdig) miljö eller skapa en anpassad miljö med hjälp av en Docker-avbildning eller en Conda-konfiguration. I den här artikeln återanvänder du den utvalda Azure Machine Learning-miljön AzureML-acpt-pytorch-2.8-cuda12.6. Använd den senaste versionen av den här miljön genom att använda direktivet @latest.

curated_env_name = "AzureML-acpt-pytorch-2.8-cuda12.6@latest"

Konfigurera och skicka ditt träningsjobb

I det här avsnittet introducerar du träningsdata. Sedan beskriver du hur du kör ett träningsjobb med hjälp av ett träningsskript som du tillhandahåller. Du lär dig att skapa träningsjobbet genom att konfigurera kommandot för att köra träningsskriptet. Sedan skickar du träningsjobbet som ska köras i Azure Machine Learning.

Hämta träningsdata

Den här datamängden består av cirka 120 träningsbilder vardera för två klasser (kalkoner och kycklingar), med 100 valideringsbilder för varje klass. Bilderna är en delmängd av datauppsättningen Öppna bilder v5. Träningsskriptet pytorch_train.py laddar ned och extraherar datauppsättningen.

Förbereda träningsskriptet

I avsnittet förutsättningar angav du träningsskriptet pytorch_train.py. I praktiken bör du kunna använda ett anpassat träningsskript som det är och köra det med Azure Machine Learning utan att behöva ändra koden.

Det angivna träningsskriptet laddar ned data, tränar en modell och registrerar modellen.

Skapa träningsjobbet

Nu när du har alla tillgångar som krävs för att köra jobbet skapar du det med hjälp av Azure Machine Learning Python SDK v2. I det här exemplet skapar du en command.

En Azure Machine Learning command är en resurs som anger all information som behövs för att köra träningskoden i molnet. Den här informationen omfattar indata och utdata, typ av maskinvara som ska användas, programvara som ska installeras och hur du kör koden. Detta command innehåller information för att köra ett enda kommando.

Konfigurera kommandot

Använd det allmänna syftet command för att köra träningsskriptet och utföra önskade uppgifter. Skapa ett command objekt för att ange konfigurationsinformationen för ditt träningsjobb.

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

• Indata för det här kommandot omfattar antalet epoker, inlärningshastighet, momentum och utdatakatalog.
• För parametervärdena:
  1. Ange det beräkningskluster gpu_compute_target = "gpu-cluster" som du skapade för att köra det här kommandot.
  2. Ange den kuraterade miljö som du initierade tidigare.
  3. Om du inte använder den slutförda anteckningsboken i mappen Exempel anger du platsen för filen pytorch_train.py .
  4. Konfigurera själva kommandoradsåtgärden. I det här fallet är kommandot python pytorch_train.py. Du kan komma åt indata och utdata i kommandot via notationen ${{ ... }} .
  5. Konfigurera metadata, till exempel visningsnamn och experimentnamn. Ett experiment är en container för alla iterationer som du gör i ett visst projekt. Alla jobb som du skickar under samma experimentnamn visas bredvid varandra i Azure Machine Learning Studio.

Skicka in jobbet

Skicka nu jobbet som ska köras i Azure Machine Learning. Använd den här gången create_or_update på ml_client.jobs.

ml_client.jobs.create_or_update(job)

När jobbet är klart registreras en modell på din arbetsyta som ett resultat av träningen. Den matar också ut en länk för att visa jobbet i Azure Machine Learning Studio.

Vad händer under jobbexekveringen?

När jobbet körs går det igenom följande steg:

• Förbereder: Processen skapar en Docker-avbildning enligt den miljö som du har definierat. Den laddar upp avbildningen till arbetsytans containerregister och cachelagrar den för senare körningar. Processen strömmar även loggar till jobbhistoriken, så att du kan visa dem för att övervaka förloppet. Om du anger en kuraterad miljö använder processen den cachelagrade avbildningen som backar upp den kurerade miljön.

• Skalning: Klustret försöker skala upp om det krävs fler noder för att köra körningen än vad som för närvarande är tillgängligt.

• Körs: Processen laddar upp alla skript i mappen src-skript till beräkningsmålet. Den monterar eller kopierar datalager. Skriptet körs. Processen strömmar utdata från stdout och mappen ./logs till jobbhistoriken. Du kan använda dessa utdata för att övervaka jobbet.

Finjustera modellhyperparametrar

Du har tränat modellen med en uppsättning parametrar. Nu ska du se om du kan förbättra modellens noggrannhet ytterligare. Justera och optimera modellens hyperparametrar med hjälp av Funktionerna i Azure Machine Learning sweep .

Om du vill justera modellens hyperparametrar definierar du parameterutrymmet som ska sökas under träningen. Ersätt några av de parametrar som skickas till träningsjobbet med särskilda indata från azure.ml.sweep paketet.

Eftersom träningsskriptet använder ett inlärningshastighetsschema för att minska inlärningshastigheten under flera epoker kan du justera den inledande inlärningshastigheten och momentum-parametrarna.

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

Konfigurera sedan svepning på kommandojobbet med hjälp av några svepspecifika parametrar, till exempel det primära måttet att titta på och samplingsalgoritmen som ska användas.

I följande kod provar slumpmässig sampling olika konfigurationsuppsättningar med hyperparametrar i ett försök att maximera det primära måttet, best_val_acc.

Du definierar också en princip för tidig avslutning, BanditPolicy, för att tidigt avsluta körningar som presterar dåligt. BanditPolicy Avbryter alla körningar som inte faller inom slackfaktorn för det primära utvärderingsmåttet. Du tillämpar den här principen varje epok (eftersom måttet best_val_acc rapporteras varje epok och evaluation_interval=1). Den första principutvärderingen fördröjs till efter de första 10 epokerna (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
    ),
)

Skicka nu det här jobbet som tidigare. Den här gången kör du ett svepjobb som sveper över ditt tågjobb.

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)

Du kan övervaka jobbet med hjälp av länken för studio-gränssnittet som visas när jobbet körs.

Hitta den bästa modellen

När alla körningar har avslutats, hitta den körning som producerade modellen med mest noggrannhet.

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

Distribuera modellen som en onlineslutpunkt

Nu kan du distribuera din modell som en onlineslutpunkt, dvs. som en webbtjänst i Azure-molnet.

För att distribuera en maskininlärningstjänst behöver du vanligtvis:

• De modelltillgångar som du vill driftsätta. Dessa tillgångar innefattar modellfilen och den metadata som du redan har registrerat i ditt träningsprojekt.
• Viss kod som ska köras som en tjänst. Koden kör modellen på en angiven indatabegäran (ett inmatningsskript). Det här skriptet tar emot data som skickas till en distribuerad webbtjänst och skickar dem till modellen. När modellen har bearbetat data returnerar skriptet modellens svar till klienten. Skriptet är specifikt för din modell och måste förstå de data som modellen förväntar sig och returnerar. När du använder en MLFlow-modell skapar Azure Machine Learning automatiskt det här skriptet åt dig.

Mer information om distribution finns i Distribuera och poängsätta en maskininlärningsmodell med hanterad onlineslutpunkt med Python SDK v2.

Skapa en ny onlineslutpunkt

Som ett första steg för att distribuera din modell skapar du din onlineslutpunkt. Slutpunktsnamnet måste vara unikt i hela Azure-regionen. I den här artikeln skapar du ett unikt namn med hjälp av en universellt unik identifierare (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}")

När du har skapat slutpunkten hämtar du den på följande sätt:

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

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

Distribuera modellen till slutpunkten

Distribuera modellen med hjälp av inmatningsskriptet. En slutpunkt kan ha flera distributioner. Med hjälp av regler kan slutpunkten dirigera trafik till dessa utplaceringar.

I följande kod skapar du en enda distribution som hanterar 100 % av den inkommande trafiken. Koden använder ett godtyckligt färgnamn blått för distributionen. Du kan också använda andra namn, till exempel grönt eller rött för distributionen.

Koden för att distribuera modellen till slutpunkten:

• Distribuerar den bästa versionen av modellen som du registrerade tidigare.
• Poängsätter modellen med hjälp av filen score.py .
• Använder den kurerade miljön (som du angav tidigare) för att utföra inferens.

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_NC4AS_T4_V3",
    instance_count=1,
)

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

Testa den implementerade modellen

När du har distribuerat modellen till slutpunkten använder du invoke metoden på slutpunkten för att förutsäga utdata från den distribuerade modellen.

Om du vill testa slutpunkten använder du en exempelbild för förutsägelse. Visa först bilden.

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

Skapa en funktion för att formatera och ändra storlek på avbildningen.

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

Formatera bilden och konvertera den till en JSON-fil.

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)

Anropa slutpunkten med den här JSON-filen och skriv ut resultatet.

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

Rensa resurser

Om du inte längre behöver slutpunkten tar du bort den för att sluta använda resursen. Se till att inga andra distributioner använder slutpunkten innan du tar bort den.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Relaterat innehåll

I den här artikeln har du tränat och registrerat ett neuralt nätverk för djupinlärning med PyTorch i Azure Machine Learning. Du har också distribuerat modellen till en onlineslutpunkt. Mer information om Azure Machine Learning finns i följande artiklar:

• Spåra körningsmått under träning
• Justera hyperparametrar
• Referensarkitektur för distribuerad djupinlärningsutbildning i Azure