PyTorch-modellen op schaal trainen met Azure Machine Learning

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

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

U gebruikt de voorbeeldscripts in dit artikel om afbeeldingen van kippen en kalkoenen te classificeren om een deep learning neuraal netwerk (DNN) te bouwen op basis van de zelfstudie over transfer learning van PyTorch. Transfer learning is een techniek waarmee kennis die is opgedaan bij het oplossen van het ene probleem wordt toegepast op een ander maar gerelateerd probleem. Leeroverdracht verkort het trainingsproces omdat er minder gegevens, tijd en rekenresources nodig zijn dan helemaal zelf trainen. Zie het artikel deep learning versus machine learning voor meer informatie over het overdragen van leren.

Of u nu een Deep Learning PyTorch-model vanaf de basis traint of een bestaand model in de cloud wilt opnemen, u kunt AzureML gebruiken om opensource-trainingstaken uit te schalen met behulp van elastische cloud-rekenresources. U kunt modellen op productieniveau bouwen, implementeren, versien en bewaken met AzureML.

Vereisten

Als u van dit artikel wilt profiteren, moet u het volgende doen:

  • Toegang tot een Azure-abonnement. Als u nog geen account 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: 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 in de deep learning-map voorbeelden op de notebookserver een voltooid en uitgebreid notebook door te navigeren naar deze map: v2 > sdk > python > jobs > single-step > pytorch > train-hyperparameter-tune-deploy-with-pytorch.
    • Uw Jupyter-notebookserver

U kunt ook een voltooide Jupyter Notebook versie van deze handleiding vinden op de pagina Met GitHub-voorbeelden.

Voordat u de code in dit artikel kunt uitvoeren om een GPU-cluster te maken, moet u een quotumverhoging aanvragen voor uw werkruimte.

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 AzureML-werkruimte. De AzureML-werkruimte is de resource op het hoogste niveau voor de service. Het biedt u een centrale plek 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. Met deze referentie moeten de meeste Azure SDK-verificatiescenario's kunnen worden verwerkt.

Als DefaultAzureCredential dit niet werkt, raadpleegt azure-identity reference documentation u of Set up authentication 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 deze in plaats daarvan gebruiken.

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

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

Vervolgens krijgt u een ingang voor 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 naar de naam van uw werkruimte in de rechterbovenhoek van de Azure Machine Learning-studio werkbalk.
  2. Selecteer de naam van uw werkruimte om uw resourcegroep en abonnements-id weer te geven.
  3. Kopieer de waarden voor 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 gebruikt om andere resources en taken te beheren.

Notitie

  • Als u maakt MLClient , wordt de client niet verbonden met de werkruimte. De client initialisatie is lui en wacht op de eerste keer dat er een aanroep moet worden uitgevoerd. In dit artikel gebeurt dit tijdens het maken van de rekenkracht.

Een rekenresource maken om de taak uit te voeren

AzureML heeft een rekenresource nodig om een taak uit te voeren. Deze resource kan machines met één of meerdere knooppunten zijn met het Linux- of Windows-besturingssysteem, of een specifieke rekeninfrastructuur zoals Spark.

In het volgende voorbeeldscript wordt een Linux compute clusteringericht. U kunt de Azure Machine Learning pricing pagina bekijken voor de volledige lijst met VM-grootten en prijzen. Omdat we voor dit voorbeeld een GPU-cluster nodig hebben, gaan we een STANDARD_NC6-model kiezen en een AzureML-berekening maken.

from azure.ai.ml.entities import AmlCompute

gpu_compute_taget = "gpu-cluster"

try:
    # let's see if the compute target already exists
    gpu_cluster = ml_client.compute.get(gpu_compute_taget)
    print(
        f"You already have a cluster named {gpu_compute_taget}, 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}"
)

Een taakomgeving maken

Als u een AzureML-taak wilt uitvoeren, hebt u een omgeving nodig. Een AzureML-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 AzureML 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 AzureML-omgeving AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpuopnieuw. U gebruikt de nieuwste versie van deze omgeving met behulp van de @latest -instructie.

curated_env_name = "AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu@latest"

Uw trainingstaak configureren en verzenden

In deze sectie introduceren we eerst de gegevens voor training. Vervolgens wordt beschreven hoe u een trainingstaak uitvoert met behulp van een trainingsscript dat we hebben verstrekt. U leert hoe u de trainingstaak bouwt door de opdracht voor het uitvoeren van het trainingsscript te configureren. Vervolgens verzendt u de trainingstaak om uit te voeren in AzureML.

De trainingsgegevens ophalen

U gebruikt gegevens die zijn opgeslagen in een openbare blob als een zip-bestand. Deze gegevensset bestaat uit ongeveer 120 trainingsafbeeldingen voor elk twee klassen (kalkoenen en kippen), met 100 validatieafbeeldingen voor elke klasse. De afbeeldingen zijn een subset van de gegevensset Open Images v5. We downloaden en extraheren de gegevensset als onderdeel van ons trainingsscript pytorch_train.py.

Het trainingsscript voorbereiden

In dit artikel hebben we het trainingsscript pytorch_train.py gegeven. In de praktijk moet u elk aangepast trainingsscript ongewijzigd kunnen uitvoeren met AzureML zonder dat u uw code hoeft te wijzigen.

Met het opgegeven trainingsscript worden de gegevens gedownload, wordt een model getraind en wordt het model geregistreerd.

De trainingstaak bouwen

Nu u over alle assets beschikt die nodig zijn om uw taak uit te voeren, is het tijd om deze te bouwen met behulp van de AzureML Python SDK v2. In dit voorbeeld maken we een command.

Een AzureML command is een resource die alle details specificeert die nodig zijn om uw trainingscode in de cloud uit te voeren. Deze details omvatten de in- en uitvoer, het type hardware dat moet worden gebruikt, 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 de gewenste taken uit te voeren. Maak een Command -object om de configuratiedetails 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_taget,
    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, de leersnelheid, het momentum en de uitvoermap.
  • Voor de parameterwaarden:
    • geef het rekencluster gpu_compute_target = "gpu-cluster" op dat u hebt gemaakt voor het uitvoeren van deze opdracht;
    • de gecureerde omgeving AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu bieden die u eerder hebt geïnitialiseerd;
    • configureert u de opdrachtregelactie zelf. In dit geval is python pytorch_train.pyde opdracht . U hebt toegang tot de invoer en uitvoer in de opdracht via de ${{ ... }} notatie; en
    • metagegevens configureren, zoals de weergavenaam en de naam van het experiment; waarbij een experiment een container is voor alle iteraties die voor een bepaald project worden uitgevoerd. Alle taken die onder dezelfde experimentnaam zijn ingediend, worden naast elkaar weergegeven in AzureML Studio.

De taak verzenden

Het is nu tijd om de taak te verzenden en uit te voeren in AzureML. 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 de training) en wordt er een koppeling uitgevoerd om de taak in AzureML Studio weer te geven.

Waarschuwing

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

Wat gebeurt er tijdens het uitvoeren van een 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.

  • Uitvoeren: 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 gestreamd naar de taakgeschiedenis en kunnen worden gebruikt om de taak te bewaken.

Modelhyperparameters afstemmen

U hebt het model getraind met één set parameters. Laten we nu eens 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 die aan de trainingstaak zijn doorgegeven, te vervangen door speciale invoer uit het azure.ml.sweep pakket.

Omdat in het trainingsscript een leerfrequentieschema wordt gebruikt om de leersnelheid om de verschillende tijdperken te laten vervallen, kunt u de initiële 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 configureert u opruimen voor de opdrachttaak, met behulp van enkele specifieke parameters voor opruimen, zoals de primaire metrische gegevens die moeten worden bekeken en het te gebruiken sampling-algoritme.

In de volgende code gebruiken we willekeurige steekproeven om verschillende configuratiesets met 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 vroegtijdig te beëindigen. De BanditPolicy beëindigt elke uitvoering die niet binnen de margefactor van onze primaire metrische evaluatiewaarde valt. U past dit beleid elk tijdvak toe (omdat we onze best_val_acc metrische gegevens elk tijdvak en evaluation_interval=1 rapporteren). U ziet dat de eerste beleidsevaluatie wordt uitgesteld tot na de eerste tien tijdperken (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
    ),
)

Nu kunt u deze taak als voorheen indienen. Deze keer voert u een veegtaak uit die uw treintaak overloopt.

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 bewaken met behulp van de koppeling naar de gebruikersinterface van Studio die wordt weergegeven tijdens het uitvoeren van de taak.

Het beste model vinden

Zodra alle uitvoeringen zijn voltooid, kunt u de uitvoering vinden die het model met de hoogste nauwkeurigheid heeft geproduceerd.

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 metagegevens die u al in uw trainingstaak hebt geregistreerd.
  • 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 naar 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 AzureML dit script automatisch voor u.

Zie Deploy and score a machine learning model with managed online endpoint using Python SDK v2 (Een machine learning-model implementeren en scoren 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 naam van het eindpunt 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

Nadat u het eindpunt hebt gemaakt, kunt u het model implementeren met het invoerscript. Een eindpunt kan meerdere implementaties hebben. Met behulp van regels kan het eindpunt vervolgens verkeer omleiden naar deze implementaties.

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 een andere naam gebruiken, zoals aci-groen of aci-rood voor de implementatie. De code voor het implementeren van het model naar het eindpunt doet het volgende:

  • implementeert de beste versie van het model dat u eerder hebt geregistreerd;
  • beoordeelt het model met behulp van het score.py bestand; en
  • gebruikt 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

Het duurt enige tijd 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.

Laten we een voorbeeldafbeelding voor voorspelling gebruiken om het eindpunt te testen. 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 gebruikt, verwijdert u het om de resource niet meer te gebruiken. Zorg ervoor dat er geen andere implementaties gebruikmaken van het eindpunt voordat u het verwijdert.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Notitie

Het duurt even voordat deze opschoning is voltooid.

Volgende stappen

In dit artikel hebt u een neuraal netwerk voor deep learning 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.