Trenowanie modelu w przypadku obliczeń bezserwerowych (wersja zapoznawcza)

Artykuł
07/13/2023

DOTYCZY:Rozszerzenie uczenia maszynowego platformy Azure w wersji 2 (bieżąca)Zestaw PYTHON SDK azure-ai-ml w wersji 2 (bieżąca)

Nie trzeba już tworzyć zasobów obliczeniowych i zarządzać nimi , aby wytrenować model w sposób skalowalny. Zadanie można zamiast tego przesłać do nowego typu docelowego obliczeniowego nazywanego obliczeniami bezserwerowym. Przetwarzanie bezserwerowe to najprostszy sposób uruchamiania zadań szkoleniowych w usłudze Azure Machine Learning. Obliczenia bezserwerowe to w pełni zarządzane obliczenia na żądanie. Jest on tworzony, skalowany i zarządzany przez usługę Azure Machine Learning. Dzięki trenowaniu modeli przy użyciu obliczeń bezserwerowych specjaliści uczenia maszynowego mogą skupić się na swojej wiedzy na temat tworzenia modeli uczenia maszynowego i nie muszą uczyć się infrastruktury obliczeniowej ani konfigurować jej.

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Specjaliści ds. uczenia maszynowego mogą określić zasoby wymagane przez zadanie. Usługa Azure Machine Learning zarządza infrastrukturą obliczeniową i zapewnia izolację sieci zarządzanej (wersja zapoznawcza) zmniejszając obciążenie.

Przedsiębiorstwa mogą również obniżyć koszty, określając optymalne zasoby dla każdego zadania. Administratorzy IT nadal mogą stosować kontrolę, określając limit przydziału rdzeni na poziomie subskrypcji i obszaru roboczego oraz stosując zasady platformy Azure.

Bezserwerowe obliczenia mogą służyć do uruchamiania poleceń, zamiatania, rozwiązania AutoML, potoku, trenowania rozproszonego i zadań interaktywnych z poziomu Azure Machine Learning studio, zestawu SDK i interfejsu wiersza polecenia. Zadania bezserwerowe zużywają ten sam limit przydziału co limit przydziału zasobów obliczeniowych usługi Azure Machine Learning. Możesz wybrać standardowa (dedykowaną) warstwę lub maszyny wirtualne typu spot (o niskim priorytcie). Tożsamość zarządzana i tożsamość użytkownika są obsługiwane w przypadku zadań bezserwerowych. Model rozliczeń jest taki sam jak środowisko obliczeniowe usługi Azure Machine Learning.

Zalety obliczeń bezserwerowych

Usługa Azure Machine Learning zarządza tworzeniem, konfigurowaniem, skalowaniem, usuwaniem, poprawianiem, infrastrukturą obliczeniową, co zmniejsza nakład pracy związany z zarządzaniem
Nie musisz dowiedzieć się więcej o obliczeniach, różnych typach obliczeniowych i powiązanych właściwościach.
Nie ma potrzeby wielokrotnego tworzenia klastrów dla każdego wymaganego rozmiaru maszyny wirtualnej, używania tych samych ustawień i replikowania dla każdego obszaru roboczego.
Koszty można zoptymalizować, określając dokładne zasoby wymagane przez każde zadanie w czasie wykonywania pod względem typu wystąpienia (rozmiar maszyny wirtualnej) i liczby wystąpień. Możesz monitorować metryki wykorzystania zadania, aby zoptymalizować zasoby potrzebne do wykonania zadania.
Zmniejszenie liczby kroków związanych z uruchamianiem zadania
Aby jeszcze bardziej uprościć przesyłanie zadań, możesz całkowicie pominąć zasoby. Usługa Azure Machine Learning domyślnie określa liczbę wystąpień i wybiera typ wystąpienia (rozmiar maszyny wirtualnej) na podstawie czynników, takich jak limit przydziału, koszt, wydajność i rozmiar dysku.
Mniejsze czasy oczekiwania przed rozpoczęciem wykonywania zadania w niektórych przypadkach.
Tożsamość użytkownika i tożsamość zarządzana przypisana przez użytkownika w obszarze roboczym jest obsługiwana w przypadku przesyłania zadań.
Dzięki zarządzana izolacja sieci można usprawnić i zautomatyzować konfigurację izolacji sieciowej.
Administracja kontrolować za pomocą limitu przydziału i zasad platformy Azure

Jak używać obliczeń bezserwerowych

Podczas tworzenia własnego klastra obliczeniowego należy użyć jego nazwy w zadaniu polecenia, takim jak compute="cpu-cluster". Bezserwerowe można pominąć tworzenie klastra obliczeniowego i compute pominąć parametr , aby zamiast tego używać bezserwerowych obliczeń. Jeśli compute nie zostanie określony dla zadania, zadanie jest uruchamiane na obliczeniach bezserwerowych. Pomiń nazwę obliczeniową w zadaniach interfejsu wiersza polecenia lub zestawu SDK, aby używać bezserwerowych zasobów obliczeniowych w następujących typach zadań i opcjonalnie podaj zasoby potrzebne w zakresie liczby wystąpień i typu wystąpienia:
- Zadania poleceń, w tym zadania interaktywne i trenowanie rozproszone
- Zadania automatycznego uczenia maszynowego
- Zamiatanie zadań
W przypadku zadań potoku za pomocą interfejsu wiersza polecenia default_compute: azureml:serverless dla domyślnych zasobów obliczeniowych na poziomie potoku. W przypadku zadań potoków za pomocą zestawu SDK użyj polecenia default_compute="serverless". Zobacz Przykład zadania potoku .
Aby użyć przesyłania zadań bezserwerowych w Azure Machine Learning studio, najpierw włącz tę funkcję w sekcji Zarządzanie wersjami zapoznawczami:
Po przesłaniu zadania szkoleniowego w programie Studio (wersja zapoznawcza) wybierz pozycję Bezserwerowa jako typ obliczeniowy.
W przypadku korzystania z projektanta usługi Azure Machine Learning wybierz pozycję Bezserwerowe jako domyślne środowisko obliczeniowe.

Ważne

Jeśli chcesz używać bezserwerowych zasobów obliczeniowych z obszarem roboczym skonfigurowanym do izolacji sieci, obszar roboczy musi używać zarządzana izolacja sieci. Aby uzyskać więcej informacji, zobacz zarządzana izolacja sieci obszaru roboczego.

Zagadnienia dotyczące wydajności

Obliczenia bezserwerowe mogą pomóc przyspieszyć trenowanie w następujący sposób:

Niewystarczający limit przydziału: Podczas tworzenia własnego klastra obliczeniowego odpowiadasz za ustalenie rozmiaru maszyny wirtualnej i liczby węzłów do utworzenia. Jeśli zadanie zostanie uruchomione, jeśli nie masz wystarczającego limitu przydziału dla klastra, zadanie zakończy się niepowodzeniem. Obliczenia bezserwerowe domyślnie używają informacji o limitach przydziału, aby wybrać odpowiedni rozmiar maszyny wirtualnej.

Optymalizacja skalowania w dół: Gdy klaster obliczeniowy jest skalowany w dół, nowe zadanie musi poczekać na wykonanie skalowania w dół, a następnie przeskalować w górę przed uruchomieniem zadania. W przypadku obliczeń bezserwerowych nie trzeba czekać na skalowanie w dół, a zadanie może rozpocząć działanie w innym klastrze/węźle (przy założeniu, że masz limit przydziału).

Optymalizacja zajętego klastra: gdy zadanie jest uruchomione w klastrze obliczeniowym, a inne zadanie jest przesyłane, zadanie jest w kolejce za aktualnie uruchomionym zadaniem. W przypadku obliczeń bezserwerowych uzyskujesz inny węzeł/inny klaster, aby rozpocząć uruchamianie zadania (przy założeniu, że masz przydział).

limit przydziału

Podczas przesyłania zadania nadal potrzebujesz wystarczającego limitu przydziału zasobów obliczeniowych usługi Azure Machine Learning (przydział na poziomie obszaru roboczego i subskrypcji). Domyślny rozmiar maszyny wirtualnej dla zadań bezserwerowych jest wybierany na podstawie tego limitu przydziału. Jeśli określisz własny rozmiar/rodzinę maszyn wirtualnych:

Jeśli masz pewien limit przydziału dla rozmiaru/rodziny maszyn wirtualnych, ale nie masz wystarczającego limitu przydziału dla liczby wystąpień, zostanie wyświetlony błąd. Błąd zaleca zmniejszenie liczby wystąpień do prawidłowej liczby na podstawie limitu przydziału lub zażądanie zwiększenia limitu przydziału dla tej rodziny maszyn wirtualnych lub zmiana rozmiaru maszyny wirtualnej
Jeśli nie masz limitu przydziału dla określonego rozmiaru maszyny wirtualnej, zostanie wyświetlony błąd. Błąd zaleca wybranie innego rozmiaru maszyny wirtualnej, dla którego masz limit przydziału lub limit przydziału żądań dla tej rodziny maszyn wirtualnych
Jeśli masz wystarczający limit przydziału dla rodziny maszyn wirtualnych do uruchomienia zadania bezserwerowego, ale jest on obecnie używany przez inne zadania, zostanie wyświetlony komunikat informujący, że zadanie musi czekać w kolejce do momentu udostępnienia limitu przydziału

Po wyświetleniu użycia i limitu przydziału w Azure Portal zostanie wyświetlona nazwa "Bezserwerowa", aby zobaczyć wszystkie limity przydziału używane przez zadania bezserwerowe.

Obsługa tożsamości i przekazywanie poświadczeń

Przekazywanie poświadczeń użytkownika: przetwarzanie bezserwerowe w pełni obsługuje przekazywanie poświadczeń użytkownika. Token użytkownika, który przesyła zadanie, jest używany do uzyskiwania dostępu do magazynu. Te poświadczenia pochodzą z usługi Azure Active Directory.

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: user_identity

Tożsamość zarządzana przypisana przez użytkownika : jeśli masz obszar roboczy skonfigurowany przy użyciu tożsamości zarządzanej przypisanej przez użytkownika, możesz użyć tej tożsamości z zadaniem bezserwerowym na potrzeby dostępu do magazynu.

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity= ManagedIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: managed

Aby uzyskać informacje na temat dołączania tożsamości zarządzanej przypisanej przez użytkownika, zobacz dołączanie tożsamości zarządzanej przypisanej przez użytkownika.

Konfigurowanie właściwości dla zadań poleceń

Jeśli nie określono docelowego obiektu obliczeniowego dla zadań poleceń, zamiatania i automatycznego uczenia maszynowego, obliczenia są domyślnie ustawione na obliczenia bezserwerowe. Na przykład dla tego zadania polecenia:

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
)
# submit the command job
ml_client.create_or_update(job)

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

Domyślnie obliczenia są domyślnie obliczane bezserwerowe za pomocą następujących elementów:

Jeden węzeł dla tego zadania. Domyślna liczba węzłów jest oparta na typie zadania. Zobacz następujące sekcje, aby zapoznać się z innymi typami zadań.
Maszyna wirtualna procesora CPU określana na podstawie limitu przydziału, wydajności, kosztów i rozmiaru dysku.
Dedykowane maszyny wirtualne
Lokalizacja obszaru roboczego

Możesz zastąpić te wartości domyślne. Jeśli chcesz określić typ maszyny wirtualnej lub liczbę węzłów dla obliczeń bezserwerowych, dodaj resources do zadania:

instance_type aby wybrać określoną maszynę wirtualną. Użyj tego parametru, jeśli chcesz mieć określony rozmiar maszyny wirtualnej procesora CPU/procesora GPU

instance_count aby określić liczbę węzłów.

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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 

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    resources = ResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
)
# submit the command job
ml_client.create_or_update(job)

$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

Aby zmienić warstwę zadań, użyj polecenia queue_settings , aby wybrać między dedykowanymi maszynami wirtualnymi (job_tier: Standard) i niskim priorytetem(jobtier: Spot).

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    queue_settings={
      "job_tier": "spot"  
    }
)
# submit the command job
ml_client.create_or_update(job)

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

Przykład dla wszystkich pól z zadaniami poleceń

Oto przykład wszystkich pól określonych, w tym tożsamości, których powinno używać zadanie. Nie ma potrzeby określania ustawień sieci wirtualnej, ponieważ zostanie automatycznie użyty poziom obszaru roboczego zarządzana izolacja sieci.

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

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-sklearn-1.0-ubuntu20.04-py38-cpu@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)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
queue_settings:
   job_tier: Standard #Possible Values are Standard, Spot. Default is Standard.
identity:
  type: user_identity #Possible values are Managed, user_identity
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3

Zobacz więcej przykładów trenowania przy użyciu bezserwerowych zasobów obliczeniowych pod adresem:-

Zadanie zautomatyzowanego uczenia maszynowego

Nie ma potrzeby określania zasobów obliczeniowych dla zadań automatycznego uczenia maszynowego. Zasoby można opcjonalnie określić. Jeśli liczba wystąpień nie jest określona, wartość domyślna jest oparta na parametrach max_concurrent_trials i max_nodes. Jeśli przesyłasz zadanie klasyfikacji obrazów automatycznego uczenia maszynowego lub NLP bez typu wystąpienia, automatycznie wybierzemy rozmiar maszyny wirtualnej z procesorem GPU. Istnieje możliwość przesyłania zadania rozwiązania AutoML za pośrednictwem interfejsów CLI, zestawu SDK lub programu Studio. Aby przesłać zadania automatycznego uczenia maszynowego z bezserwerowymi obliczeniami w programie Studio, najpierw włącz środowisko z przewodnikiem do przesyłania zadań szkoleniowych z funkcją obliczeniową bezserwerową w panelu wersji zapoznawczej, a następnie prześlij zadanie szkoleniowe w programie Studio (wersja zapoznawcza).

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

Jeśli chcesz określić typ lub liczbę wystąpień, użyj ResourceConfiguration klasy .

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

Jeśli chcesz określić typ lub liczbę wystąpień, dodaj sekcję 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

Zadanie potoku

Zestaw SDK dla języka Python
Interfejs wiersza polecenia platformy Azure

W przypadku zadania potoku określ "serverless" domyślny typ obliczeniowy, aby używać bezserwerowych zasobów obliczeniowych.

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

W przypadku zadania potoku określ azureml:serverless domyślny typ obliczeniowy, aby używać bezserwerowych zasobów obliczeniowych.

$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}}

Możesz również ustawić zasoby obliczeniowe bezserwerowe jako domyślne zasoby obliczeniowe w Projektant.

Następne kroki