Skapa och hantera instanstyper för effektiv användning av beräkningsresurser

Instanstyper är ett Azure Machine Learning-koncept som gör det möjligt att rikta in sig på vissa typer av beräkningsnoder för tränings- och slutsatsdragningsarbetsbelastningar. På en virtuell Azure-dator är STANDARD_D2_V3till exempel en instanstyp . I den här artikeln får du lära dig hur du skapar och hanterar instanstyper för dina beräkningskrav.

I Kubernetes-kluster representeras instanstyper i en anpassad resursdefinition (CRD) som är installerad med Azure Machine Learning-tillägget. Två element i Azure Machine Learning-tillägget representerar instanstyperna:

• Använd nodeSelector för att ange vilken nod en podd ska köras på. Noden måste ha en motsvarande etikett.
• I avsnittet resurser kan du ange beräkningsresurserna (CPU, minne och NVIDIA GPU) för podden.

Om du anger ett nodeSelector-fält när du distribuerar Azure Machine Learning-tillägget tillämpas fältet nodeSelector på alla instanstyper. Detta innebär att:

• För varje instanstyp som du skapar ska det angivna nodeSelector fältet vara en delmängd av det angivna nodeSelector fältet för tillägget.
• Om du använder en instanstyp med nodeSelectorkörs arbetsbelastningen på alla noder som matchar både det angivna nodeSelector fältet för tillägg och det angivna nodeSelector fältet av instanstyp.
• Om du använder en instanstyp utan fält nodeSelector körs arbetsbelastningen på alla noder som matchar det angivna nodeSelector fältet för tillägg.

Skapa en standardinstanstyp

Som standard skapas en instanstyp som heter defaultinstancetype när du kopplar ett Kubernetes-kluster till en Azure Machine Learning-arbetsyta. Här är definitionen:

resources:
  requests:
    cpu: "100m"
    memory: "2Gi"
  limits:
    cpu: "2"
    memory: "2Gi"
    nvidia.com/gpu: null

Om du inte använder ett nodeSelector fält kan podden schemaläggas på valfri nod. Arbetsbelastningens poddar tilldelas standardresurser med 0,1 CPU-kärnor, 2 GB minne och 0 GPU:er för begäran. De resurser som arbetsbelastningens poddar använder är begränsade till 2 CPU-kärnor och 8 GB minne.

Standardinstanstypen använder avsiktligt få resurser. För att säkerställa att alla maskininlärningsarbetsbelastningar körs med lämpliga resurser (till exempel GPU-resurs) rekommenderar vi starkt att du skapar anpassade instanstyper.

Tänk på följande punkter om standardinstanstypen:

• defaultinstancetype visas inte som en InstanceType anpassad resurs i klustret när du kör kommandot kubectl get instancetype, men det visas i alla klienter (UI, Azure CLI, SDK).
• defaultinstancetype kan åsidosättas med definitionen av en anpassad instanstyp som har samma namn.

Skapa en anpassad instanstyp

Skapa en ny instanstyp genom att skapa en ny anpassad resurs för instanstypen CRD. Till exempel:

kubectl apply -f my_instance_type.yaml

Här är innehållet i my_instance_type.yaml:

apiVersion: amlarc.azureml.com/v1alpha1
kind: InstanceType
metadata:
  name: myinstancetypename
spec:
  nodeSelector:
    mylabel: mylabelvalue
  resources:
    limits:
      cpu: "1"
      nvidia.com/gpu: 1
      memory: "2Gi"
    requests:
      cpu: "700m"
      memory: "1500Mi"

Föregående kod skapar en instanstyp med det märkta beteendet:

• Poddar schemaläggs endast på noder som har etiketten mylabel: mylabelvalue.
• Poddar tilldelas resursbegäranden 700m för cpu och 1500Mi minne.
• Poddar tilldelas resursgränser 1 för cpu, 2Gi minne och 1 NVIDIA GPU.

Skapande av anpassade instanstyper måste uppfylla följande parametrar och definitionsregler, annars misslyckas det:

Det går också att skapa flera instanstyper samtidigt:

kubectl apply -f my_instance_type_list.yaml

Här är innehållet i my_instance_type_list.yaml:

apiVersion: amlarc.azureml.com/v1alpha1
kind: InstanceTypeList
items:
  - metadata:
      name: cpusmall
    spec:
      resources:
        requests:
          cpu: "100m"
          memory: "100Mi"
        limits:
          cpu: "1"
          nvidia.com/gpu: 0
          memory: "1Gi"

  - metadata:
      name: defaultinstancetype
    spec:
      resources:
        requests:
          cpu: "1"
          memory: "1Gi" 
        limits:
          cpu: "1"
          nvidia.com/gpu: 0
          memory: "1Gi"

I föregående exempel skapas två instanstyper: cpusmall och defaultinstancetype. Den här defaultinstancetype definitionen åsidosätter definitionen defaultinstancetype som skapades när du kopplade Kubernetes-klustret till Azure Machine Learning-arbetsytan.

Om du skickar en tränings- eller slutsatsarbetsbelastning utan instanstyp använder defaultinstancetypeden . Om du vill ange en standardinstanstyp för ett Kubernetes-kluster skapar du en instanstyp med namnet defaultinstancetype. Den identifieras automatiskt som standard.

Välj en instanstyp för att skicka ett träningsjobb

command: python -c "print('Hello world!')"
environment:
  image: library/python:latest
compute: azureml:<Kubernetes-compute_target_name>
resources:
  instance_type: <instance type name>

from azure.ai.ml import command

# define the command
command_job = command(
    command="python -c "print('Hello world!')"",
    environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
    compute="<Kubernetes-compute_target_name>",
    instance_type="<instance type name>"
)

I föregående exempel ersätter du <Kubernetes-compute_target_name> med namnet på ditt Kubernetes-beräkningsmål. Ersätt <instance type name> med namnet på den instanstyp som du vill välja. Om du inte anger en instance_type egenskap använder defaultinstancetype systemet för att skicka jobbet.

Välj en instanstyp för att distribuera en modell

name: blue
app_insights_enabled: true
endpoint_name: <endpoint name>
model: 
  path: ./model/sklearn_mnist_model.pkl
code_configuration:
  code: ./script/
  scoring_script: score.py
instance_type: <instance type name>
environment: 
  conda_file: file:./model/conda.yml
  image: mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest

from azure.ai.ml import KubernetesOnlineDeployment,Model,Environment,CodeConfiguration

model = Model(path="./model/sklearn_mnist_model.pkl")
env = Environment(
    conda_file="./model/conda.yml",
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)

# define the deployment
blue_deployment = KubernetesOnlineDeployment(
    name="blue",
    endpoint_name="<endpoint name>",
    model=model,
    environment=env,
    code_configuration=CodeConfiguration(
        code="./script/", scoring_script="score.py"
    ),
    instance_count=1,
    instance_type="<instance type name>",
)

I föregående exempel ersätter <instance type name> du med namnet på den instanstyp som du vill välja. Om du inte anger en instance_type egenskap använder defaultinstancetype systemet för att distribuera modellen.

Verifiering av resursavsnitt

Du kan använda avsnittet resources för att definiera resursbegäran och gränsen för dina modelldistributioner. Till exempel:

name: blue
app_insights_enabled: true
endpoint_name: <endpoint name>
model: 
  path: ./model/sklearn_mnist_model.pkl
code_configuration:
  code: ./script/
  scoring_script: score.py
environment: 
  conda_file: file:./model/conda.yml
  image: mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest
resources:
  requests:
    cpu: "0.1"
    memory: "0.2Gi"
  limits:
    cpu: "0.2"
    #nvidia.com/gpu: 0
    memory: "0.5Gi"
instance_type: <instance type name>

from azure.ai.ml import (
    KubernetesOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
    ResourceSettings,
    ResourceRequirementsSettings
)

model = Model(path="./model/sklearn_mnist_model.pkl")
env = Environment(
    conda_file="./model/conda.yml",
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)

requests = ResourceSettings(cpu="0.1", memory="0.2G")
limits = ResourceSettings(cpu="0.2", memory="0.5G", nvidia_gpu="1")
resources = ResourceRequirementsSettings(requests=requests, limits=limits)

# define the deployment
blue_deployment = KubernetesOnlineDeployment(
    name="blue",
    endpoint_name="<endpoint name>",
    model=model,
    environment=env,
    code_configuration=CodeConfiguration(
        code="./script/", scoring_script="score.py"
    ),
    resources=resources,
    instance_count=1,
    instance_type="<instance type name>",
)

Om du använder avsnittet resources måste en giltig resursdefinition uppfylla följande regler. En ogiltig resursdefinition gör att modelldistributionen misslyckas.

Instanstypen krävs för modelldistribution. Om du har definierat avsnittet resources och det verifieras mot instanstypen är reglerna följande:

• Med en giltig resource avsnittsdefinition måste resursgränserna vara mindre än instanstypens gränser. Annars misslyckas distributionen.
• Om du inte definierar en instanstyp använder defaultinstancetype systemet för validering med avsnittet resources .
• Om du inte definierar resources avsnittet använder systemet instanstypen för att skapa distributionen.

Nästa steg

• Azure Machine Learning-slutsatsdragningsrouter och anslutningskrav
• Skydda Azure Kubernetes Service-inferensmiljön