Freigeben über

Modelltraining bei serverlosem Computing

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python-SDK azure-ai-ml v2 (aktuell)

Sie müssen keine Compute erstellen und verwalten , um Ihr Modell auf skalierbare Weise zu trainieren. Sie können Ihren Auftrag stattdessen an einen Computezieltyp übermitteln, der als serverlose Berechnung bezeichnet wird. Serverloses Compute ist die einfachste Möglichkeit, Trainingsaufträge in Azure Machine Learning auszuführen. Serverloses Computing stellt ein vollständig verwaltetes, bedarfsgesteuertes Computing dar. Azure Machine Learning erstellt, skaliert und verwaltet die Berechnung für Sie. Wenn Sie serverloses Computing verwenden, um Modelle zu trainieren, können Sie sich auf das Erstellen von maschinellen Lernmodellen konzentrieren und müssen sich nicht mit der Recheninfrastruktur oder deren Einrichtung auseinandersetzen.

Sie können die Ressourcen angeben, die der Auftrag benötigt. Azure Machine Learning verwaltet die Computeinfrastruktur und bietet verwaltete Netzwerkisolation, wodurch die Belastung für Sie verringert wird.

Unternehmen können auch Kosten senken, indem sie optimale Ressourcen für jeden Auftrag angeben. IT-Administratoren können weiterhin die Kontrolle übernehmen, indem Sie das Kernkontingent auf Abonnement- und Arbeitsbereichsebenen angeben und Azure-Richtlinien anwenden.

Sie können serverlose Berechnung verwenden, um Modelle im Modellkatalog zu optimieren. Sie können es verwenden, um alle Arten von Aufträgen auszuführen, indem Sie Azure Machine Learning Studio, das Python SDK und Azure CLI verwenden. Sie können auch serverloses Computing verwenden, um Umgebungsimages zu erstellen und Szenarien für verantwortungsvolle KI-Dashboards zu realisieren. Serverlose Aufträge nutzen das gleiche Kontingent wie das Azure Machine Learning-Computekontingent. Sie können VMs mit der Dienstebene „Standard“ (Dediziert) oder Spot-VMs (niedrige Priorität) auswählen. Verwaltete Identitäten und Benutzeridentitäten werden für serverlose Aufträge unterstützt. Das Abrechnungsmodell ist identisch mit dem Modell für azure Machine Learning Compute.

Vorteile von serverlosem Computing

  • Azure Machine Learning verwaltet das Erstellen, Einrichten, Skalieren, Löschen und Patchen von Computeinfrastrukturen, um den Verwaltungsaufwand zu reduzieren.
  • Sie müssen sich nicht mit Computern, verschiedenen Computertypen oder verwandten Eigenschaften befassen.
  • Sie müssen nicht wiederholt Cluster für jede benötigte VM-Größe erstellen, indem Sie die gleichen Einstellungen verwenden und sie für jeden Arbeitsbereich replizieren.
  • Sie können die Kosten optimieren, indem Sie die genauen Ressourcen angeben, die jeder Auftrag zur Laufzeit benötigt, um instanztyp (VM-Größe) und die Instanzenanzahl zu ermitteln. Sie können auch die Auslastungsmetriken des Auftrags überwachen, um die Ressourcen zu optimieren, die ein Auftrag benötigt.
  • Es sind weniger Schritte erforderlich, um einen Auftrag auszuführen.
  • Um die Auftragsübermittlung weiter zu vereinfachen, können Sie die Ressourcen vollständig überspringen. Azure Machine Learning legt standardmäßig die Anzahl der Instanzen fest und wählt einen Instanztyp aus, unter Berücksichtigung von Faktoren wie Kontingent, Kosten, Leistung und Datenträgergröße.
  • In einigen Szenarien werden Wartezeiten vor dem Starten von Aufträgen reduziert.
  • Benutzeridentität und vom Benutzer im Arbeitsbereich zugewiesene verwaltete Identität werden für die Aufgabenübermittlung unterstützt.
  • Mit verwaltete Netzwerkisolation können Sie Ihre Konfiguration der Netzwerkisolation optimieren und automatisieren. Virtuelle Kundennetzwerke werden ebenfalls unterstützt.
  • Die administrative Kontrolle ist über Kontingent- und Azure-Richtlinien verfügbar.

Verwenden von serverlosem Computing

  • Wenn Sie einen eigenen Computecluster erstellen, verwenden Sie dessen Namen im Befehlsauftrag. Beispiel: compute="cpu-cluster". Ohne Server können Sie die Erstellung eines Computeclusters überspringen und den compute Parameter auslassen, um stattdessen serverloses Berechnen zu verwenden. Wenn compute nicht für einen Auftrag angegeben ist, wird der Auftrag mit serverlosem Computing ausgeführt. Lassen Sie den Namen der Compute-Ressource in Ihren Azure CLI- oder Python SDK-Aufträgen weg, um serverlose Rechenleistung in den folgenden Auftragstypen zu verwenden. Sie können optional Ressourcen für die Instanzanzahl und den Instanztyp angeben, die der Auftrag benötigt.

    • Befehlsaufträge, einschließlich interaktiver Aufträge und verteiltem Training
    • AutoML-Aufträge
    • Sweepaufträge
    • Parallelaufträge

  • Verwenden Sie für Pipelineaufträge über die Azure CLI default_compute: azureml:serverless als Standardberechnung auf Pipelineebene. Verwenden Sie default_compute="serverless"für Pipelineaufträge über das Python SDK . Ein Beispiel finden Sie unter Pipelineauftrag.

  • Wenn Sie einen Schulungsauftrag in Studio übermitteln, wählen Sie "Serverless " als Computetyp aus.

  • Wenn Sie Azure Machine Learning-Designer verwenden, wählen Sie "Serverless " als Standardberechnung aus.

Überlegungen zur Leistung

Serverlose Berechnung kann die Geschwindigkeit Ihres Trainings auf folgende Weise erhöhen:

Vermeiden Sie Fehler durch unzureichende Kontingente. Wenn Sie Ihren eigenen Computecluster erstellen, sind Sie für die Ermittlung der Größe und der Knotenanzahl des virtuellen Computers verantwortlich. Wenn Ihr Job ausgeführt wird und Sie nicht über ein ausreichendes Kontingent für den Cluster verfügen, schlägt der Job fehl. Serverloses Computing nutzt Informationen zu Ihrem Kontingent, um standardmäßig eine geeignete VM-Größe auszuwählen.

Optimierung vertikal skalieren. Wenn ein Computecluster herunterskaliert wird, muss ein neuer Auftrag warten, bis der Cluster herunterskaliert und dann nach oben skaliert wird, bevor der Auftrag ausgeführt werden kann. Bei serverlosem Computing müssen Sie nicht auf das Herunterskalieren warten. Ihr Auftrag kann mit der Ausführung auf einem anderen Cluster/Knoten beginnen (vorausgesetzt, Sie verfügen über ein Kontingent).

Cluster-busy-Optimierung. Wenn ein Auftrag auf einem Computecluster ausgeführt wird und ein anderer Auftrag übermittelt wird, wird Ihr Auftrag hinter dem aktuell ausgeführten Auftrag in die Warteschlange eingereiht. Bei serverloser Berechnung kann Ihr Auftrag mit der Ausführung auf einem anderen Knoten/Cluster beginnen (vorausgesetzt, Sie verfügen über ein Kontingent).

Kontingent

Wenn Sie einen Auftrag übermitteln, benötigen Sie weiterhin ein ausreichendes Computekontingent für Azure Machine Learning, um fortzufahren (sowohl arbeitsbereichs- als auch abonnementbasiertes Kontingent). Die Standard-VM-Größe für serverlose Aufträge wird basierend auf diesem Kontingent ausgewählt. Wenn Sie Ihre eigene VM-Größe/-Familie angeben:

  • Wenn Sie über ein Kontingent für Ihre VM-Größe/Familie verfügen, aber nicht über ein ausreichendes Kontingent für die Anzahl der Instanzen verfügen, wird ein Fehler angezeigt. Der Fehler empfiehlt, die Anzahl der Instanzen auf eine gültige Zahl basierend auf Ihrem Kontingentlimit zu verringern, eine Kontingenterhöhung für die VM-Familie anzufordern oder die VM-Größe zu ändern.
  • Wenn Sie kein Kontingent für die angegebene VM-Größe haben, wird ein Fehler angezeigt. Der Fehler empfiehlt, eine andere VM-Größe auszuwählen, für die Sie ein Kontingent oder ein Anforderungskontingent für die VM-Familie haben.
  • Wenn Sie über ein ausreichendes Kontingent für eine VM-Familie verfügen, um den serverlosen Auftrag auszuführen, aber andere Aufträge verwenden das Kontingent, erhalten Sie eine Meldung, dass Ihr Auftrag in einer Warteschlange warten muss, bis das Kontingent verfügbar ist.

Wenn Sie Ihre Nutzung und Kontingente im Azure-Portal anzeigen, wird der Name "Serverless " für alle von serverlosen Aufträgen verbrauchten Kontingente angezeigt.

Support für Identitäten und Anmeldeinformationen

  • Passthrough für Benutzeranmeldeinformationen: Serverless Compute unterstützt die Passthrough für Benutzeranmeldeinformationen vollständig. Das Benutzertoken des Benutzers, der den Auftrag übermittelt, wird für den Speicherzugriff verwendet. Diese Anmeldeinformationen stammen aus der Microsoft Entra-ID.

    Die serverlose Berechnung unterstützt keine vom System zugewiesene Identität.

    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)

  • Vom Benutzer zugewiesene verwaltete Identität: Wenn Sie einen Arbeitsbereich mit der vom Benutzer zugewiesenen verwalteten Identität konfiguriert haben, können Sie diese Identität mit dem serverlosen Auftrag für den Speicherzugriff verwenden. Informationen zum Zugriff auf geheime Schlüssel finden Sie unter Verwenden geheimer Authentifizierungsschlüssel in Azure Machine Learning-Aufträgen.

  1. Überprüfen Sie Ihre Arbeitsbereichsidentitätskonfiguration.

    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)

    Suchen Sie in der Ausgabe nach der vom Benutzer zugewiesenen Identität. Wenn sie fehlt, erstellen Sie einen neuen Arbeitsbereich mit einer vom Benutzer zugewiesenen verwalteten Identität, indem Sie die Anweisungen unter Einrichten der Authentifizierung zwischen Azure Machine Learning und anderen Diensten befolgen.

  2. Verwenden Sie Ihre benutzerdefinierte verwaltete Identität in Ihrer Aufgabe.

    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(client_id="<workspace-UAMI-client-ID>"),
)
# Submit the command job.
ml_client.create_or_update(job)

Konfigurieren von Eigenschaften für Befehlsaufträge

Wenn für Command-, Sweep- und AutoML-Jobs kein Compute-Ziel angegeben wird, wird standardmäßig Serverless-Compute verwendet. Ein Beispiel:

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)

Für die Computeressource wird standardmäßig serverloses Computing mit Folgendem verwendet:

  • Ein einzelner Knoten für diesen Auftrag. Die Standardanzahl von Knoten basiert auf dem Auftragstyp. Weitere Auftragstypen finden Sie in den folgenden Abschnitten.
  • Ein virtueller CPU-Computer. Der virtuelle Computer wird basierend auf Kontingent, Leistung, Kosten und Datenträgergröße bestimmt.
  • Dedizierte virtuelle Computer.
  • Ort des Arbeitsbereichs.

Sie können diese Standardwerte außer Kraft setzen. Wenn Sie den VM-Typ oder die Anzahl der Knoten für serverloses Computing angeben möchten, fügen Sie Ihrem Auftrag resources hinzu:

  • Verwenden Sie instance_type, um eine bestimmte VM auszuwählen. Verwenden Sie diesen Parameter, wenn Sie eine bestimmte CPU- oder GPU-VM-Größe benötigen.

  • Wird instance_count verwendet, um die Anzahl der Knoten anzugeben.

    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)

  • Verwenden Sie queue_settings zum Ändern der Auftragsebene zwischen dedizierten VMs (job_tier: Standard) und VMs mit niedriger Priorität (job_tier: 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)

Beispiel für alle Felder mit Befehlsaufträgen

Hier ist ein Beispiel, das alle angegebenen Felder anzeigt, einschließlich der ID, die der Auftrag verwenden soll. Sie müssen keine Einstellungen für virtuelle Netzwerke angeben, da die verwaltete Netzwerkisolation auf Arbeitsbereichsebene automatisch verwendet wird.

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)

Hier sind zwei weitere Beispiele für die Verwendung von Serverless Compute für Schulungen:

Auftrag für automatisiertes maschinelles Lernen

Für AutoML-Jobs müssen Sie kein Compute-Ziel angeben. Ressourcen können optional angegeben werden. Wenn keine Instanzanzahl angegeben ist, wird diese basierend auf den Parametern max_concurrent_trials und max_nodes standardmäßig festgelegt. Wenn Sie eine AutoML-Imageklassifizierung oder EINE NLP-Aufgabe ohne Angabe eines Instanztyps übermitteln, wird die GRÖßE der GPU-VM automatisch ausgewählt. Sie können AutoML-Aufträge mithilfe von CLIs, dem Python SDK oder Studio übermitteln.

Wenn Sie den Typ oder die Anzahl der Instanzen angeben möchten, verwenden Sie die Klasse 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)

Pipelineauftrag

Geben Sie für einen Pipelineauftrag "serverless" als Standardcomputetyp an, um serverloses Computing zu verwenden.

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

Sie können auch serverloses Computing als Standardcomputetyp im Designer festlegen.

Konfigurieren von serverlosen Pipelineaufträgen mit vom Benutzer zugewiesener verwalteter Identität

Wenn Sie serverlose Berechnung in Pipelineaufträgen verwenden, empfiehlt es sich, die Benutzeridentität auf der ebene der einzelnen Schritte festzulegen, die auf einer Berechnung und nicht auf der Stammpipelineebene ausgeführt wird. (Obwohl die Identitätseinstellung sowohl auf Der Stammpipeline- als auch auf Schrittebene unterstützt wird, hat die Einstellung auf Schrittebene Vorrang, wenn beide festgelegt sind. Für Pipelines, die Pipelinekomponenten enthalten, muss die Identität jedoch für einzelne Schritte festgelegt werden, die ausgeführt werden. Die auf der Ebene der Stammpipeline- oder Pipelinekomponente festgelegte Identität funktioniert nicht. Daher empfehlen wir, die Identität auf der ebene der einzelnen Schritte im Sinne der Einfachheit festzulegen.)

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"

Verwandte Inhalte

Sehen Sie sich weitere Beispiele für Schulungen mit serverlosem Compute an:

  • Last updated on