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 Machine Learning-arbetsyta med SDK v1. Sedan kan du använda dessa resurser som tränings- och slutsatsdragningsmål i dina maskininlärningsuppgifter.

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

  • Din lokala dator
  • Fjärranslutna virtuella datorer
  • 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-instans
  • Azure Machine Learning Kubernetes

Information om hur du använder beräkningsmål som hanteras av Azure Machine Learning finns i:

Förutsättningar

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 Machine Learning 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 Machine Learning Compute, Azure HDInsight eller en fjärransluten virtuell dator. 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 din lokala dator 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. För att 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 Machine Learning.

Fjärranslutna virtuella datorer

Azure Machine Learning stöder även anslutning av 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 Machine Learning finns i Konfigurera en utvecklingsmiljö.

Tips

I stället för en fjärransluten virtuell dator rekommenderar vi att du använder Azure Machine Learning-beräkningsinstansen. Det är en fullständigt hanterad, molnbaserad beräkningslösning som är specifik för Azure Machine Learning. Mer information finns i Skapa och hantera Azure Machine Learning-beräkningsinstans.

  1. Skapa: Azure Machine Learning 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 Machine Learning-arbetsyta. Information om hur du skapar en DSVM finns i Etablera Data Science Virtual Machine för Linux (Ubuntu).

    Varning

    Azure Machine Learning 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: Om du vill koppla en befintlig virtuell dator som beräkningsmål måste du ange resurs-ID, användarnamn och lösenord för den virtuella datorn. Resurs-ID:t för den virtuella datorn kan konstrueras med hjälp av prenumerations-ID, resursgruppsnamn och VM-namn med följande strängformat: /subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.Compute/virtualMachines/<vm_name>

    from azureml.core.compute import RemoteCompute, ComputeTarget
    
    # Create the compute config 
    compute_target_name = "attach-dsvm"
    
    attach_config = RemoteCompute.attach_configuration(resource_id='<resource_id>',
                                                    ssh_port=22,
                                                    username='<username>',
                                                    password="<password>")
    
    # Attach the compute
    compute = ComputeTarget.attach(ws, compute_target_name, attach_config)
    
    compute.wait_for_completion(show_output=True)
    

    Eller så kan du koppla DSVM till din arbetsyta med hjälp av Azure Machine Learning-studio.

    Varning

    Skapa inte flera samtidiga bifogade filer till samma DSVM från arbetsytan. 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) 
    

Tips

Om du vill ta bort (koppla bort) en virtuell dator från arbetsytan använder du metoden RemoteCompute.detach().

Azure Machine Learning tar inte bort den virtuella datorn åt dig. Du måste ta bort den virtuella datorn manuellt med hjälp av Azure Portal, CLI eller SDK för virtuella Azure-datorer.

Apache Spark-pooler

Med Azure Synapse Analytics-integrering med Azure Machine Learning (förhandsversion) kan du ansluta 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 Machine Learning kan inte skapa ett HDInsight-kluster åt dig. I stä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 <klusternamn> är det namn som du angav för klustret.

  2. Bifoga: Om du vill koppla ett HDInsight-kluster som beräkningsmål måste du ange resurs-ID, användarnamn och lösenord för HDInsight-klustret. Resurs-ID:t för HDInsight-klustret kan konstrueras med hjälp av prenumerations-ID, resursgruppsnamn och HDInsight-klusternamn med följande strängformat: /subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.HDInsight/clusters/<cluster_name>

    from azureml.core.compute import ComputeTarget, HDInsightCompute
    from azureml.exceptions import ComputeTargetException
    
    try:
    # if you want to connect using SSH key instead of username/password you can provide parameters private_key_file and private_key_passphrase
    
    attach_config = HDInsightCompute.attach_configuration(resource_id='<resource_id>',
                                                          ssh_port=22, 
                                                          username='<ssh-username>', 
                                                          password='<ssh-pwd>')
    hdi_compute = ComputeTarget.attach(workspace=ws, 
                                       name='myhdi', 
                                       attach_configuration=attach_config)
    
    except ComputeTargetException as e:
    print("Caught = {}".format(e.message))
    
    hdi_compute.wait_for_completion(show_output=True)
    

    Eller så kan du koppla HDInsight-klustret till din arbetsyta med hjälp av Azure Machine Learning-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
    

Tips

Om du vill ta bort (koppla från) ett HDInsight-kluster från arbetsytan använder du metoden HDInsightCompute.detach().

Azure Machine Learning tar inte bort HDInsight-klustret åt dig. Du måste ta bort den manuellt med hjälp av Azure Portal, CLI eller SDK för Azure HDInsight.

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 Machine Learning 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 Machine Learning SDK och ange följande information:

  • Azure Batch beräkningsnamn: Ett eget namn som ska användas för beräkning på arbetsytan
  • Azure Batch kontonamn: Namnet på det 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))

Varning

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

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.

Viktigt

Azure Machine Learning kan inte skapa ett Azure Databricks-beräkningsmål. I stället måste du skapa en Azure Databricks-arbetsyta och sedan koppla den till din Azure Machine Learning-arbetsyta. Information om hur du skapar en arbetsyteresurs finns i dokumentet Kör ett Spark-jobb på Azure Databricks .

Om du vill koppla en Azure Databricks-arbetsyta från en annan Azure-prenumeration måste du (ditt Azure AD-konto) beviljas rollen Deltagare på Azure Databricks-arbetsytan. Kontrollera din åtkomst i Azure Portal.

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

  • Databricks-beräkningsnamn: Det namn som du vill tilldela den här beräkningsresursen.
  • Databricks-arbetsytans namn: Namnet på Azure Databricks-arbetsytan.
  • Databricks-åtkomsttoken: Den å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 kopplar Azure Databricks som beräkningsmål med Azure Machine Learning 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 en exempelanteckningsbok på GitHub.

Varning

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

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 Kom igång med Azure Data Lake Analytics.

Om du vill koppla Data Lake Analytics som beräkningsmål måste du använda Azure Machine Learning 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 kontonamn.

Följande kod visar hur du kopplar 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 en exempelanteckningsbok på GitHub.

Varning

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

Tips

Azure Machine Learning-pipelines kan bara fungera med data som lagras i standarddatalagret för Data Lake Analytics-kontot. Om de data som du behöver arbeta med finns i ett icke-standardlager kan du använda en DataTransferStep för att kopiera data före träningen.

Azure Container-instans

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 Machine Learning kan du koppla dina egna Kubernetes-kluster för träning och slutsatsdragning. Se Konfigurera Kubernetes-kluster för Azure Machine Learning.

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

compute_target.detach()

Varning

Om du kopplar från ett kluster tas inte klustret bort. Information om hur du tar bort ett Azure Kubernetes Service kluster finns i Använda Azure CLI med AKS. Information om hur du tar bort ett Azure Arc-aktiverat Kubernetes-kluster finns i Snabbstart för Azure Arc.

Notebook-exempel

I de här notebook-filerna finns exempel på träning med olika beräkningsmål:

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