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. Leerproces overdragen verkort het trainingsproces door minder gegevens, tijd en rekenresources te vereisen dan de training helemaal zelf. Zie Deep Learning versus machine learning voor meer informatie over overdrachtsleer.

Of u nu een Deep Learning PyTorch-model traint vanaf de basis of als u een bestaand model in de cloud brengt, gebruikt u 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.
• 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 is geladen met de SDK en de voorbeeldopslagplaats.
    • 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

Eerst moet u verbinding maken met uw Azure Machine Learning-werkruimte. De werkruimte is de resource op het hoogste niveau voor de service. Het biedt u een centrale locatie om te werken met alle artefacten die u maakt wanneer u Azure Machine Learning gebruikt.

We gebruiken DefaultAzureCredential om toegang te krijgen tot de werkruimte. Deze referentie moet geschikt zijn voor het verwerken van de meeste Azure SDK-verificatiescenario's.

Als DefaultAzureCredential dit niet werkt, raadpleegt u het azure.identity-pakket of stelt u verificatie in voor meer beschikbare referenties.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Als u liever een browser gebruikt om u aan te melden en te verifiëren, moet u de opmerkingen bij de volgende code verwijderen en in plaats daarvan gebruiken.

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

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

Haal vervolgens een ingang op voor de werkruimte door uw abonnements-id, resourcegroepnaam en werkruimtenaam 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.

Notitie

Bij het maken MLClient wordt de client niet verbonden met de werkruimte. De initialisatie van de client is lui en wacht op de eerste keer dat de client een oproep moet doen. In dit artikel gebeurt dit tijdens het maken van het rekenproces.

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 machines met één of meerdere knooppunten zijn met Linux- of Windows-besturingssysteem, of een specifieke rekeninfrastructuur zoals Spark.

In het volgende voorbeeldscript richten we een Linux-rekencluster in. U kunt de pagina met prijzen voor Azure Machine Learning bekijken voor de volledige lijst met VM-grootten en -prijzen. Omdat we een GPU-cluster nodig hebben voor dit voorbeeld, gaan we een STANDARD_NC6 model kiezen en een Azure Machine Learning-rekenproces maken.

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

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.2-cuda12.1opnieuw. Gebruik de nieuwste versie van deze omgeving met behulp van de @latest instructie.

curated_env_name = "AzureML-acpt-pytorch-2.2-cuda12.1@latest"

Uw trainingstaak configureren en verzenden

In deze sectie beginnen we met het introduceren van de gegevens voor training. Vervolgens bespreken we hoe u een trainingstaak uitvoert met behulp van een trainingsscript dat we hebben opgegeven. 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

U kunt de gegevensset in dit zip-bestand gebruiken. Deze gegevensset bestaat uit ongeveer 120 trainingsafbeeldingen voor twee klassen (kalkoenen en kippen), met 100 validatieafbeeldingen voor elke klasse. De installatiekopieën zijn een subset van de Open Images v5-gegevensset. Het trainingsscript pytorch_train.py downloadt en extraheert de gegevensset.

Het trainingsscript voorbereiden

In de sectie Vereisten hebben we het trainingsscript pytorch_train.py gegeven. 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, is het tijd om deze te bouwen met behulp van de Azure Machine Learning Python SDK v2. Voor dit voorbeeld maken we 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

U gebruikt 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 de opdracht python pytorch_train.py. U hebt toegang tot de invoer en uitvoer in de opdracht via de ${{ ... }} notatie.
  5. Configureer metagegevens zoals de weergavenaam en de naam van het experiment, waarbij een experiment een container is voor alle iteraties die een bepaalde project uitvoert. Alle taken die onder dezelfde experimentnaam worden ingediend, worden naast elkaar weergegeven in Azure Machine Learning-studio.

De taak verzenden

Het is nu tijd om de taak in te dienen om te worden uitgevoerd in Azure Machine Learning. Deze keer gebruikt create_or_update u op ml_client.jobs.

ml_client.jobs.create_or_update(job)

Zodra de taak is voltooid, wordt een model in uw werkruimte geregistreerd (als gevolg van training) en wordt er een koppeling uitgevoerd voor het weergeven van de taak in Azure Machine Learning-studio.

Waarschuwing

Azure Machine Learning voert trainingsscripts uit door de volledige bronmap te kopiëren. Als u gevoelige gegevens hebt die u niet wilt uploaden, gebruikt u een .ignore-bestand of neemt u het niet op in de bronmap.

Wat gebeurt er tijdens het uitvoeren van de taak

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

• Voorbereiden: Er wordt een Docker-installatiekopieën gemaakt op basis van de gedefinieerde omgeving. De installatiekopieën worden geüpload naar het containerregister van de werkruimte en in de cache opgeslagen voor latere uitvoeringen. Logboeken worden ook gestreamd naar de taakgeschiedenis en kunnen worden bekeken om de voortgang te controleren. Als er een gecureerde omgeving is opgegeven, wordt de back-up van de gecureerde omgeving in de cache gebruikt.

• 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: Alle scripts in de scriptmap src worden geüpload naar het rekendoel, gegevensarchieven worden gekoppeld of gekopieerd en het script wordt uitgevoerd. Uitvoer van stdout en de map ./logs worden naar de taakgeschiedenis gestreamd en kunnen worden gebruikt om de taak te bewaken.

Modelhyperparameters afstemmen

U hebt het model getraind met één set parameters. Laten we nu kijken of u de nauwkeurigheid van uw model verder kunt verbeteren. U kunt 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 waarin tijdens de training moet worden gezocht. U doet dit door enkele parameters te vervangen die aan de trainingstaak zijn doorgegeven door speciale invoer uit het azure.ml.sweep pakket.

Omdat in het trainingsscript een leerfrequentieschema wordt gebruikt om de leersnelheid om de verschillende tijdvakken te vervalsen, 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),
)

Vervolgens kunt u opruimen configureren voor de opdrachttaak, met behulp van een aantal sweep-specifieke parameters, zoals de primaire metriek om te bekijken en het sampling-algoritme dat moet worden gebruikt.

In de volgende code gebruiken we willekeurige steekproeven om verschillende configuratiesets van hyperparameters uit te proberen in een poging om onze primaire metrische gegevens te maximaliseren. best_val_acc

We definiëren ook een beleid voor vroegtijdige beëindiging, de BanditPolicy, om slecht presterende uitvoeringen vroeg te beëindigen. De BanditPolicy uitvoering wordt beëindigd die niet binnen de margefactor van de primaire evaluatiewaarde valt. U past dit beleid elke periode toe (omdat we onze best_val_acc metrische gegevens elk tijdvak en evaluation_interval=1 rapporteren). U ziet dat we de eerste beleidsevaluatie vertragen 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
    ),
)

U kunt deze taak nu indienen zoals voorheen. 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 gebruikersinterfacekoppeling van studio die wordt weergegeven tijdens de taakuitvoering.

Het beste model zoeken

Zodra alle uitvoeringen zijn voltooid, kunt u de uitvoering vinden 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 bestand en de metagegevens van het model 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 invoerscript 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 moet u uw online-eindpunt maken. De eindpuntnaam moet uniek zijn in de hele Azure-regio. Voor dit artikel maakt u 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, kunt u het als volgt ophalen:

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

U kunt het model nu implementeren met het invoerscript. Een eindpunt kan meerdere implementaties hebben. Met behulp van regels kan het eindpunt vervolgens verkeer naar deze implementaties leiden.

In de volgende code maakt u één implementatie die 100% van het binnenkomende verkeer verwerkt. We hebben een willekeurige kleurnaam aci-blauw opgegeven voor de implementatie. U kunt ook elke andere naam gebruiken, zoals aci-groen of aci-rood 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.
• Hiermee wordt het model gescored met behulp van het score.py-bestand .
• Maakt gebruik van de gecureerde omgeving (die u eerder hebt opgegeven) om deductie 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_NC6s_v3",
    instance_count=1,
)

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

Notitie

Verwacht dat het even duurt voordat deze implementatie is voltooid.

Het geïmplementeerde model testen

Nu u het model op het eindpunt hebt geïmplementeerd, kunt u de uitvoer van het geïmplementeerde model voorspellen met behulp van de invoke methode op het eindpunt.

Als u het eindpunt wilt testen, gebruiken we een voorbeeldafbeelding voor voorspelling. Laten we eerst de afbeelding weergeven.

# 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 op te maken en het formaat ervan te wijzigen.

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

Vervolgens kunt u het eindpunt aanroepen met deze JSON en het resultaat afdrukken.

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

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

Notitie

Verwacht dat het even duurt voordat deze opschoonactie is voltooid.

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. Zie deze andere artikelen voor meer informatie over Azure Machine Learning.

• Metrische gegevens voor uitvoering bijhouden tijdens de training
• Hyperparameters afstemmen
• Referentiearchitectuur voor gedistribueerde Deep Learning-training in Azure