PyTorch-modellek betanítása nagy méretekben az Azure Machine Learninggel

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

Ebben a cikkben megismerkedhet egy PyTorch-modell betanítása, hiperparaméter-finomhangolása és üzembe helyezése az Azure Machine Tanulás Python SDK v2 használatával.

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. A tanulás átadása olyan technika, amely az egyik probléma megoldásából nyert tudást egy másik, de kapcsolódó problémára alkalmazza. A tanulás átvitele 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. A transzfertanulásról további információt a mély tanulás és a gépi tanulás című témakörben talál.

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

Előfeltételek

• Azure-előfizetés. Ha még nem rendelkezik ilyen fiókkal, hozzon létre egy ingyenes fiókot.
• Futtassa a jelen cikkben szereplő kódot egy Azure Machine Tanulás számítási példány vagy egy saját Jupyter-jegyzetfüzet használatával.
  • Azure Machine Tanulás számítási példány – nincs szükség letöltésre vagy telepítésre:
    • Végezze el a rövid útmutatót: Ismerkedés az Azure Machine Tanulás az SDK-val és a mintaadattárral előre betöltött dedikált jegyzetfüzet-kiszolgáló létrehozásához.
    • A munkaterület Jegyzetfüzetek szakaszÁnak Minták lapján keressen egy befejezett és kibontott jegyzetfüzetet a következő könyvtárra navigálva: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Az Ön Jupyter notebook-kiszolgálója:
    • Telepítse az Azure Machine Tanulás SDK-t (v2).
    • Töltse le a betanítási szkriptfájlt pytorch_train.py.

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

Ahhoz, hogy a cikkben szereplő kód futtatásával GPU-fürtöt hozzon létre, 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, a munkaterülethez való csatlakozással, egy számítási erőforrás létrehozásával egy parancsfeladat futtatásához, valamint a feladat futtatásához szükséges környezet létrehozásával.

Csatlakozás a munkaterületre

Először csatlakoznia kell az Azure Machine Tanulás-munkaterülethez. A munkaterület a szolgáltatás legfelső szintű erőforrása. Központosított helyet biztosít az Azure Machine Tanulás használatakor létrehozott összes összetevővel való munkához.

A munkaterülethez való hozzáférést használjuk DefaultAzureCredential . 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 az azure.identity csomagot , vagy állítsa be a hitelesítést az elérhetőbb hitelesítő adatokért.

# 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ódot, é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 szerezze be 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 paraméterek megkeresése:

1. Keresse meg a munkaterület nevét az Azure Machine Tanulás studio eszköztárának 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ójának é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ó, amellyel más erőforrásokat és feladatokat kezelhet.

Feljegyzés

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

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

Az Azure Machine Tanulás 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.

Az alábbi példaszkriptben kiépítünk egy Linux számítási fürtöt. Az Azure Machine Tanulás díjszabási oldalán megtekintheti a virtuális gépek méreteinek és árainak teljes listáját. Mivel ehhez a példához GPU-fürtre van szükségünk, válasszunk ki egy STANDARD_NC6 modellt, és hozzunk létre egy Azure Machine-Tanulás számítást.

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

Feladatkörnyezet létrehozása

Azure Machine-Tanulás feladat futtatásához környezetre van szükség. Az Azure Machine Tanulás környezet magában foglalja a számítógép-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 szoftveres futtatókörnyezetet és kódtárakat). Ez a környezet hasonló a helyi gépen lévő Python-környezethez.

Az Azure Machine Tanulás 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 Azure Machine Tanulás környezetetAzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu. Használja a környezet legújabb verzióját 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 bevezetésével kezdjük. Ezután bemutatjuk, hogyan futtathat egy betanítási feladatot egy általunk biztosított betanítási szkripttel. A betanítási feladat összeállításához konfigurálja a betanítási szkript futtatására szolgáló parancsot. Ezután elküldi a betanítási feladatot az Azure Machine Tanulás futtatásához.

A betanítási adatok beszerzése

Ebben a tömörített fájlban használhatja az adathalmazt. 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 kép tartozik. A képek az Open Images v5 Dataset részhalmazai. A betanítási szkript pytorch_train.py letölti és kinyeri az adathalmazt.

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

Az előfeltételek szakaszban a betanítási szkriptet pytorch_train.py. A gyakorlatban bármilyen egyéni betanítási szkriptet használhat, és futtathatja az Azure Machine Tanulás 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 Azure Machine Tanulás Python SDK v2 használatával létrehozni. Ebben a példában létrehozunk egy command.

Az Azure Machine Tanulás command olyan 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íteni kívánt szoftvereket és a kód futtatásának módját. A command parancsok 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 elvégzéséhez. Hozzon létre egy objektumot command a betanítási feladat konfigurációs adatainak 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_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",
)

• 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:
  1. Adja meg a parancs futtatásához létrehozott számítási fürtöt gpu_compute_target = "gpu-cluster" .
  2. Adja meg a korábban inicializált válogatott környezetet AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu .
  3. Ha nem a Minták mappában használja a kész jegyzetfüzetet, adja meg a pytorch_train.py fájl helyét.
  4. Konfigurálja magát a parancssori műveletet – ebben az esetben a parancs a következő python pytorch_train.py. A parancs bemeneteit és kimeneteit a jelölésen keresztül érheti ${{ ... }} el.
  5. Konfigurálja a metaadatokat, például a megjelenítendő nevet és a kísérlet nevét, ahol a kísérlet egy tároló az adott projekten végzett összes iterációhoz. Az ugyanazon kísérletnév alatt elküldött összes feladat egymás mellett szerepelne az Azure Machine Tanulás Studióban.

Feladat küldése

Itt az ideje, hogy elküldje a feladatot az Azure Machine Tanulás futtatásához. Ezúttal a következőt használja create_or_update : ml_client.jobs.

ml_client.jobs.create_or_update(job)

Miután 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 megtekintéséhez az Azure Machine Tanulás Studióban.

Figyelmeztetés

Az Azure Machine Tanulás a teljes forráskönyvtár másolásával futtatja a 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 figyeléséhez. Ha egy válogatott környezet van megadva, a rendszer a gyorsítótárazott rendszerkép-háttérrendszert használja a válogatott környezethez.

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

• Futtatás: A szkriptmappa src összes szkriptje fel lesz töltve a számítási célba, az adattárak csatlakoztatva vannak vagy másolódnak, és a szkript végrehajtása megtö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 egy paraméterkészlettel képezte be, most lássuk, hogy tovább javíthatja-e a modell pontosságát. Az Azure Machine Tanulás képességeivel hangolhatja és optimalizálhatja a modell hiperparamétereitsweep.

A modell hiperparamétereinek finomhangolásához adja meg azt a paraméterteret, 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 a tanulási sebesség ütemezését használja a tanulási sebesség több korszakban történő romlásához, beállíthatja a kezdeti tanulási arányt és a lendület paramétereit.

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álhatja a takarítást a parancsfeladaton bizonyos, takarítással kapcsolatos 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, hogy maximalizáljuk az elsődleges metrikát. best_val_acc

Meghatározunk egy korai felmondási szabályzatot is, a BanditPolicyhelytelenül teljesítő futtatások korai leállításához. A BanditPolicy rendszer leállítja azokat a futtatásokat, amelyek nem tartoznak az elsődleges kiértékelési metrika tartalékidő-tényezőjébe. Ezt a szabályzatot minden korszakban alkalmazza (mivel a metrikát minden korszakban és evaluation_interval=1-ben jelentjükbest_val_acc). Figyelje meg, hogy az első szabályzat kiértékelését az első 10 korszak után (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 a korábbiakhoz hasonlóan küldheti el ezt a feladatot. Ezúttal egy takarítási feladatot futtat, amely átsöpri a vonatfeladatát.

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 feladat futtatása során megjelenő studio felhasználói felületi hivatkozást.

A legjobb modell megkeresése

Miután az összes futtatás befejeződött, megtalálhatja a modellt a legnagyobb pontossággal előállító futtatásokat.

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, vagyis 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 van szüksége:

• Az üzembe helyezni kívánt modellegységek. Ezek az eszközök tartalmazzák a modell azon fájlját és metaadatait, amelyeket már regisztrált a betanítási feladatban.
• Néhány szolgáltatásként futtatandó kód. A kód egy adott bemeneti kérésen (belépési szkripten) hajtja végre a modellt. Ez a bejegyzésszkript fogadja az üzembe helyezett webszolgáltatásnak kü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 ismernie kell a modell által várt és visszaadott adatokat. MLFlow-modell használatakor az Azure Machine Tanulás automatikusan létrehozza ezt a szkriptet.

További információ az üzembe helyezésről: Gépi tanulási modell üzembe helyezése és pontszáma felügyelt online végponttal 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 hoz létre egyedi nevet.

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

A végpont létrehozása után az alábbiak szerint 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

Most már ü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 ezekre az üzemelő példányokra.

Az alábbi kódban egyetlen üzembe helyezést fog létrehozni, amely a bejövő forgalom 100%-át kezeli. Tetszőleges aci-kék színnevet adtunk meg az üzembe helyezéshez. Az üzembe helyezéshez bármilyen más nevet is használhat, például aci-zöld vagy aci-piros nevet.

A modell végponton való üzembe helyezéséhez szükséges kód:

• A korábban regisztrált modell legjobb verzióját helyezi üzembe.
• A modell pontszáma a score.py fájl használatával.
• 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()

Feljegyzés

Az üzembe helyezés várhatóan egy kis időt vesz igénybe.

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égponton található metódus használatá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 már nincs szüksége a végpontra, 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)

Feljegyzés

Várjon egy kis időt a törlé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 Tanulás. A modellt egy online végponton is üzembe helyezte. Az Azure Machine Tanulás további információért tekintse meg ezeket a cikkeket.

• Futtatási metrikák nyomon követése a betanítás során
• Hiperparaméterek hangolása
• Referenciaarchitektúra elosztott mélytanulási képzéshez az Azure-ban