PyTorch-modellek nagy léptékű betanítása az Azure Machine Learning használatával

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)

Ebből a cikkből megtudhatja, hogyan taníthat be, hangolhat hiperparamétereket és helyezhet üzembe PyTorch-modelleket az Azure Machine Learning (AzureML) Python SDK v2 használatával.

A cikkben szereplő példaszkriptekkel osztályozhatja a csirke- és pulykaképeket egy mélytanulási neurális hálózat (DNN) létrehozásához a PyTorch átviteli tanulási oktatóanyaga alapján. Az átadási tanulás egy olyan technika, amely az egyik probléma megoldásából szerzett tudást egy másik, de kapcsolódó problémára alkalmazza. Az átviteli tanulás lerövidíti a betanítási folyamatot azáltal, hogy kevesebb adatot, időt és számítási erőforrást igényel, mint az alapoktól való betanítás. Az átadási tanulásról további információt a mély tanulás és a gépi tanulás című cikkben talál.

Akár mélytanulási PyTorch-modellt tanít be az alapoktól, akár egy meglévő modellt hoz a felhőbe, az AzureML használatával kibővítheti a nyílt forráskódú betanítási feladatokat rugalmas felhőbeli számítási erőforrások használatával. Az AzureML használatával éles üzemű modelleket hozhat létre, helyezhet üzembe, futtathat és monitorozhat.

Előfeltételek

A cikk előnyeinek kihasználásához a következőket kell elvégeznie:

Az útmutató befejezett Jupyter Notebook verzióját a GitHub-minták oldalán is megtalálhatja.

Mielőtt a cikkben szereplő kódot futtatva létrehozna egy GPU-fürtöt, kvótanövelést kell kérnie a munkaterülethez.

A feladat beállítása

Ez a szakasz betanításra állítja be a feladatot a szükséges Python-csomagok betöltésével, egy munkaterülethez való csatlakozással, egy számítási erőforrás létrehozásával egy parancsfeladat futtatásához, valamint egy környezet létrehozásával a feladat futtatásához.

Csatlakozás a munkaterülethez

Először csatlakoznia kell az AzureML-munkaterülethez. Az AzureML-munkaterület a szolgáltatás legfelső szintű erőforrása. Központi helyet biztosít az Azure Machine Learning használata során létrehozott összes összetevő használatához.

A használatával DefaultAzureCredential férünk hozzá a munkaterülethez. Ennek a hitelesítő adatnak képesnek kell lennie a legtöbb Azure SDK-hitelesítési forgatókönyv kezelésére.

Ha DefaultAzureCredential nem működik az Ön számára, tekintse meg vagy Set up authentication tekintse meg azure-identity reference documentation a további elérhető hitelesítő adatokat.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Ha inkább böngészőt használ a bejelentkezéshez és a hitelesítéshez, törölje a következő kód megjegyzését, és használja helyette.

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

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

Ezután lekérheti a munkaterület leíróját az előfizetés azonosítójának, az erőforráscsoport nevének és a munkaterület nevének megadásával. A következő paraméterek megkeresése:

  1. Keresse meg a munkaterület nevét az Azure Machine Learning stúdió eszköztár jobb felső sarkában.
  2. Válassza ki a munkaterület nevét az erőforráscsoport és az előfizetés azonosítójának megjelenítéséhez.
  3. Másolja az erőforráscsoport és az előfizetés-azonosító értékeit a kódba.
# 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>",
)

A szkript futtatásának eredménye egy munkaterületi leíró, amelyet más erőforrások és feladatok kezelésére fog használni.

Megjegyzés

  • A létrehozás MLClient nem fogja csatlakoztatni az ügyfelet a munkaterülethez. Az ügyfél inicializálása lusta, és az első alkalommal vár, amikor hívást kell kezdeményeznie. Ebben a cikkben ez a számítás létrehozása során fog megtörténni.

Számítási erőforrás létrehozása a feladat futtatásához

Az AzureML-nek számítási erőforrásra van szüksége egy feladat futtatásához. Ez az erőforrás lehet egy- vagy többcsomópontos gép Linux vagy Windows operációs rendszerrel, vagy egy adott számítási háló, például a Spark.

A következő példaszkriptben kiépítünk egy Linuxot compute cluster. Azure Machine Learning pricing A virtuálisgép-méretek és -árak teljes listáját megtalálja. Mivel ehhez a példához GPU-fürtre van szükségünk, válasszunk egy STANDARD_NC6 modellt, és hozzunk létre egy AzureML-számítást.

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

Feladatkörnyezet létrehozása

AzureML-feladat futtatásához környezetre lesz szüksége. Az AzureML-környezet magában foglalja a gépi tanulási betanítási szkript számítási erőforráson való futtatásához szükséges függőségeket (például a szoftveres futtatókörnyezetet és a kódtárakat). Ez a környezet hasonló a helyi gépen futó Python-környezethez.

Az AzureML lehetővé teszi, hogy válogatott (vagy kész) környezetet használjon, vagy egyéni környezetet hozzon létre Docker-rendszerkép vagy Conda-konfiguráció használatával. Ebben a cikkben újra felhasználja a válogatott AzureML-környezetet AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu. A környezet legújabb verzióját fogja használni az @latest irányelv használatával.

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

A betanítási feladat konfigurálása és elküldése

Ebben a szakaszban a betanításhoz szükséges adatok bemutatásával kezdjük. Ezután bemutatjuk, hogyan futtathat egy betanítási feladatot egy általunk megadott betanítási szkripttel. Megtudhatja, hogyan hozhatja létre a betanítási feladatot a betanítási szkript futtatására szolgáló parancs konfigurálásával. Ezután elküldi a betanítási feladatot az AzureML-ben való futtatáshoz.

A betanítási adatok beszerzése

A nyilvános blobokon tárolt adatokat zip-fájlként fogja használni. Ez az adatkészlet körülbelül 120 betanítási képből áll két osztályhoz (pulykákhoz és csirkékhez), és minden osztályhoz 100 érvényesítési rendszerkép tartozik. A képek az Open Images v5 adatkészlet részhalmazai. Az adatkészletet a betanítási szkript pytorch_train.pyrészeként töltjük le és nyerjük ki.

A betanítási szkript előkészítése

Ebben a cikkben a betanítási szkriptet pytorch_train.py. A gyakorlatban képesnek kell lennie bármilyen egyéni betanítási szkriptet az adott módon használni, és futtatni az AzureML-lel anélkül, hogy módosítania kellene a kódot.

A megadott betanítási szkript letölti az adatokat, betanít egy modellt, és regisztrálja a modellt.

A betanítási feladat létrehozása

Most, hogy rendelkezik a feladat futtatásához szükséges összes eszközzel, ideje az AzureML Python SDK v2 használatával felépíteni. Ebben a példában egy commandújat hozunk létre.

Az AzureML command egy erőforrás, amely megadja a betanítási kód felhőben való végrehajtásához szükséges összes részletet. Ezek a részletek tartalmazzák a bemeneteket és kimeneteket, a használandó hardver típusát, a telepítendő szoftvereket és a kód futtatásának módját. A command egyetlen parancs végrehajtásához szükséges információkat tartalmazza.

A parancs konfigurálása

Az általános célt command fogja használni a betanítási szkript futtatásához és a kívánt feladatok végrehajtásához. Hozzon létre egy objektumot Command a betanítási feladat konfigurációs részleteinek megadásához.

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",
)
  • A parancs bemenetei közé tartozik az alapidőszakok száma, a tanulási sebesség, a lendület és a kimeneti könyvtár.
  • A paraméterértékek esetében:
    • adja meg a parancs futtatásához létrehozott számítási fürtöt gpu_compute_target = "gpu-cluster" ;
    • adja meg a korábban inicializált válogatott környezetet AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu ;
    • konfigurálja magát a parancssori műveletet – ebben az esetben a parancs.python pytorch_train.py A parancs bemeneteit és kimeneteit a jelöléssel érheti ${{ ... }} el; és
    • konfigurálja a metaadatokat, például a megjelenítendő nevet és a kísérlet nevét; ahol a kísérlet egy adott projekt összes iterációjának tárolója. Az azonos kísérletnév alatt elküldött összes feladat megjelenik egymás mellett az AzureML Studióban.

Feladat küldése

Itt az ideje, hogy elküldje a feladatot az AzureML-ben való futtatáshoz. Ezúttal a következőt fogja használni create_or_update : ml_client.jobs.

ml_client.jobs.create_or_update(job)

Ha végzett, a feladat regisztrál egy modellt a munkaterületen (a betanítás eredményeként), és egy hivatkozást ad ki a feladat AzureML Studióban való megtekintéséhez.

Figyelmeztetés

Az Azure Machine Learning a teljes forráskönyvtár másolásával futtat betanítási szkripteket. Ha olyan bizalmas adatokkal rendelkezik, amelyeket nem szeretne feltölteni, használjon .ignore fájlt , vagy ne vegye fel azokat a forráskönyvtárba.

Mi történik a feladat végrehajtása során?

A feladat végrehajtása során a következő szakaszokon megy keresztül:

  • Előkészítés: A rendszer létrehoz egy Docker-rendszerképet a megadott környezetnek megfelelően. A rendszerképet a rendszer feltölti a munkaterület tárolóregisztrációs adatbázisára, és gyorsítótárazza a későbbi futtatásokhoz. A naplók a feladatelőzményekbe is streamelhetők, és megtekinthetők a folyamat nyomon követéséhez. Ha válogatott környezet van megadva, a rendszer az adott válogatott környezetet tartalmazó gyorsítótárazott rendszerképet fogja használni.

  • Skálázás: A fürt vertikális felskálázást kísérel meg, ha a futtatás végrehajtásához több csomópontra van szükség, mint amennyi jelenleg elérhető.

  • Futtatás: Az src szkriptmappa összes szkriptje fel lesz töltve a számítási célhoz, az adattárak csatlakoztatva vagy másolva lesznek, és a szkript végrehajtása történik. Az stdout és a ./logs mappa kimenetei a feladatelőzményekbe kerülnek, és a feladat figyelésére használhatók.

Modell hiperparamétereinek finomhangolása

A modellt egyetlen paraméterkészlettel képezte be, most pedig lássuk, hogy tovább javíthatja-e a modell pontosságát. A modell hiperparamétereit az Azure Machine Learning sweep képességeivel hangolhatja és optimalizálhatja.

A modell hiperparamétereinek finomhangolásához adja meg azt a paraméterterületet, amelyben a betanítás során keresni szeretne. Ehhez cserélje le a betanítási feladatnak átadott paraméterek egy részét a azure.ml.sweep csomagból származó speciális bemenetekre.

Mivel a betanítási szkript tanulási sebességütemezést használ a tanulási sebesség több alapidőszakban történő lebontásához, a kezdeti tanulási arányt és a lendület paramétereit is finomhangolhatja.

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

Ezután konfigurálja a takarítást a parancsfeladaton bizonyos takarítási paraméterekkel, például a figyelendő elsődleges metrikával és a használandó mintavételezési algoritmussal.

Az alábbi kódban véletlenszerű mintavételezést használunk a hiperparaméterek különböző konfigurációs készleteinek kipróbálására az elsődleges metrika( ) best_val_accmaximalizálása érdekében.

Meghatározunk egy korai leállítási szabályzatot is, a BanditPolicy-t, amely a rosszul teljesítő futtatások korai leállítására vonatkozik. A BanditPolicy leállítja azokat a futtatásokat, amelyek nem esnek bele az elsődleges kiértékelési metrika tartalékidő-tényezőjébe. Ezt a szabályzatot minden alapidőszakban alkalmazni fogja (mivel a metrikát minden alapidőszakban és evaluation_interval=1-ben jelentjükbest_val_acc). Figyelje meg, hogy az első szabályzat kiértékelését az első 10 alapidőszakig (delay_evaluation=10) késleltetjük.

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

Most már elküldheti ezt a feladatot a korábbiakhoz hasonlóan. Ezúttal egy takarítási feladatot fog futtatni, amely átsöpör a betanítási feladaton.

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)

A feladat monitorozásához használja a studio felhasználói felületének a feladatfuttatás során megjelenő hivatkozását.

A legjobb modell megkeresése

Miután az összes futtatás befejeződött, megtalálhatja azt a futtatást, amely a legnagyobb pontossággal hozta létre a modellt.

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

A modell üzembe helyezése online végpontként

Mostantól online végpontként is üzembe helyezheti a modellt, azaz webszolgáltatásként az Azure-felhőben.

Gépi tanulási szolgáltatás üzembe helyezéséhez általában a következőkre lesz szüksége:

  • Az üzembe helyezni kívánt modelleszközök. Ezek közé tartozik a modell fájlja és metaadatai, amelyeket már regisztrált a betanítási feladatban.
  • Szolgáltatásként futtatandó kód. A kód végrehajtja a modellt egy adott bemeneti kérésen (egy beviteli szkripten). Ez a bejegyzési szkript fogadja az üzembe helyezett webszolgáltatásnak elküldött adatokat, és továbbítja azokat a modellnek. Miután a modell feldolgozta az adatokat, a szkript visszaadja a modell válaszát az ügyfélnek. A szkript a modellre jellemző, és tisztában kell lennie a modell által várt és visszaadott adatokkal. MLFlow-modell használatakor az AzureML automatikusan létrehozza ezt a szkriptet.

További információ az üzembe helyezésről: Gépi tanulási modell üzembe helyezése és pontozása felügyelt online végponttal a Python SDK v2 használatával.

Új online végpont létrehozása

A modell üzembe helyezésének első lépéseként létre kell hoznia az online végpontot. A végpont nevének egyedinek kell lennie a teljes Azure-régióban. Ebben a cikkben egy univerzálisan egyedi azonosító (UUID) használatával fog egyedi nevet létrehozni.

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

Miután létrehozta a végpontot, a következőképpen kérdezheti le:

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

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

A modell üzembe helyezése a végponton

A végpont létrehozása után üzembe helyezheti a modellt a belépési szkripttel. Egy végpont több üzembe helyezéssel is rendelkezhet. A szabályok használatával a végpont ezután átirányíthatja a forgalmat ezekhez az üzemelő példányokhoz.

Az alábbi kódban egyetlen üzembe helyezést fog létrehozni, amely a bejövő forgalom 100%-át kezeli. Megadottunk egy tetszőleges színnevet (aci-blue) az üzembe helyezéshez. Az üzembe helyezéshez bármilyen más nevet is használhat, például aci-green vagy aci-red . A modell végponton való üzembe helyezéséhez szükséges kód a következőket teszi:

  • a korábban regisztrált modell legjobb verzióját helyezi üzembe;
  • pontszámot ad a modellnek a score.py fájl használatával; és
  • a (korábban megadott) válogatott környezetet használja a következtetés végrehajtásához.
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()

Megjegyzés

Az üzembe helyezés befejezéséhez várjon egy kis időt.

Az üzembe helyezett modell tesztelése

Most, hogy üzembe helyezte a modellt a végponton, előrejelezheti az üzembe helyezett modell kimenetét a invoke végpont metódusával.

A végpont teszteléséhez használjunk egy mintaképet az előrejelzéshez. Először jelenítsük meg a képet.

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

Hozzon létre egy függvényt a kép formázásához és átméretezéséhez.

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

Formázza a képet, és konvertálja JSON-fájllá.

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)

Ezután meghívhatja a végpontot ezzel a JSON-val, és kinyomtathatja az eredményt.

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

Az erőforrások eltávolítása

Ha nem használja a végpontot, törölje az erőforrás használatának leállításához. A törlés előtt győződjön meg arról, hogy más üzemelő példányok nem használják a végpontot.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Megjegyzés

Várjon egy kis időt a tisztítás befejezésére.

Következő lépések

Ebben a cikkben betanított és regisztrált egy mélytanulási neurális hálózatot a PyTorch használatával az Azure Machine Learningben. A modellt egy online végponton is üzembe helyezte. Az Azure Machine Learningről további információt az alábbi cikkekben talál.