Freigeben über

Modelltraining bei serverlosem Computing

  • Artikel

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 Compute 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. Zu Ihrer Entlastung verwaltet Azure Machine Learning die Computeinfrastruktur und bietet verwaltete Netzwerkisolation.

Unternehmen können auch Kosten senken, indem sie optimale Ressourcen für jeden Auftrag angeben. IT-Administratoren können immer noch die Kontrolle ausüben, indem sie die Core-Quoten auf Abonnement- und Arbeitsbereichsebene festlegen und Azure-Richtlinien anwenden.

Serverloses Computing zur Feinabstimmung von Modellen im Modellkatalog wie LLAMA 2 verwendet werden. Serverloses Computing kann zur Ausführung aller Arten von Aufträgen aus Azure Machine Learning Studio, SDK und CLI verwendet werden. 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 ist identisch mit Azure Machine Learning Compute.

Vorteile von serverlosem Computing

  • Azure Machine Learning verwaltet das Erstellen, Einrichten, Skalieren, Löschen, Patchen und die Computeinfrastruktur, was den Verwaltungsaufwand reduziert.
  • Sie müssen sich nicht mit Compute, den verschiedenen Computetypen und verwandten Eigenschaften vertraut machen.
  • Es ist nicht erforderlich, für jede erforderliche VM-Größe wiederholt Cluster mit den gleichen Einstellungen zu erstellen und 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ötigen würde.
  • 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. Basierend auf Faktoren wie Kontingent, Kosten, Leistung und Datenträgergröße legt Azure Machine Learning standardmäßig die Anzahl der Instanzen fest und wählt einen Instanztyp (VM-Größe) aus.
  • Wartezeiten, bevor der Auftrag ausgeführt wird, sind in einigen Fällen geringer.
  • Benutzeridentität und benutzerseitig zugewiesene verwaltete Identität des Arbeitsbereichs werden für die Auftragsübermittlung unterstützt.
  • Mit verwaltete Netzwerkisolation können Sie Ihre Konfiguration der Netzwerkisolation optimieren und automatisieren. Virtuelles Kundennetzwerk wird ebenfalls unterstützt
  • Administratorkontrolle über Kontingente und Azure-Richtlinien

Verwenden von serverlosem Computing

  • Die Feinabstimmung von Gründungsmodellen wie LLAMA 2 kann mit Hilfe von Notebooks erfolgen (siehe unten):

  • 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. Verwenden Sie bei Pipelineaufträgen über das SDK 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.

  • Sie können serverloses Computing für ein verantwortungsvolles KI-Dashboard verwenden

Ü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.

Optimierung des Herunterskalierens: Wenn ein Computecluster herunterskaliert wird, muss ein neuer Auftrag warten, bis das Herunterskalieren abgeschlossen ist, und dann hochskalieren, 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 wird und ein anderer 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. In der Fehlermeldung wird empfohlen, die Anzahl der Instanzen basierend auf Ihrer Kontingentgrenze auf eine gültige Zahl zu verringern oder eine Kontingenterhöhung für diese VM-Familie bzw. eine Änderung der VM-Größe anzufordern.
  • Wenn Sie kein Kontingent für die angegebene VM-Größe haben, wird ein Fehler angezeigt. In der Fehlermeldung wird empfohlen, eine andere VM-Größe auszuwählen, für die Sie über ein Kontingent verfügen, oder ein Kontingent für diese VM-Familie anzufordern.
  • Wenn Sie über ein ausreichendes Kontingent für die VM-Familie zum Ausführen des serverlosen Auftrags verfügen, aber andere Aufträge das Kontingent derzeit nutzen, erhalten Sie eine Meldung, dass Ihr Auftrag in einer Warteschlange warten muss, bis 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 das 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.

    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)

  • Benutzerseitig zugewiesene verwaltete Identität: Wenn Sie einen Arbeitsbereich mit einer benutzerseitig 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.

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

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

Informationen zum Anfügen einer benutzerseitig zugewiesenen verwalteten Identität finden Sie unter Benutzerseitig zugewiesene verwaltete Identitäten anfügen.

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
  • Standort 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)

  • Wenn Sie die Auftragsebene ändern möchten, verwenden Sie queue_settings, um zwischen dedizierten VMs (job_tier: Standard) und VMs mit niedriger Priorität (jobtier: Spot) zu wählen.

    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)

Weitere Beispiele für das Training mit serverlosem Computing finden Sie unter:-

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. Es ist möglich, AutoML-Aufträge über CLIs, das SDK oder Studio zu übermitteln. Um AutoML-Aufträge mit serverlosem Computing in Studio zu übermitteln, aktivieren Sie zunächst die Funktion Trainingsauftrag in Studio übermitteln (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.

Nächste Schritte

Weitere Beispiele für das Training mit serverlosem Computing finden Sie unter:-