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 keinen Computecluster mehr erstellen und verwalten, um Ihr Modell auf skalierbare Weise zu trainieren. Ihr Auftrag kann stattdessen an einen neuen Compute-Zieltyp übermittelt werden. Dies wird als serverloses Compute 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. Durch Modelltraining mit serverlosem Computing können sich Machine Learning-Experten auf ihre Kenntnisse im Erstellen von Machine Learning-Modellen konzentrieren und müssen sich nicht mit der Computeinfrastruktur oder ihrer Einrichtung vertraut machen.

Machine Learning-Experten 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.

Serverlose Berechnung kann verwendet werden, um Modelle im Modellkatalog zu optimieren. Serverlose Berechnung kann verwendet werden, um alle Arten von Aufträgen aus Azure Machine Learning Studio, SDK und CLI auszuführen. Serverloses Computing kann auch für die Erstellung von Umgebungsimages und für verantwortungsvolle KI-Dashboard-Szenarien verwendet werden. 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 entspricht der Berechnung von Azure Machine Learning.

Vorteile von serverlosem Computing

  • Azure Machine Learning verwaltet das Erstellen, Einrichten, Skalieren, Löschen und Patchen von Computeinfrastrukturen, wodurch der Verwaltungsaufwand reduziert wird.
  • Sie müssen sich nicht mit Computing, den verschiedenen Computetypen und verwandten Eigenschaften vertraut machen.
  • Es ist nicht erforderlich, wiederholt Cluster für jedes benötigte VM-Format zu erstellen, unter Verwendung derselben Einstellungen und diese für jeden Arbeitsbereich zu replizieren.
  • Sie können die Kosten optimieren, indem Sie die genauen Ressourcen angeben, die jeder Auftrag zur Laufzeit in Bezug auf Instanztyp (VM-Größe) und Anzahl der Instanzen benötigt. Sie können die Auslastungsmetriken des Auftrags überwachen, um die Ressourcen zu optimieren, die ein Auftrag benötigt.
  • Reduzierung der schritte, die zum Ausführen eines Auftrags erforderlich sind
  • Um die Auftragsübermittlung weiter zu vereinfachen, können Sie die Ressourcen vollständig überspringen. Azure Machine Learning standardmäßig die Instanzanzahl und wählt einen Instanztyp (VM-Größe) basierend auf Faktoren wie Kontingent, Kosten, Leistung und Datenträgergröße aus.
  • Kürzere Wartezeiten, bevor Aufträge in einigen Fällen ausgeführt werden
  • Für die Auftragsübermittlung werden die Benutzeridentität und die benutzerseitig zugewiesene verwaltete Identität des Arbeitsbereichs unterstützt.
  • Mit verwaltete Netzwerkisolation können Sie Ihre Konfiguration der Netzwerkisolation optimieren und automatisieren. Virtuelles Kundennetzwerk wird ebenfalls unterstützt
  • Administrative Kontrolle durch Kontingent- und Azure-Richtlinien

Verwenden von serverlosem Computing

  • Wenn Sie einen eigenen Computecluster erstellen, verwenden Sie seinen Namen im Befehlsauftrag, etwa compute="cpu-cluster". Mit der Option „serverlos“ können Sie die Erstellung eines Computeclusters überspringen und den Parameter compute weglassen, um stattdessen serverloses Computing zu verwenden. Wenn compute nicht für einen Auftrag angegeben ist, wird der Auftrag mit serverlosem Computing ausgeführt. Lassen Sie den Computenamen in Ihren CLI- oder SDK-Aufträgen weg, um serverloses Computing in den folgenden Auftragstypen zu verwenden und optional Ressourcen bereitzustellen, die ein Auftrag in Bezug auf Anzahl der Instanzen und Instanztyp benötigt:

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

  • Verwenden Sie bei Pipelineaufträgen über die CLI default_compute: azureml:serverless für Standardcomputeressourcen auf Pipelineebene. Für Pipelineaufträge über das SDK verwenden Sie default_compute="serverless". Ein Beispiel finden Sie unter Pipelineauftrag.

  • Wenn Sie einen Trainingsauftrag in Studio übermitteln (Vorschau), wählen Sie Serverlos als Computetyp aus.

  • Wenn Sie den Azure Machine Learning-Designer verwenden, wählen Sie Serverlos als Standardcomputetyp aus.

Überlegungen zur Leistung

Serverloses Computing kann wie folgt dazu beitragen, das Training zu beschleunigen:

Unzureichendes Kontingent: Wenn Sie einen eigenen Computecluster erstellen, sind Sie dafür verantwortlich, die zu erstellende VM-Größe und Knotenanzahl zu bestimmen. Wenn Ihr Auftrag ausgeführt wird und Sie nicht über ein ausreichendes Kontingent für den Cluster verfügen, ist der Auftrag nicht erfolgreich. Serverloses Computing nutzt Informationen zu Ihrem Kontingent, um standardmäßig eine geeignete VM-Größe auszuwählen.

Skalierungsoptimierung: Wenn ein Computecluster herunterskaliert wird, muss ein neuer Auftrag warten, bis die Skalierung nach unten erfolgt und dann nach oben skaliert wird, bevor der Auftrag ausgeführt werden kann. Bei serverlosem Computing müssen Sie nicht auf das Herunterskalieren warten, und Ihr Auftrag kann auf einem anderen Cluster/Knoten ausgeführt werden (vorausgesetzt, Sie verfügen über ein Kontingent).

Optimierung bei ausgelastetem Cluster: Wenn ein Auftrag in einem Computecluster ausgeführt und ein weiterer Auftrag übermittelt wird, wird Ihr Auftrag hinter dem derzeit ausgeführten Auftrag in die Warteschlange eingereiht. Bei serverlosem Computing erhalten Sie einen weiteren Knoten bzw. Cluster, um mit der Ausführung des Auftrags zu beginnen (vorausgesetzt, Sie verfügen über ein Kontingent).

Kontingent

Beim Übermitteln des Auftrags benötigen Sie weiterhin ein ausreichendes Azure Machine Learning-Computekontingent, um fortzufahren (Kontingent auf Arbeitsbereichs- und Abonnementebene). 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, wird ein Fehler angezeigt. Der Fehler empfiehlt, die Anzahl der Instanzen auf eine gültige Zahl basierend auf Ihrem Kontingentlimit zu verringern oder eine Kontingenterhöhung für diese 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 anforderungskontingent für diese VM-Familie haben.
  • Wenn Sie über ausreichendes Kontingent für die 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 Ihr Kontingent im Azure-Portal anzeigen, wird der Name „Serverlos“ angezeigt, um das gesamte Kontingent anzuzeigen, das von serverlosen Aufträgen genutzt wird.

Identitätsunterstützung und Passthrough für Anmeldeinformationen

  • Passthrough für Benutzeranmeldeinformationen: Serverloses Computing unterstützt Passthrough für Benutzeranmeldeinformationen vollständig. Das Benutzertoken des Benutzers bzw. der Benutzerin, der bzw. die den Auftrag übermittelt, wird für den Speicherzugriff verwendet. Diese Anmeldeinformationen stammen aus Ihrem 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. Weitere Informationen zum Zugreifen auf Geheimnisse finden Sie unter Verwenden von geheimen Authentifizierungsschlüsseln 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 den vom Benutzer zugewiesenen Identitäten. 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 Befehls-, Sweep- und AutoML-Aufträge kein Computeziel angegeben ist, wird standardmäßig serverloses Computing verwendet. Beispiel für diesen Befehlsauftrag:

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)

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

  • Einzelner Knoten für diesen Auftrag. Die Standardanzahl von Knoten basiert auf dem Auftragstyp. Weitere Auftragstypen finden Sie in den folgenden Abschnitten.
  • Virtueller CPU-Computer, der basierend auf Kontingent, Leistung, Kosten und Datenträgergröße bestimmt wird.
  • Dedizierte virtuelle Computer
  • Speicherort 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:

  • instance_type zum Auswählen einer bestimmten VM. Verwenden Sie diesen Parameter, wenn Sie eine bestimmte CPU-/GPU-VM-Größe benötigen.

  • instance_count zum Angeben der Knotenanzahl.

    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, um die Jobstufe zwischen dedizierten VMs (job_tier: Standard) und VMs mit niedriger Priorität (job_tier: Spot) zu wechseln.

    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 sehen Sie ein Beispiel für alle angegebenen Felder, einschließlich der Identität, die der Auftrag verwenden sollte. Es ist nicht erforderlich, Einstellungen für virtuelle Netzwerke anzugeben, da automatisch verwaltete Netzwerkisolation auf Arbeitsbereichsebene 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)

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

Auftrag für automatisiertes maschinelles Lernen

Es ist nicht erforderlich, Computing für AutoML-Aufträge anzugeben. Ressourcen können optional angegeben werden. Wenn die Anzahl der Instanzen nicht angegeben ist, wird die Standardeinstellung basierend auf den Parametern „max_concurrent_trials“ und „max_nodes“ verwendet. Wenn Sie eine AutoML-Aufgabe zur Bildklassifizierung oder eine NLP-Aufgabe ohne Instanztyp übermitteln, wird die GPU-VM-Größe automatisch ausgewählt. Sie können AutoML-Aufträge über CLIs, SDK oder Studio übermitteln. Um AutoML-Aufträge mit serverlosem Compute in Studio zu übermitteln, aktivieren Sie zuerst das Feature zum Übermitteln eines Schulungsauftrags in Studio (Vorschau) im Vorschaubereich.

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 benutzerseitig zugewiesener verwalteter Identität

Wenn Sie serverlose Berechnung in Pipeline-Jobs verwenden, empfehlen wir, die Benutzeridentität auf der Ebene der einzelnen Schritte festzulegen, die auf einer Berechnung und nicht auf der Ebene der Stammpipeline ausgeführt werden. (Während 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 zur 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()
# set pipeline to use serverless compute
pipeline_job.settings.default_compute = "serverless"

Nächste Schritte

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

  • Last updated on