Modellträning på serverlös beräkning

  • Artikel

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

Du behöver inte längre skapa och hantera beräkning för att träna din modell på ett skalbart sätt. Jobbet kan i stället skickas till en ny beräkningsmåltyp, som kallas serverlös beräkning. Serverlös beräkning är det enklaste sättet att köra träningsjobb på Azure Machine Learning. Serverlös beräkning är en fullständigt hanterad beräkning på begäran. Azure Machine Learning skapar, skalar och hanterar beräkningen åt dig. Genom modellträning med serverlös beräkning kan maskininlärningspersonal fokusera på sina kunskaper om att skapa maskininlärningsmodeller och inte behöva lära sig mer om beräkningsinfrastruktur eller konfigurera den.

Maskininlärningspersonal kan ange de resurser som jobbet behöver. Azure Machine Learning hanterar beräkningsinfrastrukturen och ger hanterad nätverksisolering att minska belastningen på dig.

Företag kan också minska kostnaderna genom att ange optimala resurser för varje jobb. IT-administratörer kan fortfarande använda kontroll genom att ange kärnkvoter på prenumerations- och arbetsytenivå och tillämpa Azure-principer.

Serverlös beräkning kan användas för att finjustera modeller i modellkatalogen, till exempel LLAMA 2. Serverlös beräkning kan användas för att köra alla typer av jobb från Azure Machine Learning-studio, SDK och CLI. Serverlös beräkning kan också användas för att skapa miljöbilder och för ansvarsfulla AI-instrumentpanelsscenarier. Serverlösa jobb använder samma kvot som Azure Machine Learning-beräkningskvoten. Du kan välja standardnivå (dedikerad) eller virtuella datorer med låg prioritet(låg prioritet). Hanterad identitet och användaridentitet stöds för serverlösa jobb. Faktureringsmodellen är densamma som Azure Machine Learning-beräkning.

Fördelar med serverlös beräkning

  • Azure Machine Learning hanterar skapande, konfiguration, skalning, borttagning, korrigering, beräkningsinfrastruktur som minskar hanteringskostnaderna
  • Du behöver inte lära dig mer om beräkning, olika beräkningstyper och relaterade egenskaper.
  • Du behöver inte skapa kluster upprepade gånger för varje VM-storlek som behövs, med samma inställningar och replikering för varje arbetsyta.
  • Du kan optimera kostnaderna genom att ange de exakta resurser som varje jobb behöver vid körning när det gäller instanstyp (VM-storlek) och antal instanser. Du kan övervaka användningsstatistiken för jobbet för att optimera de resurser som ett jobb skulle behöva.
  • Minskning av steg som krävs för att köra ett jobb
  • Om du vill förenkla jobböverföringen ytterligare kan du hoppa över resurserna helt och hållet. Azure Machine Learning använder instansantalet som standard och väljer en instanstyp (VM-storlek) baserat på faktorer som kvot, kostnad, prestanda och diskstorlek.
  • Kortare väntetider innan jobb börjar köras i vissa fall.
  • Användaridentitet och användartilldelad hanterad identitet på arbetsytan stöds för att skicka jobb.
  • Med hanterad nätverksisolering kan du effektivisera och automatisera konfigurationen av nätverksisolering. Kundens virtuella nätverk stöds också
  • Administratörskontroll via kvot- och Azure-principer

Så här använder du serverlös beräkning

  • Du kan finjustera grundmodeller som LLAMA 2 med hjälp av notebook-filer enligt nedan:

  • När du skapar ett eget beräkningskluster använder du dess namn i kommandojobbet, till exempel compute="cpu-cluster". Med serverlös kan du hoppa över skapandet av ett beräkningskluster och utelämna parametern compute för att i stället använda serverlös beräkning. När compute inte har angetts för ett jobb körs jobbet på serverlös beräkning. Utelämna beräkningsnamnet i dina CLI- eller SDK-jobb för att använda serverlös beräkning i följande jobbtyper och om du vill ange resurser som ett jobb behöver när det gäller antal instanser och instanstyp:

    • Kommandojobb, inklusive interaktiva jobb och distribuerad utbildning
    • AutoML-jobb
    • Sopa jobb
    • Parallella jobb

  • För pipelinejobb via CLI används default_compute: azureml:serverless för standardberäkning på pipelinenivå. För pipelinejobb via SDK använder du default_compute="serverless". Ett exempel finns i Pipeline-jobb .

  • När du skickar ett träningsjobb i studio (förhandsversion) väljer du Serverlös som beräkningstyp.

  • När du använder Azure Machine Learning Designer väljer du Serverlös som standardberäkning.

  • Du kan använda serverlös beräkning för en ansvarsfull AI-instrumentpanel

Prestandaöverväganden

Serverlös beräkning kan hjälpa dig att påskynda träningen på följande sätt:

Otillräcklig kvot: När du skapar ett eget beräkningskluster ansvarar du för att ta reda på vilken VM-storlek och antal noder som ska skapas. När jobbet körs misslyckas jobbet om du inte har tillräcklig kvot för klustret. Serverlös beräkning använder information om din kvot för att välja en lämplig VM-storlek som standard.

Skala ned optimering: När ett beräkningskluster skalas ned måste ett nytt jobb vänta på att nedskalningen ska ske och sedan skalas upp innan jobbet kan köras. Med serverlös beräkning behöver du inte vänta på nedskalning och jobbet kan börja köras på ett annat kluster/nod (förutsatt att du har en kvot).

Optimering av klustrets upptagna: när ett jobb körs i ett beräkningskluster och ett annat jobb skickas placeras jobbet i kö bakom det jobb som körs. Med serverlös beräkning får du en annan nod/ett annat kluster för att börja köra jobbet (förutsatt att du har en kvot).

Kvot

När du skickar jobbet behöver du fortfarande tillräckligt med Azure Machine Learning-beräkningskvot för att kunna fortsätta (både arbetsyta och prenumerationsnivåkvot). Standardstorleken för virtuella datorer för serverlösa jobb väljs baserat på den här kvoten. Om du anger din egen vm-storlek/familj:

  • Om du har en viss kvot för den virtuella datorns storlek/familj, men inte tillräcklig kvot för antalet instanser, visas ett fel. Felet rekommenderar att du minskar antalet instanser till ett giltigt nummer baserat på din kvotgräns eller begär en kvotökning för den här virtuella datorfamiljen eller ändrar storleken på den virtuella datorn
  • Om du inte har en kvot för din angivna VM-storlek visas ett fel. Felet rekommenderar att du väljer en annan VM-storlek som du har kvot eller begärandekvot för för den här virtuella datorfamiljen
  • Om du har tillräcklig kvot för att den virtuella datorfamiljen ska kunna köra det serverlösa jobbet, men andra jobb använder kvoten, får du ett meddelande om att jobbet måste vänta i en kö tills kvoten är tillgänglig

När du visar din användning och kvot i Azure-portalen visas namnet "Serverlös" för att se all kvot som förbrukas av serverlösa jobb.

Identitetsstöd och autentiseringsuppgifter passerar genom

  • Användarens autentiseringsuppgifter passerar genom : Serverlös beräkning stöder fullständigt genomströmning av användarautentiseringsuppgifter. Användartoken för den användare som skickar jobbet används för lagringsåtkomst. Dessa autentiseringsuppgifter kommer från ditt 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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

  • Användartilldelad hanterad identitet : När du har en arbetsyta konfigurerad med användartilldelad hanterad identitet kan du använda den identiteten med det serverlösa jobbet för lagringsåtkomst.

    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)

Information om hur du kopplar användartilldelad hanterad identitet finns i bifoga användartilldelad hanterad identitet.

Konfigurera egenskaper för kommandojobb

Om inget beräkningsmål har angetts för kommando-, svep- och AutoML-jobb används beräkningen som standard för serverlös beräkning. Till exempel för det här kommandojobbet:

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)

Beräkningen är som standard serverlös beräkning med:

  • En nod för det här jobbet. Standardantalet noder baseras på typen av jobb. Se följande avsnitt för andra jobbtyper.
  • Den virtuella processordatorn, som bestäms baserat på kvot, prestanda, kostnad och diskstorlek.
  • Dedikerade virtuella datorer
  • Plats för arbetsyta

Du kan åsidosätta dessa standardvärden. Om du vill ange vm-typ eller antal noder för serverlös beräkning lägger du till resources i jobbet:

  • instance_type för att välja en specifik virtuell dator. Använd den här parametern om du vill ha en specifik CPU/GPU VM-storlek

  • instance_count för att ange antalet noder.

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

  • Om du vill ändra jobbnivå använder du queue_settings för att välja mellan dedikerade virtuella datorer (job_tier: Standard) och låg prioritet(jobtier: 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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    queue_settings={
      "job_tier": "spot"  
    }
)
# submit the command job
ml_client.create_or_update(job)

Exempel för alla fält med kommandojobb

Här är ett exempel på alla fält som anges, inklusive identitet som jobbet ska använda. Du behöver inte ange inställningar för virtuella nätverk som arbetsytenivå hanterad nätverksisolering används automatiskt.

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)

Visa fler exempel på träning med serverlös beräkning på:-

AutoML-jobb

Du behöver inte ange beräkning för AutoML-jobb. Du kan också ange resurser. Om antalet instanser inte anges är det standard baserat på parametrarna max_concurrent_trials och max_nodes. Om du skickar en AutoML-bildklassificering eller NLP-uppgift utan instanstyp väljs storleken på den virtuella GPU-datorn automatiskt. Det går att skicka AutoML-jobb via CLIs, SDK eller Studio. Om du vill skicka AutoML-jobb med serverlös beräkning i studio aktiverar du först funktionen skicka ett träningsjobb i studio (förhandsversion) i förhandsgranskningspanelen.

Om du vill ange typen eller antalet instanser använder du ResourceConfiguration klassen.

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

Pipelinejobb

För ett pipelinejobb anger du "serverless" som standard beräkningstyp att använda serverlös beräkning.

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

Du kan också ange serverlös beräkning som standardberäkning i Designer.

Nästa steg

Visa fler exempel på träning med serverlös beräkning på:-