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

É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 nem kell számításokat létrehoznia és kezelnie . Ehelyett elküldheti a feladatot egy kiszolgáló nélküli számításnak nevezett számítási céltípusnak. 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. Amikor kiszolgáló nélküli számítással tanít be modelleket, a gépi tanulási modellek létrehozására összpontosíthat, és nem kell megismerkednie a számítási infrastruktúrával vagy annak beállításával.

Megadhatja a feladathoz szükséges erőforrásokat. Az Azure Machine Learning felügyeli a számítási infrastruktúrát, és felügyelt hálózatelkülönítést biztosít, csökkentve az Önre nehezedő terheket.

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 az alapkvóta előfizetési és munkaterületi szinten történő megadásával, valamint az Azure-szabályzatok alkalmazásával.

A kiszolgáló nélküli számítás használatával finomhangolhatja a modelleket a modellkatalógusban. Az Azure Machine Learning Studióval, a Python SDK-val és az Azure CLI-vel bármilyen típusú feladatot futtathat. A kiszolgáló nélküli számítással környezeti rendszerképeket és felelős AI-irányítópult-forgatókönyveket is létrehozhat. 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) vagy spot (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 ugyanaz, mint az Azure Machine Learning számítási modellje.

Előfeltételek

• Egy Azure-előfizetés. Ha még nincs előfizetése, hozzon létre egy ingyenes fiókot.

• Egy Azure Machine Learning-munkaterület.

• A bővítményt tartalmazó ml Azure CLI vagy az Azure Machine Learning Python SDK v2:

  Python

  pip install azure-ai-ml azure-identity
  

  Azure CLI

  az extension add --name ml
  

---

• Szerepkörkövetelmények: A feladatok elküldéséhez legalább közreműködői vagy Azure ML-adatelemzői szerepkörre van szüksége a munkaterületen.

Az első kiszolgáló nélküli feladat elküldése

Az alábbi példa egy kiszolgáló nélküli számításon futó minimális parancsfeladatot mutat be. Amikor kihagyja a paramétert compute , a feladat automatikusan kiszolgáló nélküli számítást használ.

Python

from azure.ai.ml import command, MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Initialize the ML client
try:
    credential = DefaultAzureCredential()
    credential.get_token("https://management.azure.com/.default")
except Exception:
    credential = InteractiveBrowserCredential()
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure-subscription-ID>",
    resource_group_name="<Azure-resource-group>",
    workspace_name="<Azure-Machine-Learning-workspace>",
)

# Create a simple command job - omitting 'compute' uses serverless
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
)

# Submit the job
returned_job = ml_client.create_or_update(job)
print(f"Job submitted: {returned_job.name}")

Azure CLI

Hozzon létre egy fájlt:hello-serverless.yaml

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest

Küldje el a feladatot:

az ml job create --file hello-serverless.yaml --resource-group <resource-group> --workspace-name <workspace>

Várt kimenet: A feladat létrejön, és visszatér egy munka objektummal, amely állapotot tartalmaz NotStarted vagy Starting. Monitorozza a folyamatot az Azure ML Studióban vagy a hívással ml_client.jobs.get(returned_job.name).

Hivatkozás:parancsfüggvény | MLClient

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

• Az Azure Machine Learning felügyeli a számítási infrastruktúra létrehozását, beállítását, méretezését, törlését és javítását a felügyeleti többletterhelés csökkentése érdekében.
• Nem kell többet megtudnia a számításról, a különböző számítási típusokról vagy a kapcsolódó tulajdonságokról.
• Nem kell ismétlődően fürtöket létrehoznia minden szükséges virtuálisgép-mérethez, ugyanazokat a beállításokat használva és replikálva az egyes munkaterületekhez.
• A költségeket úgy optimalizálhatja, hogy megadja az egyes feladatokhoz szükséges erőforrásokat a futtatókörnyezetben a példánytípus (virtuálisgép-méret) és a példányszám szempontjából. A feladat kihasználtsági metrikáit is figyelheti a feladathoz szükséges erőforrások optimalizálása érdekében.
• A feladatok futtatásához kevesebb lépésre van szükség.
• A feladatok beküldését még egyszerűbbé teheti az erőforrások mellőzésével. Az Azure Machine Learning alapértelmezés szerint a példányok számát adja meg, és olyan tényezők figyelembevételével választja ki a példánytípust, mint a kvóta, a költség, a teljesítmény és a lemezméret.
• Bizonyos esetekben a feladatok futásának megkezdése előtt a várakozási idő csökken.
• A feladatbeküldéshez támogatott a felhasználói identitás és a munkaterülethez felhasználók által hozzárendelt felügyelt identitás.
• 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ózatai is támogatottak.
• A felügyeleti vezérlés kvóta- és Azure-szabályzatokkal érhető el.

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

• Amikor létrehoz egy saját számítási fürtöt, annak nevét a parancsfeladatban fogja használni. Például: compute="cpu-cluster". A kiszolgáló nélküli megoldás használatával kihagyhatja a számítási fürt létrehozását, és mellőzheti a compute paramétert, hogy helyette kiszolgáló nélküli számítást használjon. Ha compute nincs megadva feladathoz, a feladat kiszolgáló nélküli számításon fut. Hagyja ki a számítási nevet az Azure CLI- vagy Python SDK-feladatokban, hogy kiszolgáló nélküli számítást használjon a következő feladattípusokban, és opcionálisan adja meg a feladathoz szükséges erőforrásokat a példányszámhoz és a példánytípushoz:

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

• Az Azure CLI-vel végzett folyamatfeladatok esetében használja default_compute: azureml:serverless a folyamatszintű alapértelmezett számításhoz. A Python SDK-val végzett folyamatfeladatokhoz használja a következőt default_compute="serverless": . Az alábbiakban a Pipeline feladat példa.

• Amikor elküld egy betanítási feladatot a studióban, 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 lehetőséget alapértelmezett számításként.

A teljesítménnyel kapcsolatos megfontolások

A kiszolgáló nélküli számítás a következő módokon növelheti a betanítás sebességét:

Kerülje az elégtelen kvótahibákat. Saját számítási fürt létrehozásakor Ön határozza meg a virtuális gép méretét és a csomópontok számát. 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 leépül, egy új feladatnak meg kell várnia, amíg a fürt teljesen le- és visszaépül, mielőtt a feladat lefuthat. Kiszolgáló nélküli számítás esetén nem kell megvárnia a leskálázást. A feladat elkezdhet futni egy másik fürtön/csomóponton (feltéve, hogy rendelkezik kvótával).

Fürt foglalt optimalizálása. Amikor egy feladat egy számítási fürtön fut, és egy másik feladat beküldésre kerül, az Ön feladata várólistára kerül az éppen futó feladat mögött. Kiszolgáló nélküli számítással a feladat egy másik csomóponton/fürtön is elindulhat (feltéve, hogy rendelkezik kvótával).

Kvóta

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ületszintű é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 nem rendelkezik elegendő kvótával a példányok számához, hibaüzenet jelenik meg. A hiba azt javasolja, hogy a kvótakorlát alapján csökkentse a példányok számát érvényes számra, kérje a virtuálisgép-család kvótanövelését, vagy módosítsa a virtuális gép méreté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 van kvótája, vagy kérjen kvótát a virtuálisgép-családhoz.
• Ha rendelkezik elegendő kvótával ahhoz, hogy egy virtuálisgép-család futtassa a kiszolgáló nélküli feladatot, de más feladatok használják a kvótát, egy üzenetben közli, hogy a feladatnak várakozási sorban kell állnia, amíg a kvóta elérhetővé válik.

Amikor megtekinti a használatot és a kvótákat az Azure Portalon, a kiszolgáló nélküli feladatok által felhasznált összes kvóta kiszolgáló nélküli nevét látja.

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

A kiszolgáló nélküli számítás két identitáslehetőséget támogat a tárterület és más erőforrások eléréséhez:

• Felhasználói hitelesítő adatok átadása: A Microsoft Entra ID tokent használja. Legjobb interaktív fejlesztéshez és teszteléshez.
• Felhasználó által hozzárendelt felügyelt identitás: A munkaterület felügyelt identitását használja. Éles forgatókönyvekhez és automatizáláshoz a legjobb.

• Felhasználói hitelesítő adatok átadá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 rendszer a feladatot beküldő felhasználó felhasználói jogkivonatát használja a tárhoz való hozzáféréshez. Ezek a hitelesítő adatok a Microsoft Entra-azonosítóból származnak.

  A kiszolgáló nélküli számítás nem támogatja a rendszer által hozzárendelt identitást.

  Python

  from azure.ai.ml import command
  from azure.ai.ml import MLClient     # Handle to the workspace.
  from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential     # Authentication package.
  from azure.ai.ml.entities import UserIdentityConfiguration 
  
  try:
      credential = DefaultAzureCredential()
      credential.get_token("https://management.azure.com/.default")
  except Exception:
      credential = InteractiveBrowserCredential()
  # 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)
  

  Azure CLI

  Hozzon létre egy hello.yaml nevű fájlt, amely a következőket tartalmazza:

  $schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
  command: echo "hello world"
  environment:
    image: library/python:latest
  identity:
    type: user_identity
  

  Küldje el a feladatot a következő paranccsal:

  az ml job create --file hello.yaml --resource-group my-resource-group --workspace-name my-workspace
  

  A többi Azure CLI-példa a hello.yaml fájl variációit mutatja. Futtassa mindegyiket ugyanúgy.

  Hivatkozás:UserIdentityConfiguration | parancsfüggvény

• 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éről további információt a hitelesítési hitelesítő adatok titkos kulcsainak használata az Azure Machine Learning-feladatokban című témakörben talál.

1. Ellenőrizze a munkaterület identitáskonfigurációját.

   Python

   from azure.ai.ml import MLClient
   from azure.identity import DefaultAzureCredential
   
   subscription_id = "<your-subscription-id>"
   resource_group = "<your-resource-group>"
   workspace = "<your-workspace-name>"
   
   ml_client = MLClient(
       DefaultAzureCredential(),
       subscription_id,
       resource_group,
       workspace
   )
   
   # Get workspace details.
   ws = ml_client.workspaces.get(name=workspace)
   print(ws)
   
   

   Azure CLI

   az ml workspace show --name <workspace-sname>  --resource-group <resource-group-name>
   

   Keresse meg a felhasználó által hozzárendelt identitást a kimenetben. Ha hiányzik, hozzon létre egy új munkaterületet egy felhasználó által hozzárendelt felügyelt identitással az Azure Machine Learning és más szolgáltatások közötti hitelesítés beállítása című témakör utasításait követve.

2. Használja a felhasználóhoz rendelt felügyelt identitást a munkájában.

   Python

   from azure.ai.ml import command
   from azure.ai.ml import MLClient     # Handle to the workspace.
   from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential    # Authentication package.
   from azure.ai.ml.entities import ManagedIdentityConfiguration
   
   try:
       credential = DefaultAzureCredential()
       credential.get_token("https://management.azure.com/.default")
   except Exception:
       credential = InteractiveBrowserCredential()
   # 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(client_id="<workspace-UAMI-client-ID>"),
   )
   # Submit the command job.
   ml_client.create_or_update(job)
   

   Azure CLI

   $schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
   command: echo "hello world"
   environment:
     image: library/python:latest
   identity:
     type: managed
   

Referencia:ManagedIdentityConfiguration

Parancsfeladatok tulajdonságainak konfigurálása

Ha nincs megadva számítási cél a parancs-, takarítási és AutoML-feladatokhoz, a számítás alapértelmezés szerint kiszolgáló nélküli számítás lesz. Íme egy példa:

Python

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

try:
    credential = DefaultAzureCredential()
    credential.get_token("https://management.azure.com/.default")
except Exception:
    credential = InteractiveBrowserCredential()
# 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)

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest

A számítás alapértelmezetten kiszolgáló nélküli számítást használ.

• Ehhez a feladathoz egyetlen csomópont. 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. A virtuális gép meghatározása a kvóta, a teljesítmény, a költség és a lemezméret alapján történik.
• 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:

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

• A csomópontok számának megadására használható instance_count .

  Python

  from azure.ai.ml import command 
  from azure.ai.ml import MLClient # Handle to the workspace.
  from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential # Authentication package.
  from azure.ai.ml.entities import JobResourceConfiguration 
  
  try:
      credential = DefaultAzureCredential()
      credential.get_token("https://management.azure.com/.default")
  except Exception:
      credential = InteractiveBrowserCredential()
  # 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)
  

  Azure CLI

  $schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
  command: echo "hello world"
  environment:
    image: library/python:latest
  resources:
    instance_count: 4
    instance_type: Standard_NC24 
  

  Referencia:JobResourceConfiguration

• 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ú virtuális gépeket (job_tier: Spot).

  Python

  from azure.ai.ml import command
  from azure.ai.ml import MLClient    # Handle to the workspace.
  from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential    # Authentication package.
  try:
      credential = DefaultAzureCredential()
      credential.get_token("https://management.azure.com/.default")
  except Exception:
      credential = InteractiveBrowserCredential()
  # 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)
  

  Azure CLI

  $schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
  component: ./train.yml 
  queue_settings:
     job_tier: Standard # Possible values are Standard (dedicated) and Spot (low priority). The default is Standard.
  

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

Íme egy példa, amely az összes megadott mezőt megjeleníti, beleértve azt az identitást is, amelyet a feladatnak használnia kell. Nem kell virtuális hálózati beállításokat megadnia, mert a munkaterületszintű felügyelt hálózatelkülönítés automatikusan használatban van.

Python

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

try:
    credential = DefaultAzureCredential()
    credential.get_token("https://management.azure.com/.default")
except Exception:
    credential = InteractiveBrowserCredential()
# 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 = JobResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=1)
# Submit the command job.
ml_client.create_or_update(job)

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
queue_settings:
   job_tier: Standard # Possible values are Standard and Spot. The default is Standard.
identity:
  type: user_identity # Possible values are Managed and user_identity.
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3 

Referencia:JobResourceConfiguration | UserIdentityConfiguration | parancsfüggvény

Íme két további példa a kiszolgáló nélküli számítás betanításhoz való használatára:

• Első pillantás az Azure Machine Learningre
• Modell betanítása

AutoML-feladat

Nem kell megadnia az AutoML-feladatok számítását. Az erőforrások opcionálisan megadhatóak. Ha nincs megadva példányszám, az a max_concurrent_trials és max_nodes paraméterek alapján alapértelmezettként van beállítva. Ha autoML-rendszerkép-besorolást vagy NLP-feladatot küld el példánytípus megadása nélkül, a rendszer automatikusan kiválasztja a GPU-beli virtuális gép méretét. AutoML-feladatokat cli-ekkel, Python SDK-val vagy studióval küldhet be.

Python

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)

Azure CLI

Ha meg szeretné adni a típust vagy a példányszámot, adjon hozzá egy szakaszt resources .

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl
experiment_name: dpv2-cli-automl-classifier-experiment
description: A Classification job using bank marketing
# Serverless compute is used to run this AutoML job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.

task: classification
log_verbosity: debug
primary_metric: accuracy

target_column_name: "y"

#validation_data_size: 0.20
#n_cross_validations: 5
#test_data_size: 0.1

training_data:
  path: "./training-mltable-folder"
  type: mltable
validation_data:
  path: "./validation-mltable-folder"
  type: mltable
test_data:
  path: "./test-mltable-folder"
  type: mltable

limits:
  timeout_minutes: 180
  max_trials: 40
  max_concurrent_trials: 5
  trial_timeout_minutes: 20
  enable_early_termination: true
  exit_score: 0.92

featurization:
  mode: custom
  transformer_params:
    imputer:
      - fields: ["job"]
        parameters:
          strategy: most_frequent
  blocked_transformers:
    - WordEmbedding
training:
  enable_model_explainability: true
  allowed_training_algorithms:
    - gradient_boosting
    - logistic_regression
# Resources to run this serverless job
resources:
  instance_type="Standard_E4s_v3"
  instance_count=5

Folyamatfeladat

Python

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"

Azure CLI

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

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: 1b_e2e_registered_components
description: E2E dummy train-score-eval pipeline with registered components
# Serverless compute is used to run this pipeline job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.
inputs:
  pipeline_job_training_max_epocs: 20
  pipeline_job_training_learning_rate: 1.8
  pipeline_job_learning_rate_schedule: 'time-based'

outputs: 
  pipeline_job_trained_model:
    mode: upload
  pipeline_job_scored_data:
    mode: upload
  pipeline_job_evaluation_report:
    mode: upload

settings:
 default_compute: azureml:serverless

jobs:
  train_job:
    type: command
    component: azureml:my_train@latest
    inputs:
      training_data: 
        type: uri_folder 
        path: ./data      
      max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
      learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
      learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
    outputs:
      model_output: ${{parent.outputs.pipeline_job_trained_model}}
    services:
      my_vscode:
        type: vs_code
      my_jupyter_lab:
        type: jupyter_lab
      my_tensorboard:
        type: tensor_board
        log_dir: "outputs/tblogs"
    #  my_ssh:
    #    type: tensor_board
    #    ssh_public_keys: <paste the entire pub key content>
    #    nodes: all # Use the `nodes` property to pick which node you want to enable interactive services on. If `nodes` are not selected, by default, interactive applications are only enabled on the head node.

  score_job:
    type: command
    component: azureml:my_score@latest
    inputs:
      model_input: ${{parent.jobs.train_job.outputs.model_output}}
      test_data: 
        type: uri_folder 
        path: ./data
    outputs:
      score_output: ${{parent.outputs.pipeline_job_scored_data}}

  evaluate_job:
    type: command
    component: azureml:my_eval@latest
    inputs:
      scoring_result: ${{parent.jobs.score_job.outputs.score_output}}
    outputs:
      eval_output: ${{parent.outputs.pipeline_job_evaluation_report}}

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

Kiszolgáló nélküli folyamatfeladatok konfigurálása felhasználó által hozzárendelt felügyelt identitással

Amikor kiszolgálómentes számítást használ a csővezeték-feladatokban, javasoljuk, hogy a felhasználói identitást az egyes lépések szintjén állítsa be, amelyek egy számítási egységen futnak, ahelyett, hogy a gyökér csővezeték szintjén tenné ezt. (Bár az identitásbeállítás a gyökérfolyamat és a lépés szintjén is támogatott, a lépésszintű beállítás elsőbbséget élvez, ha mindkettő be van állítva. A folyamatösszetevőket tartalmazó folyamatok esetében azonban az identitást az egyes futtatandó lépésekre kell beállítani. A gyökérfolyamat vagy a folyamat összetevő szintjén beállított identitás nem fog működni. Ezért javasoljuk, hogy az egyszerűség kedvéért állítsa be az identitást az egyes lépések szintjén.)

Python

def my_pipeline():
    train_job = train_component(
        training_data=Input(type="uri_folder", path="./data")
    )
    # Set managed identity for the job
    train_job.identity = {"type": "managed"}
    return {"train_output": train_job.outputs}

pipeline_job = my_pipeline()
# Configure the pipeline to use serverless compute.
pipeline_job.settings.default_compute = "serverless"

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
description: E2E dummy train-score-eval pipeline with registered components
settings:
    default_compute: azureml:serverless
jobs:
 train_job:
   type: command
   component: azureml:my_train@latest
inputs:
   training_data: 
     type: uri_folder 
      path: ./data   
 identity:
   type: managed

Kapcsolódó tartalom

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

• Első pillantás az Azure Machine Learningre
• Modell betanítása