Share via

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

  • Artikel

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 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 Machine Learning Kubernetes

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

Viktigt!

Objekt i den här artikeln som har markerats som "förhandsversion" finns för närvarande i offentlig förhandsversion. Förhandsversionen tillhandahålls utan ett serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

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 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 Machine Learning.

Virtuella fjärrdatorer

Azure Machine Learning 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 Machine Learning finns i Konfigurera en utvecklingsmiljö.

Dricks

Istället för en virtuell fjärrdator 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äkningsinstanser.

  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 Datavetenskap Virtual Machine for 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 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)

Dricks

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-portalen, CLI eller SDK för virtuella Azure-datorer.

Apache Spark-pooler

Med Azure Synapse Analytics-integreringen med Azure Machine Learning (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 Machine Learning 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: 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

Dricks

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 det manuellt med hjälp av Azure-portalen, 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ä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))

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. Istä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öra ett Spark-jobb i Azure Databricks.

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

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 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 ett exempel på en notebook-fil 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 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 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-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.

Varning

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

Dricks

Azure Machine Learning-pipelines kan bara fungera med data som lagras i standarddatalagret för Data Lake Analytics-kontot. Om de data 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 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 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

När 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

Se de här notebook-filerna för 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