Träna modeller med Azure Machine Learning Python SDK (v1)

GÄLLER FÖR: Python SDK azureml v1

Lär dig hur du kopplar Azure-beräkningsresurser till din Azure Mašinsko učenje-arbetsyta med SDK v1. Sedan kan du använda dessa resurser som tränings- och slutsatsdragningsberäkningsmål i dina maskininlärningsuppgifter.

I den här artikeln får du lära dig hur du konfigurerar arbetsytan så att den använder dessa beräkningsresurser:

• Din lokala dator
• Virtuella fjärrdatorer
• Apache Spark-pooler (drivs av Azure Synapse Analytics)
• Azure HDInsight
• Azure Batch
• Azure Databricks – används endast som träningsberäkningsmål i maskininlärningspipelines
• Azure Data Lake Analytics
• Azure Container Instance
• Azure Mašinsko učenje Kubernetes

Information om hur du använder beräkningsmål som hanteras av Azure Mašinsko učenje finns i:

• Azure Mašinsko učenje beräkningsinstans
• Azure Mašinsko učenje beräkningskluster
• Azure Kubernetes Service-kluster

Förutsättningar

• En Azure Machine Learning-arbetsyta. Mer information finns i Skapa arbetsyteresurser.

• Azure CLI-tillägget för Mašinsko učenje-tjänsten, Azure Mašinsko učenje Python SDK eller Tillägget Azure Mašinsko učenje Visual Studio Code.

Begränsningar

• Skapa inte flera samtidiga bifogade filer till samma beräkning från din arbetsyta. Du kan till exempel koppla ett Azure Kubernetes Service-kluster till en arbetsyta med två olika namn. Varje ny bifogad fil bryter de tidigare befintliga bifogade filerna.

  Om du vill koppla om ett beräkningsmål, till exempel för att ändra TLS eller annan konfigurationsinställning för klustret, måste du först ta bort den befintliga bifogade filen.

Vad är ett beräkningsmål?

Med Azure Mašinsko učenje kan du träna din modell på olika resurser eller miljöer, som tillsammans kallas beräkningsmål. Ett beräkningsmål kan vara en lokal dator eller en molnresurs, till exempel en Azure Mašinsko učenje Compute, Azure HDInsight eller en virtuell fjärrdator. Du använder också beräkningsmål för modelldistribution enligt beskrivningen i "Var och hur du distribuerar dina modeller".

Lokal dator

När du använder den lokala datorn för träning behöver du inte skapa ett beräkningsmål. Skicka bara träningskörningen från den lokala datorn.

När du använder den lokala datorn för slutsatsdragning måste du ha Docker installerat. Om du vill utföra distributionen använder du LocalWebservice.deploy_configuration() för att definiera den port som webbtjänsten ska använda. Använd sedan den normala distributionsprocessen enligt beskrivningen i Distribuera modeller med Azure Mašinsko učenje.

Virtuella fjärrdatorer

Azure Mašinsko učenje har också stöd för att ansluta en virtuell Azure-dator. Den virtuella datorn måste vara en Azure Data Science Virtual Machine (DSVM). Den virtuella datorn erbjuder ett kuraterat urval av verktyg och ramverk för maskininlärningsutveckling i hela livscykeln. Mer information om hur du använder DSVM med Azure Mašinsko učenje finns i Konfigurera en utvecklingsmiljö.

1. Skapa: Azure Mašinsko učenje kan inte skapa en fjärransluten virtuell dator åt dig. I stället måste du skapa den virtuella datorn och sedan koppla den till din Azure Mašinsko učenje-arbetsyta. Information om hur du skapar en DSVM finns i Etablera Data Science Virtual Machine for Linux (Ubuntu).

   Varning

   Azure Mašinsko učenje stöder endast virtuella datorer som kör Ubuntu. När du skapar en virtuell dator eller väljer en befintlig virtuell dator måste du välja en virtuell dator som använder Ubuntu.

   Azure Machine Learning kräver också att den virtuella datorn har en offentlig IP-adress.

2. Bifoga: Koppla DSVM till din arbetsyta med Hjälp av Azure Mašinsko učenje Studio.

   Varning

   Skapa inte flera samtidiga bifogade filer till samma DSVM från din arbetsyta. Varje ny bifogad fil bryter de tidigare befintliga bifogade filerna.

3. Konfigurera: Skapa en körningskonfiguration för DSVM-beräkningsmålet. Docker och conda används för att skapa och konfigurera träningsmiljön på DSVM.

   from azureml.core import ScriptRunConfig
   from azureml.core.environment import Environment
   from azureml.core.conda_dependencies import CondaDependencies
   
   # Create environment
   myenv = Environment(name="myenv")
   
   # Specify the conda dependencies
   myenv.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'])
   
   # If no base image is explicitly specified the default CPU image "azureml.core.runconfig.DEFAULT_CPU_IMAGE" will be used
   # To use GPU in DSVM, you should specify the default GPU base Docker image or another GPU-enabled image:
   # myenv.docker.enabled = True
   # myenv.docker.base_image = azureml.core.runconfig.DEFAULT_GPU_IMAGE
   
   # Configure the run configuration with the Linux DSVM as the compute target and the environment defined above
   src = ScriptRunConfig(source_directory=".", script="train.py", compute_target=compute, environment=myenv) 
   

Apache Spark-pooler

Med Azure Synapse Analytics-integreringen med Azure Mašinsko učenje (förhandsversion) kan du bifoga en Apache Spark-pool som backas upp av Azure Synapse för interaktiv datautforskning och förberedelse. Med den här integreringen kan du ha en dedikerad beräkning för dataomvandling i stor skala. Mer information finns i Så här kopplar du Apache Spark-pooler som drivs av Azure Synapse Analytics.

Azure HDInsight

Azure HDInsight är en populär plattform för stordataanalys. Plattformen tillhandahåller Apache Spark, som kan användas för att träna din modell.

1. Skapa: Azure Mašinsko učenje kan inte skapa ett HDInsight-kluster åt dig. Istället måste du skapa klustret och sedan koppla det till din Azure Machine Learning-arbetsyta. Mer information finns i Skapa ett Spark-kluster i HDInsight.

   Varning

   Azure Machine Learning kräver att HDInsight-klustret har en offentlig IP-adress.

   När du skapar klustret måste du ange ett SSH-användarnamn och lösenord. Anteckna dessa värden eftersom du behöver dem för att använda HDInsight som beräkningsmål.

   När klustret har skapats ansluter du till det med värdnamnet <clustername-ssh.azurehdinsight.net>, där <clustername> är det namn som du angav för klustret.

2. Bifoga: Koppla HDInsight-klustret till din arbetsyta med Hjälp av Azure Mašinsko učenje Studio.

   Varning

   Skapa inte flera samtidiga bifogade filer till samma HDInsight från din arbetsyta. Varje ny bifogad fil bryter de tidigare befintliga bifogade filerna.

3. Konfigurera: Skapa en körningskonfiguration för HDI-beräkningsmålet.

   from azureml.core.runconfig import RunConfiguration
   from azureml.core.conda_dependencies import CondaDependencies
   
   
   # use pyspark framework
   run_hdi = RunConfiguration(framework="pyspark")
   
   # Set compute target to the HDI cluster
   run_hdi.target = hdi_compute.name
   
   # specify CondaDependencies object to ask system installing numpy
   cd = CondaDependencies()
   cd.add_conda_package('numpy')
   run_hdi.environment.python.conda_dependencies = cd
   

Azure Batch

Azure Batch används för att effektivt köra storskaliga parallella och högpresterande databehandlingsprogram (HPC) i molnet. AzureBatchStep kan användas i en Azure Mašinsko učenje Pipeline för att skicka jobb till en Azure Batch-pool med datorer.

Om du vill koppla Azure Batch som beräkningsmål måste du använda Azure Mašinsko učenje SDK och ange följande information:

• Azure Batch-beräkningsnamn: Ett eget namn som ska användas för beräkningen på arbetsytan
• Azure Batch-kontonamn: Namnet på Azure Batch-kontot
• Resursgrupp: Resursgruppen som innehåller Azure Batch-kontot.

Följande kod visar hur du kopplar Azure Batch som beräkningsmål:

from azureml.core.compute import ComputeTarget, BatchCompute
from azureml.exceptions import ComputeTargetException

# Name to associate with new compute in workspace
batch_compute_name = 'mybatchcompute'

# Batch account details needed to attach as compute to workspace
batch_account_name = "<batch_account_name>"  # Name of the Batch account
# Name of the resource group which contains this account
batch_resource_group = "<batch_resource_group>"

try:
    # check if the compute is already attached
    batch_compute = BatchCompute(ws, batch_compute_name)
except ComputeTargetException:
    print('Attaching Batch compute...')
    provisioning_config = BatchCompute.attach_configuration(
        resource_group=batch_resource_group, account_name=batch_account_name)
    batch_compute = ComputeTarget.attach(
        ws, batch_compute_name, provisioning_config)
    batch_compute.wait_for_completion()
    print("Provisioning state:{}".format(batch_compute.provisioning_state))
    print("Provisioning errors:{}".format(batch_compute.provisioning_errors))

print("Using Batch compute:{}".format(batch_compute.cluster_resource_id))

Azure Databricks

Azure Databricks är en Apache Spark-baserad miljö i Azure-molnet. Det kan användas som beräkningsmål med en Azure Machine Learning-pipeline.

Om du vill bifoga Azure Databricks som beräkningsmål anger du följande information:

• Databricks-beräkningsnamn: Det namn som du vill tilldela till den här beräkningsresursen.
• Databricks-arbetsytans namn: Namnet på Azure Databricks-arbetsytan.
• Databricks-åtkomsttoken: Åtkomsttoken som används för att autentisera till Azure Databricks. Information om hur du genererar en åtkomsttoken finns i dokumentet Autentisering .

Följande kod visar hur du bifogar Azure Databricks som beräkningsmål med Azure Mašinsko učenje SDK:

import os
from azureml.core.compute import ComputeTarget, DatabricksCompute
from azureml.exceptions import ComputeTargetException

databricks_compute_name = os.environ.get(
    "AML_DATABRICKS_COMPUTE_NAME", "<databricks_compute_name>")
databricks_workspace_name = os.environ.get(
    "AML_DATABRICKS_WORKSPACE", "<databricks_workspace_name>")
databricks_resource_group = os.environ.get(
    "AML_DATABRICKS_RESOURCE_GROUP", "<databricks_resource_group>")
databricks_access_token = os.environ.get(
    "AML_DATABRICKS_ACCESS_TOKEN", "<databricks_access_token>")

try:
    databricks_compute = ComputeTarget(
        workspace=ws, name=databricks_compute_name)
    print('Compute target already exists')
except ComputeTargetException:
    print('compute not found')
    print('databricks_compute_name {}'.format(databricks_compute_name))
    print('databricks_workspace_name {}'.format(databricks_workspace_name))
    print('databricks_access_token {}'.format(databricks_access_token))

    # Create attach config
    attach_config = DatabricksCompute.attach_configuration(resource_group=databricks_resource_group,
                                                           workspace_name=databricks_workspace_name,
                                                           access_token=databricks_access_token)
    databricks_compute = ComputeTarget.attach(
        ws,
        databricks_compute_name,
        attach_config
    )

    databricks_compute.wait_for_completion(True)

Ett mer detaljerat exempel finns i ett exempel på en notebook-fil på GitHub.

Azure Data Lake Analytics

Azure Data Lake Analytics är en plattform för stordataanalys i Azure-molnet. Det kan användas som beräkningsmål med en Azure Machine Learning-pipeline.

Skapa ett Azure Data Lake Analytics-konto innan du använder det. Information om hur du skapar den här resursen finns i dokumentet Komma igång med Azure Data Lake Analytics.

Om du vill bifoga Data Lake Analytics som beräkningsmål måste du använda Azure Mašinsko učenje SDK och ange följande information:

• Beräkningsnamn: Det namn som du vill tilldela till den här beräkningsresursen.
• Resursgrupp: Resursgruppen som innehåller Data Lake Analytics-kontot.
• Kontonamn: Data Lake Analytics-kontonamnet.

Följande kod visar hur du bifogar Data Lake Analytics som beräkningsmål:

import os
from azureml.core.compute import ComputeTarget, AdlaCompute
from azureml.exceptions import ComputeTargetException


adla_compute_name = os.environ.get(
    "AML_ADLA_COMPUTE_NAME", "<adla_compute_name>")
adla_resource_group = os.environ.get(
    "AML_ADLA_RESOURCE_GROUP", "<adla_resource_group>")
adla_account_name = os.environ.get(
    "AML_ADLA_ACCOUNT_NAME", "<adla_account_name>")

try:
    adla_compute = ComputeTarget(workspace=ws, name=adla_compute_name)
    print('Compute target already exists')
except ComputeTargetException:
    print('compute not found')
    print('adla_compute_name {}'.format(adla_compute_name))
    print('adla_resource_id {}'.format(adla_resource_group))
    print('adla_account_name {}'.format(adla_account_name))
    # create attach config
    attach_config = AdlaCompute.attach_configuration(resource_group=adla_resource_group,
                                                     account_name=adla_account_name)
    # Attach ADLA
    adla_compute = ComputeTarget.attach(
        ws,
        adla_compute_name,
        attach_config
    )

    adla_compute.wait_for_completion(True)

Ett mer detaljerat exempel finns i ett exempel på en notebook-fil på GitHub.

Azure Container Instance

Azure Container Instances (ACI) skapas dynamiskt när du distribuerar en modell. Du kan inte skapa eller koppla ACI till din arbetsyta på något annat sätt. Mer information finns i Distribuera en modell till Azure Container Instances.

Kubernetes

Med Azure Mašinsko učenje kan du koppla egna Kubernetes-kluster för träning och slutsatsdragning. Se Konfigurera Kubernetes-kluster för Azure Mašinsko učenje.

Om du vill koppla från ett Kubernetes-kluster från arbetsytan använder du följande metod:

compute_target.detach()

Notebook-exempel

Se de här notebook-filerna för exempel på träning med olika beräkningsmål:

• how-to-use-azureml/training
• tutorials/img-classification-part1-training.ipynb

Lär dig att köra notebook-filer genom att följa artikeln Använda Jupyter-notebooks till att utforska tjänsten.

Nästa steg

• Använd beräkningsresursen för att konfigurera och skicka en träningskörning.
• Självstudie: Träna och distribuera en modell använder ett hanterat beräkningsmål för att träna en modell.
• Lär dig hur du effektivt justerar hyperparametrar för att skapa bättre modeller.
• När du har en tränad modell får du lära dig hur och var du distribuerar modeller.
• Använda Azure Mašinsko učenje med Virtuella Azure-nätverk