Megosztás a következőn keresztül:

Modellbetanítás kiszolgáló nélküli számításon

  • Cikk

ÉRVÉNYES:Azure CLI ml-bővítmény v2 (aktuális)Python SDK azure-ai-ml v2 (aktuális)

A modell skálázható betanítása érdekében már nem kell számítási feladatokat létrehoznia és kezelnie. A feladat ehelyett elküldhető egy új számítási céltípusra, az úgynevezett kiszolgáló nélküli számításra. A kiszolgáló nélküli számítás a legegyszerűbb módja a betanítási feladatok futtatásának az Azure Machine Learningben. A kiszolgáló nélküli számítás egy teljes mértékben felügyelt, igény szerinti számítás. Az Azure Machine Learning létrehozza, skálázza és kezeli a számítást. A kiszolgáló nélküli számításokkal végzett modellbetanítás révén a gépi tanulási szakemberek a gépi tanulási modellek készítésével kapcsolatos szakértelmükre összpontosíthatnak, és nem kell megismerkedniük a számítási infrastruktúrával vagy annak beállításával.

A gépi tanulási szakemberek meg tudják határozni a feladathoz szükséges erőforrásokat. Az Azure Machine Learning felügyeli a számítási infrastruktúrát, és kezelt hálózati elkülönítés csökkenti a terhelést.

A vállalatok az egyes feladatokhoz tartozó optimális erőforrások megadásával csökkenthetik a költségeket. Az informatikai rendszergazdák továbbra is alkalmazhatják az irányítást a magok előfizetési és munkaterületi szintű kvótáinak megadásával és az Azure-szabályzatok alkalmazásával.

A kiszolgáló nélküli számítás segítségével finomhangolhatók a modellkatalógusban szereplő modellek, például a LLAMA 2. A kiszolgáló nélküli számítás az Azure Machine Learning Studióból, az SDK-ból és a PARANCSSOR-ból minden típusú feladat futtatására használható. A kiszolgáló nélküli számítás környezeti rendszerképek készítéséhez és felelős AI-irányítópult-forgatókönyvekhez is használható. A kiszolgáló nélküli feladatok ugyanazt a kvótát használják fel, mint az Azure Machine Learning számítási kvótáját. Választhat standard (dedikált) szintet vagy kihasználatlan (alacsony prioritású) virtuális gépeket. A felügyelt identitás és a felhasználói identitás kiszolgáló nélküli feladatok esetén támogatott. A számlázási modell megegyezik az Azure Machine Learning számítási modellel.

A kiszolgáló nélküli számítás előnyei

  • Az Azure Machine Learning felügyeli a felügyeleti többletterhelést csökkentő létrehozást, beállítást, skálázást, törlést, javítást és számítási infrastruktúrát
  • Nem kell megismerkednie a számítással, a különböző számítási típusokkal és a kapcsolódó tulajdonságokkal.
  • Nincs szükség fürtök ismételt létrehozására minden szükséges virtuálisgép-mérethez ugyanazokkal a beállításokkal és az egyes munkaterületek replikálásával.
  • A költségeket úgy optimalizálhatja, hogy pontosan megadja azokat az erőforrásokat, amelyekre az egyes feladatoknak futásidőben szükségük van a példánytípus (virtuális gép mérete) és a példányok száma alapján. A feladat kihasználtsági metrikáit figyelve optimalizálhatja azokat az erőforrásokat, amelyekre a feladatnak szüksége lenne.
  • A feladat futtatásához szükséges lépések csökkentése
  • A feladatok elküldésének további egyszerűsítése érdekében kihagyhatja az erőforrásokat. Az Azure Machine Learning alapértelmezés szerint a példányok számát adja meg, és egy példánytípust (virtuálisgép-méretet) választ ki olyan tényezők alapján, mint a kvóta, a költség, a teljesítmény és a lemezméret.
  • Kisebb várakozási idő, mielőtt a feladatok bizonyos esetekben megkezdődnek.
  • A feladatküldéshez a felhasználói identitás és a munkaterület felhasználó által hozzárendelt felügyelt identitása támogatott.
  • A kezelt hálózati elkülönítés leegyszerűsítheti és automatizálhatja a hálózatelkülönítési konfigurációt. Az ügyfél virtuális hálózata is támogatott
  • Rendszergazdai vezérlés kvóta és Azure-szabályzatok segítségével

Kiszolgáló nélküli számítás használata

  • Az alapmodelleket, például a LLAMA 2-t a jegyzetfüzetek használatával finomíthatja az alábbiak szerint:

  • Amikor saját számítási fürtöt hoz létre, a parancsfeladatban a nevét használja, például compute="cpu-cluster". Kiszolgáló nélküli esetén kihagyhatja a számítási fürt létrehozását, és kihagyhatja a paramétert a compute kiszolgáló nélküli számítás használatához. Ha compute nincs megadva feladathoz, a feladat kiszolgáló nélküli számításon fut. Hagyja ki a parancssori felület vagy az SDK-feladatok számítási nevét, hogy kiszolgáló nélküli számítást használjon a következő feladattípusokban, és opcionálisan olyan erőforrásokat adjon meg, amelyekre a feladatnak szüksége lenne a példányszám és a példánytípus szempontjából:

    • Parancsfeladatok, beleértve az interaktív feladatokat és az elosztott betanítást
    • AutoML-feladatok
    • Takarítási feladatok
    • Párhuzamos feladatok

  • Folyamatfeladatok parancssori felületről történő használata default_compute: azureml:serverless a folyamatszintű alapértelmezett számításhoz. Folyamatfeladatok SDK-val történő használata default_compute="serverless"esetén. Példa: Folyamatfeladat .

  • Amikor beküld egy betanítási feladatot a studióban (előzetes verzió), válassza a Kiszolgáló nélküli lehetőséget számítási típusként.

  • Az Azure Machine Learning Designer használatakor válassza a Kiszolgáló nélküli beállítást alapértelmezett számításként.

  • Kiszolgáló nélküli számítást használhat a felelős AI-irányítópulthoz

A teljesítménnyel kapcsolatos megfontolások

A kiszolgáló nélküli számítás a következő módokon segíthet a betanítás felgyorsításában:

Nincs elegendő kvóta: Ha saját számítási fürtöt hoz létre, önnek kell kitalálnia, hogy milyen virtuálisgép-méretet és csomópontszámot kell létrehoznia. Ha a feladat fut, ha nem rendelkezik elegendő kvótával a fürthöz, a feladat meghiúsul. A kiszolgáló nélküli számítás alapértelmezés szerint a kvótával kapcsolatos információkat használja a megfelelő virtuálisgép-méret kiválasztásához.

Vertikális leskálázás optimalizálása: Amikor egy számítási fürt leskálázódik, egy új feladatnak várnia kell a leskálázásra, majd fel kell skáláznia, mielőtt a feladat lefuthat. A kiszolgáló nélküli számítással nem kell megvárnia a leskálázást, és a feladat egy másik fürtön/csomóponton is elindulhat (feltéve, hogy kvótával rendelkezik).

Fürt foglalt optimalizálása: ha egy feladat egy számítási fürtön fut, és egy másik feladatot küld el, a feladat várólistára kerül az aktuálisan futó feladat mögött. A kiszolgáló nélküli számítással egy másik csomópontot vagy egy másik fürtöt kap a feladat futtatásához (feltéve, hogy kvótával rendelkezik).

Kvóta

A feladat elküldésekor továbbra is elegendő Azure Machine Learning számítási kvótára van szüksége a folytatáshoz (munkaterületi és előfizetési szintű kvótára is). A kiszolgáló nélküli feladatok alapértelmezett virtuálisgép-mérete a kvóta alapján van kiválasztva. Ha saját virtuálisgép-méretet/-családot ad meg:

  • Ha rendelkezik némi kvótával a virtuális gép méretéhez/családjához, de a példányok számára nem elegendő kvótával rendelkezik, hibaüzenet jelenik meg. A hiba azt javasolja, hogy a példányok számát a kvótakorlát alapján érvényes számra csökkentsük, vagy kérje a virtuálisgép-család kvótanövelését vagy a virtuális gép méretének módosítását
  • Ha nem rendelkezik kvótával a megadott virtuálisgép-mérethez, hibaüzenet jelenik meg. A hiba azt javasolja, hogy válasszon egy másik virtuálisgép-méretet, amelyhez kvótát vagy kvótát igényel ehhez a virtuálisgép-családhoz
  • Ha elegendő kvótával rendelkezik ahhoz, hogy a virtuálisgép-család futtathassa a kiszolgáló nélküli feladatot, de más feladatok is használják a kvótát, egy üzenetben megjelenik, hogy a feladatnak várakozási sorban kell állnia, amíg a kvóta el nem érhető

Amikor megtekinti a használatot és a kvótát az Azure Portalon, a "Kiszolgáló nélküli" név jelenik meg a kiszolgáló nélküli feladatok által felhasznált összes kvóta megtekintéséhez.

Identitástámogatás és hitelesítő adatok átadása

  • Felhasználói hitelesítő adatok továbbítása : A kiszolgáló nélküli számítás teljes mértékben támogatja a felhasználói hitelesítő adatok átadását. A feladatot beküldő felhasználó felhasználói jogkivonata tárolóhozzáféréshez használatos. Ezek a hitelesítő adatok a Microsoft Entra-azonosítóból származnak.

    from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

  • Felhasználó által hozzárendelt felügyelt identitás: Ha a munkaterület felhasználó által hozzárendelt felügyelt identitással van konfigurálva, ezt az identitást használhatja a kiszolgáló nélküli feladattal a tárterület-hozzáféréshez. A titkos kódok eléréséhez lásd : Hitelesítési hitelesítő adatok titkos kulcsának használata az Azure Machine Learning-feladatokban.

    from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import ManagedIdentityConfiguration

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
        identity= ManagedIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

A felhasználó által hozzárendelt felügyelt identitás csatolásával kapcsolatos információkért tekintse meg a felhasználó által hozzárendelt felügyelt identitás csatolását ismertető témakört.

Parancsfeladatok tulajdonságainak konfigurálása

Ha nincs megadva számítási cél a parancs-, takarítási és AutoML-feladatokhoz, akkor a számítás alapértelmezés szerint kiszolgáló nélküli számítás lesz. Ehhez a parancsfeladathoz például:

from azure.ai.ml import command
from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
)
# submit the command job
ml_client.create_or_update(job)

A számítás alapértelmezés szerint kiszolgáló nélküli számításra a következőkkel történik:

  • Ehhez a feladathoz egyetlen csomópontot kell kijelölni. A csomópontok alapértelmezett száma a feladat típusától függ. A többi feladattípust a következő szakaszokban találja.
  • CPU virtuális gép, amely a kvóta, a teljesítmény, a költség és a lemez mérete alapján van meghatározva.
  • Dedikált virtuális gépek
  • Munkaterület helye

Ezeket az alapértelmezett értékeket felülbírálhatja. Ha meg szeretné adni a virtuális gép típusát vagy a kiszolgáló nélküli számítás csomópontjainak számát, adja hozzá resources a feladathoz:

  • instance_type egy adott virtuális gép kiválasztásához. Ezt a paramétert akkor használja, ha egy adott CPU-/GPU-virtuálisgép-méretet szeretne

  • instance_count csomópontok számának megadásához.

    from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package
from azure.ai.ml.entities import JobResourceConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    resources = JobResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
)
# submit the command job
ml_client.create_or_update(job)

  • A feladatszint módosításához válassza queue_settings ki a dedikált virtuális gépeket (job_tier: Standard) és az alacsony prioritású() elemetjobtier: Spot.

    from azure.ai.ml import command
from azure.ai.ml import MLClient    # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    queue_settings={
      "job_tier": "spot"  
    }
)
# submit the command job
ml_client.create_or_update(job)

Példa a parancsfeladatokkal rendelkező összes mezőre

Íme egy példa az összes megadott mezőre, beleértve az identitást, amelyet a feladatnak használnia kell. Nincs szükség virtuális hálózati beállítások megadására, mivel a munkaterületi szint kezelt hálózati elkülönítés automatikusan használatban van.

from azure.ai.ml import command
from azure.ai.ml import MLClient      # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
         identity=UserIdentityConfiguration(),
    queue_settings={
      "job_tier": "Standard"  
    }
)
job.resources = ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=1)
# submit the command job
ml_client.create_or_update(job)

További példák a kiszolgáló nélküli számítással való betanításra: -

AutoML-feladat

Az AutoML-feladatok számítási feladatainak megadása nem szükséges. Az erőforrások opcionálisan megadhatóak. Ha a példányok száma nincs megadva, akkor az alapértelmezés szerint max_concurrent_trials és max_nodes paraméterek alapján történik. Ha autoML-rendszerkép-besorolást vagy NLP-feladatot küld el példánytípus nélkül, a rendszer automatikusan kiválasztja a GPU-beli virtuális gép méretét. Az AutoML-feladatot cli-eken, SDK-kkal vagy Studióval is elküldheti. Az AutoML-feladatok kiszolgáló nélküli számítással való elküldéséhez először engedélyezze a betanítási feladatot a studio (előzetes verzió) szolgáltatásban az előnézeti panelen.

Ha meg szeretné adni a típust vagy a példányszámot, használja az osztályt ResourceConfiguration .

# Create the AutoML classification job with the related factory-function.
from azure.ai.ml.entities import ResourceConfiguration 

classification_job = automl.classification(
    experiment_name=exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"},
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600,
    trial_timeout_minutes=20,
    max_trials=max_trials,
    # max_concurrent_trials = 4,
    # max_cores_per_trial: -1,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=[ClassificationModels.LOGISTIC_REGRESSION],
    enable_onnx_compatible_models=True,
)

# Serverless compute resources used to run the job
classification_job.resources = 
ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=6)

Folyamatfeladat

Folyamatfeladat esetén adja meg "serverless" alapértelmezett számítási típusként a kiszolgáló nélküli számítás használatát.

# Construct pipeline
@pipeline()
def pipeline_with_components_from_yaml(
    training_input,
    test_input,
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
):
    """E2E dummy train-score-eval pipeline with components defined via yaml."""
    # Call component obj as function: apply given inputs & parameters to create a node in pipeline
    train_with_sample_data = train_model(
        training_data=training_input,
        max_epochs=training_max_epochs,
        learning_rate=training_learning_rate,
        learning_rate_schedule=learning_rate_schedule,
    )

    score_with_sample_data = score_data(
        model_input=train_with_sample_data.outputs.model_output, test_data=test_input
    )
    score_with_sample_data.outputs.score_output.mode = "upload"

    eval_with_sample_data = eval_model(
        scoring_result=score_with_sample_data.outputs.score_output
    )

    # Return: pipeline outputs
    return {
        "trained_model": train_with_sample_data.outputs.model_output,
        "scored_data": score_with_sample_data.outputs.score_output,
        "evaluation_report": eval_with_sample_data.outputs.eval_output,
    }


pipeline_job = pipeline_with_components_from_yaml(
    training_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    test_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
)

# set pipeline to use serverless compute
pipeline_job.settings.default_compute = "serverless"

A kiszolgáló nélküli számítást is beállíthatja alapértelmezett számításként a Tervezőben.

Következő lépések

További példák a kiszolgáló nélküli számítással való betanításra: -