PyTorch-modellen op schaal trainen met Azure Machine Learning

VAN TOEPASSING OP: Python SDK azure-ai-ml v2 (actueel)

In dit artikel leert u hoe u een PyTorch-model traint, hyperparameter afstemt en implementeert met behulp van de Azure Machine Learning Python SDK v2.

U gebruikt voorbeeldscripts om kippen- en kalkoenafbeeldingen te classificeren om een deep learning neural network (DNN) te bouwen op basis van de zelfstudie over overdrachtsleer van PyTorch. Leren overdragen is een techniek die kennis toepast die is opgedaan bij het oplossen van één probleem op een ander, maar gerelateerd probleem. Transfer learning verkort het trainingsproces door minder gegevens, tijd en rekenkracht te vereisen dan training vanaf nul. Zie Deep Learning versus machine learning voor meer informatie over overdrachtsleer.

Of u nu een Deep Learning PyTorch-model traint of een bestaand model naar de cloud brengt, gebruik Azure Machine Learning om opensource-trainingstaken uit te schalen met behulp van elastische cloud-rekenresources. U kunt modellen op productieniveau bouwen, implementeren, versien en bewaken met Azure Machine Learning.

Vereisten

• Een Azure-abonnement. Als u er nog geen hebt, maakt u een gratis account.
• Python 3.10 of hoger.
• Voer de code in dit artikel uit met behulp van een Azure Machine Learning-rekenproces of uw eigen Jupyter-notebook.
  • Azure Machine Learning-rekenproces: er zijn geen downloads of installatie nodig:
    • Voltooi de Quickstart: Aan de slag met Azure Machine Learning om een toegewezen notebookserver te maken die vooraf geladen is met de SDK en de voorbeeldrepository.
    • Zoek op het tabblad Voorbeelden in de sectie Notebooks van uw werkruimte een voltooid en uitgebreid notebook door naar deze map te navigeren: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Uw Jupyter-notebookserver:
    • Installeer de Azure Machine Learning SDK (v2).
    • Download het trainingsscriptbestand pytorch_train.py.

U kunt ook een voltooide Jupyter-notebookversie van deze handleiding vinden op de pagina met GitHub-voorbeelden.

De taak instellen

In deze sectie wordt de taak voor training ingesteld door de vereiste Python-pakketten te laden, verbinding te maken met een werkruimte, een rekenresource te maken om een opdrachttaak uit te voeren en een omgeving te maken om de taak uit te voeren.

Verbinding maken met de werkruimte

Maak eerst verbinding met uw Azure Machine Learning-werkruimte. De werkruimte is de resource op het hoogste niveau voor de service. Het biedt een gecentraliseerde plek om te werken met alle artefacten die u maakt wanneer u Azure Machine Learning gebruikt.

Gebruik DefaultAzureCredential dit om toegang te krijgen tot de werkruimte. Met deze referentie worden de meeste Azure SDK-verificatiescenario's verwerkt.

Als DefaultAzureCredential niet voor u werkt, kunt u het azure.identity-pakket raadplegen of de authenticatie instellen voor meer beschikbare referenties.

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

Krijg vervolgens toegang tot de werkruimte door uw abonnements-ID, de naam van de resourcegroep en de naam van de werkruimte op te geven. Ga als volgt te werk om deze parameters te vinden:

1. Zoek de naam van uw werkruimte in de rechterbovenhoek van de werkbalk Azure Machine Learning-studio.
2. Selecteer de naam van uw werkruimte om uw resourcegroep en abonnements-id weer te geven.
3. Kopieer de waarden voor uw resourcegroep en abonnements-id naar de code.

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

Het resultaat van het uitvoeren van dit script is een werkruimtehandgreep die u kunt gebruiken om andere resources en taken te beheren.

Een rekenresource maken om de taak uit te voeren

Azure Machine Learning heeft een rekenresource nodig om een taak uit te voeren. Deze resource kan één of meerdere knooppuntcomputers zijn met Linux- of Windows-besturingssysteem, of een specifieke rekeninfrastructuur zoals Spark.

In het volgende voorbeeldscript richt u een Linux-rekencluster in. Zie de pagina met prijzen voor Azure Machine Learning voor de volledige lijst met VM-grootten en -prijzen. Omdat u een GPU-cluster nodig hebt voor dit voorbeeld, selecteert u een Standard_NC4as_T4_v3 model en maakt u een Azure Machine Learning-rekenproces.

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

Een taakomgeving maken

Als u een Azure Machine Learning-taak wilt uitvoeren, hebt u een omgeving nodig. Een Azure Machine Learning-omgeving bevat de afhankelijkheden, zoals softwareruntime en bibliotheken, die nodig zijn om uw machine learning-trainingsscript uit te voeren op uw rekenresource. Deze omgeving is vergelijkbaar met een Python-omgeving op uw lokale computer.

Met Azure Machine Learning kunt u een gecureerde (of kant-en-klare) omgeving gebruiken of een aangepaste omgeving maken met behulp van een Docker-installatiekopieën of een Conda-configuratie. In dit artikel gebruikt u de gecureerde Azure Machine Learning-omgeving AzureML-acpt-pytorch-2.8-cuda12.6opnieuw. Gebruik de nieuwste versie van deze omgeving met behulp van de @latest instructie.

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

Configureer en verstuur je trainingstaak

In deze sectie introduceert u de gegevens voor training. Vervolgens wordt uitgelegd hoe u een trainingstaak uitvoert met behulp van een trainingsscript dat u opgeeft. U leert hoe u de trainingstaak bouwt door de opdracht voor het uitvoeren van het trainingsscript te configureren. Vervolgens dient u de trainingstaak in om te worden uitgevoerd in Azure Machine Learning.

De trainingsgegevens verkrijgen

Deze gegevensset bestaat uit ongeveer 120 trainingsafbeeldingen voor twee klassen (kalkoenen en kippen), met 100 validatieafbeeldingen voor elke klasse. De afbeeldingen zijn een subset van de Open Images v5 Dataset. Het trainingsscript pytorch_train.py downloadt en extraheert de gegevensset.

Het trainingsscript voorbereiden

In de sectie Vereisten hebt u het trainingsscript pytorch_train.py opgegeven. In de praktijk moet u elk aangepast trainingsscript kunnen gebruiken en uitvoeren met Azure Machine Learning zonder dat u uw code hoeft te wijzigen.

Het opgegeven trainingsscript downloadt de gegevens, traint een model en registreert het model.

De trainingstaak bouwen

Nu u alle assets hebt die nodig zijn om uw taak uit te voeren, bouwt u deze met behulp van de Azure Machine Learning Python SDK v2. Maak voor dit voorbeeld een command.

Een Azure Machine Learning command is een resource waarmee alle details worden opgegeven die nodig zijn om uw trainingscode in de cloud uit te voeren. Deze details omvatten de invoer en uitvoer, het type hardware dat moet worden gebruikt, de software die moet worden geïnstalleerd en hoe u uw code uitvoert. De command bevat informatie voor het uitvoeren van één opdracht.

De opdracht configureren

Gebruik het algemene doel command om het trainingsscript uit te voeren en uw gewenste taken uit te voeren. Maak een command object om de configuratiegegevens van uw trainingstaak op te geven.

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

• De invoer voor deze opdracht omvat het aantal tijdvakken, leersnelheid, momentum en uitvoermap.
• Voor de parameterwaarden:
  1. Geef het rekencluster gpu_compute_target = "gpu-cluster" op dat u hebt gemaakt voor het uitvoeren van deze opdracht.
  2. Geef de gecureerde omgeving op die u eerder hebt geïnitialiseerd.
  3. Als u het voltooide notitieblok niet in de map Voorbeelden gebruikt, geeft u de locatie van het pytorch_train.py-bestand op.
  4. Configureer de opdrachtregelactie zelf. In dit geval is python pytorch_train.py de opdracht. U hebt toegang tot de invoer en uitvoer in de opdracht via de ${{ ... }} notatie.
  5. Configureer metagegevens zoals de weergavenaam en experimentnaam. Een experiment is een container voor alle iteraties die u voor een bepaald project uitvoert. Alle taken die u onder dezelfde experimentnaam verzendt, worden naast elkaar weergegeven in Azure Machine Learning Studio.

De taak verzenden

Verzend nu de taak die moet worden uitgevoerd in Azure Machine Learning. Gebruik deze keer create_or_update op ml_client.jobs.

ml_client.jobs.create_or_update(job)

Wanneer de taak is voltooid, wordt er een model in uw werkruimte geregistreerd als gevolg van de training. Er wordt ook een koppeling uitgevoerd voor het weergeven van de taak in Azure Machine Learning Studio.

Wat gebeurt er tijdens het uitvoeren van de taak

Terwijl de taak wordt uitgevoerd, doorloopt deze de volgende fasen:

• Voorbereiden: Het proces maakt een Docker-image op basis van de omgeving die u hebt gedefinieerd. Het uploadt de afbeelding naar het containerregister van de werkruimte en slaat deze in de cache op voor latere runs. Het proces streamt ook logboeken naar de taakgeschiedenis, zodat u ze kunt bekijken om de voortgang te controleren. Als u een gecureerde omgeving opgeeft, gebruikt het proces de gecachte afbeelding waarop die gecureerde omgeving is gebaseerd.

• Schalen: Het cluster probeert omhoog te schalen als er meer knooppunten nodig zijn om de uitvoering uit te voeren dan momenteel beschikbaar is.

• Wordt uitgevoerd: Het proces uploadt alle scripts in de src-scriptmap naar het rekendoel. Het koppelt of kopieert gegevensarchieven. Het script wordt uitgevoerd. Het proces streamt uitvoer van stdout en de map ./logs naar de taakgeschiedenis. U kunt deze uitvoer gebruiken om de taak te bewaken.

Modelhyperparameters afstemmen

U hebt het model getraind met één set parameters. Kijk nu of u de nauwkeurigheid van uw model verder kunt verbeteren. De hyperparameters van uw model afstemmen en optimaliseren met behulp van de mogelijkheden van sweep Azure Machine Learning.

Als u de hyperparameters van het model wilt afstemmen, definieert u de parameterruimte die tijdens de training moet worden gezocht. Vervang enkele parameters die zijn doorgegeven aan de trainingstaak door speciale invoer uit het azure.ml.sweep pakket.

Omdat het trainingsscript een leerpad schema gebruikt om de leersnelheid elke paar epochs te laten afnemen, kunt u de aanvankelijke leersnelheid en de momentumparameters afstemmen.

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

Configureer vervolgens sweep-instellingen voor de commandojob met behulp van enkele sweep-specifieke parameters, zoals de primaire meetwaarde om te monitoren en het te gebruiken sampling-algoritme.

In de volgende code probeert willekeurige steekproeven verschillende configuratiesets van hyperparameters in een poging om de primaire metriek te maximaliseren. best_val_acc

U definieert ook een beleid voor vroegtijdige beëindiging, de BanditPolicy, om slecht presterende uitvoeringen vroegtijdig te beëindigen. De BanditPolicy beëindigt elke uitvoering die niet binnen de spelingfactor van de primaire evaluatiemaatstaf valt. U past dit beleid elke periode toe (omdat de best_val_acc metrische waarde elk tijdvak en evaluation_interval=1 wordt gerapporteerd). De eerste beleidsevaluatie wordt uitgesteld tot na de eerste 10 epochs (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
    ),
)

Verzend deze opdracht nu zoals eerder. Deze keer voert u een sweep-taak uit die over uw trainingstaak veegt.

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)

U kunt de taak controleren met behulp van de koppeling naar de gebruikersinterface van de studio die tijdens de uitvoering van de taak wordt weergegeven.

Het beste model zoeken

Wanneer alle uitvoeringen zijn voltooid, zoekt u de uitvoering die het model heeft geproduceerd met de hoogste nauwkeurigheid.

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

Het model implementeren als een online-eindpunt

U kunt uw model nu implementeren als een online-eindpunt, dat wil gezegd, als een webservice in de Azure-cloud.

Voor het implementeren van een machine learning-service hebt u doorgaans het volgende nodig:

• De modelassets die u wilt implementeren. Deze assets omvatten het modelbestand en de metagegevens die u al hebt geregistreerd in uw trainingstaak.
• Sommige code die moet worden uitgevoerd als een service. De code voert het model uit op een bepaalde invoeraanvraag (een invoerscript). Dit script ontvangt gegevens die zijn verzonden naar een geïmplementeerde webservice en geeft deze door aan het model. Nadat het model de gegevens heeft verwerkt, retourneert het script het antwoord van het model op de client. Het script is specifiek voor uw model en moet de gegevens begrijpen die het model verwacht en retourneert. Wanneer u een MLFlow-model gebruikt, maakt Azure Machine Learning dit script automatisch voor u.

Zie Een machine learning-model implementeren en beoordelen met een beheerd online-eindpunt met behulp van Python SDK v2 voor meer informatie over implementatie.

Een nieuw online-eindpunt maken

Als eerste stap voor het implementeren van uw model maakt u uw online-eindpunt. De eindpuntnaam moet uniek zijn in de hele Azure-regio. Maak voor dit artikel een unieke naam met behulp van een UUID (Universally Unique Identifier).

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

Nadat u het eindpunt hebt gemaakt, haalt u het als volgt op:

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

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

Het model implementeren op het eindpunt

Implementeer het model met behulp van het invoerscript. Een eindpunt kan meerdere implementaties hebben. Met behulp van regels kan het eindpunt verkeer naar deze implementaties leiden.

In de volgende code maakt u één implementatie die 100% van het binnenkomende verkeer verwerkt. De code maakt gebruik van een willekeurige kleurnaam blauw voor de implementatie. U kunt ook elke andere naam, zoals groen of rood , gebruiken voor de implementatie.

De code voor het implementeren van het model naar het eindpunt:

• Implementeert de beste versie van het model dat u eerder hebt geregistreerd.
• Het model wordt beoordeeld door het score.py-bestand te gebruiken.
• Maakt gebruik van de gecureerde omgeving (die u eerder hebt opgegeven) om inferentie uit te voeren.

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

Het geïmplementeerde model testen

Nadat u het model op het eindpunt hebt geïmplementeerd, gebruikt u de invoke methode op het eindpunt om de uitvoer van het geïmplementeerde model te voorspellen.

Als u het eindpunt wilt testen, gebruikt u een voorbeeldafbeelding voor voorspelling. Geef eerst de afbeelding weer.

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

Maak een functie om de afbeelding te formatteren en aan te passen.

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

Maak de afbeelding op en converteer deze naar een JSON-bestand.

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)

Roep het eindpunt aan met deze JSON en druk het resultaat af.

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

Middelen opschonen

Als u het eindpunt niet meer nodig hebt, verwijdert u het om te stoppen met het gebruik van de resource. Zorg ervoor dat er geen andere implementaties het eindpunt gebruiken voordat u het verwijdert.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Gerelateerde inhoud

In dit artikel hebt u een neuraal deep learning-netwerk getraind en geregistreerd met behulp van PyTorch in Azure Machine Learning. U hebt het model ook geïmplementeerd op een online-eindpunt. Raadpleeg de volgende artikelen voor meer informatie over Azure Machine Learning:

• Trainingsstatistieken bijhouden tijdens de training
• Hyperparameters instellen
• Referentiearchitectuur voor gedistribueerde Deep Learning-training in Azure