Vad är Azure Machine Learning-SDK för Python?

  • Artikel

Dataforskare och AI-utvecklare använder Azure Machine Learning SDK för Python för att skapa och köra maskininlärningsarbetsflöden med Azure Machine Learning-tjänsten. Du kan interagera med tjänsten i valfri Python-miljö, inklusive Jupyter Notebooks, Visual Studio Code eller valfri Python IDE.

Huvuddelar i SDK:n:

  • Utforska, förbered och hantera livscykeln för dina datauppsättningar som används i Machine Learning-experiment.
  • Hantera molnresurser för övervakning, loggning och organisering av Machine Learning-experiment.
  • Träna modeller, antingen lokalt eller med hjälp av molnresurser, inklusive GPU-accelererad modellträning.
  • Använd automatiserad maskininlärning, som accepterar konfigurationsparametrar och träningsdata. Funktionen itererar automatiskt igenom algoritmer och hyperparameterinställningar för att hitta den bästa modellen för att köra förutsägelser.
  • Distribuera webbtjänster för att konvertera dina inlärda modeller till RESTful-tjänster som kan användas i alla program.

En stegvis genomgång som hjälper dig att komma igång finns i den här självstudien.

Följande avsnitt visar översikter över några av de viktigaste klasserna i SDK:n, och vanliga designmönster för hur du kan använda dem. Information om hur du hämtar SDK:n finns i installationsguiden.

Stabila och experimentella versioner

Azure Machine Learning SDK för Python innehåller både stabila och experimentella funktioner i samma SDK.

Funktions-/funktionsstatus Description
Stabila funktioner Produktionsklar

Dessa funktioner rekommenderas för de flesta användningsfall och produktionsmiljöer. De uppdateras mindre ofta än experimentella funktioner.
Experimentella funktioner Utvecklings

Dessa funktioner är nyutvecklade funktioner & uppdateringar som kanske inte är klara eller fullständigt testade för produktionsanvändning. Även om funktionerna vanligtvis fungerar kan de innehålla vissa icke-bakåtkompatibla ändringar. Experimentella funktioner används för att lösa SDK-fel och får endast uppdateringar under hela testperioden. Experimentella funktioner kallas även för funktioner som är i förhandsversion.

Som namnet anger är experimentella funktioner (förhandsversion) för experimentering och anses inte vara buggfria eller stabila. Därför rekommenderar vi bara experimentella funktioner till avancerade användare som vill testa tidiga versioner av funktioner och uppdateringar och som har för avsikt att delta i rapporteringen av buggar och problem.

Experimentella funktioner är märkta med ett anteckningsavsnitt i SDK-referensen och betecknas med text som (förhandsversion) i Azure Machine Learning-dokumentationen.

Arbetsyta

Namnområde: azureml.core.workspace.Workspace

Klassen Workspace är en grundläggande resurs i det moln som du använder för att experimentera, träna och distribuera maskininlärningsmodeller. Den binder din Azure-prenumeration och resursgrupp till ett objekt som är enkelt att använda.

Visa alla parametrar i metoden create Workspace för att återanvända befintliga instanser (Storage, Key Vault, App-Insights och Azure Container Registry-ACR) samt ändra ytterligare inställningar, till exempel konfiguration av privata slutpunkter och beräkningsmål.

Importera klassen och skapa en ny arbetsyta med hjälp av följande kod. Ange create_resource_group till False om du redan har en Azure-resursgrupp som du vill använda för arbetsytan. Vissa funktioner kan fråga efter Azure-autentiseringsuppgifter.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Använd samma arbetsyta i flera miljöer genom att först skriva den till en JSON-konfigurationsfil. Detta sparar information om prenumerationen, resursen och arbetsytenamnet.

ws.write_config(path="./file-path", file_name="ws_config.json")

Läs in din arbetsyta genom att läsa konfigurationsfilen.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Du kan också använda den statiska metoden get() till att läsa in en befintlig arbetsyta utan att använda konfigurationsfiler.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

Variabeln ws representerar ett Workspace-objekt i följande kodexempel.

Experiment

Namnområde: azureml.core.experiment.Experiment

Klassen Experiment är en annan grundläggande molnresurs som representerar en samling av provkörningar (enskilda modellkörningar). Följande kod hämtar ett Experiment-objekt inifrån Workspace efter namn, eller skapar ett nytt Experiment-objekt om namnet inte finns.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Kör följande kod för att hämta en lista över alla Experiment-objekt som finns i Workspace.

list_experiments = Experiment.list(ws)

Använd funktionen get_runs för att hämta en lista över Run-objekt (provkörningar) från Experiment. Följande kod hämtar körningarna och skriver ut varje körnings-ID.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Det finns två sätt att köra en experimentell provkörning. Om du experimenterar interaktivt i en Jupyter-anteckningsbok använder du funktionen start_logging. Om du skickar ett experiment från en vanlig Python-miljö använder du funktionen submit. Båda funktionerna returnerar ett Run-objekt. Variabeln experiment representerar ett Experiment-objekt i följande kodexempel.

Kör

Namnområde: azureml.core.run.Run

En körning representerar en enda provkörning av ett experiment. Run är det objekt som du använder för att övervaka den asynkrona provkörningen, lagra utdata för provkörningen, analysera resultat och komma åt genererade artefakter. Du kan använda Run inuti din experimentkod för att logga mått och artefakter till tjänsten för körningshistorik. Funktionerna omfattar:

  • Lagring och hämtning av mått och data.
  • Användning av taggar och underordnad hierarki för enkel sökning efter tidigare körningar.
  • Registrering av lagrade modellfiler för distribution.
  • Lagring, ändring och hämtning av egenskaper för en körning.

Skapa ett Run-objekt genom att skicka ett Experiment-objekt med ett run configuration-objekt. Använd parametern tags för att koppla anpassade kategorier och etiketter till dina körningar. Du kan enkelt hitta och hämta dem senare från Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Använd den statiska funktionen list för att hämta en lista över alla Run-objekt från Experiment. Ange parametern tags för att filtrera efter taggen du skapade tidigare.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Använd funktionen get_details för att hämta detaljerade utdata för körningen.

run_details = run.get_details()

Utdata för den här funktionen är en ordlista som innehåller:

  • Körnings-ID
  • Status
  • Start- och sluttid
  • Beräkningsmål (lokalt och moln)
  • Beroenden och versioner som användes i körningen
  • Träningsspecifika data (varierar beroende på modelltyp)

Fler exempel på hur du konfigurerar och övervakar körningar finns i instruktionerna.

Modell

Namnområde: azureml.core.model.Model

Klassen Model används för att arbeta med molnrepresentationer av Machine Learning-modeller. Med metoder kan du överföra modeller mellan lokala utvecklingsmiljöer och Workspace-objektet i molnet.

Du kan använda modellregistrering för att lagra och versionshantera dina modeller i Azure-molnet, på din arbetsyta. Registrerade modeller identifieras med namn och version. Varje gång du registrerar en modell med ett namn som redan finns ökar versionsnumret. Azure Machine Learning stöder alla modeller som kan läsas in via Python 3, inte bara Azure Machine Learning-modeller.

I följande exempel visas hur du skapar en enkel lokal klassificeringsmodell med scikit-learn, registrerar modellen i Workspace och laddar ned modellen från molnet.

Skapa en enkel klassificerare, clf, för att förutsäga kundomsättningen utifrån ålder. Dumpa sedan modellen till en .pkl-fil i samma katalog.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Använd funktionen register för att registrera modellen på din arbetsyta. Ange den lokala sökvägen för modellen och modellnamnet. Om du registrerar samma namn mer än en gång skapas en ny version.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Nu när modellen har registrerats på din arbetsyta är det enkelt att hantera, ladda ned och organisera dina modeller. Om du vill hämta ett modellobjekt (till exempel i en annan miljö) från Workspace använder du klasskonstruktorn och anger modellnamnet och eventuella valfria parametrar. Använd sedan funktionen download för att ladda ned modellen, inklusive molnmappstrukturen.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Använd funktionen delete för att ta bort modellen från Workspace.

model.delete()

När du har en registrerad modell är det enkelt att distribuera den som en webbtjänst. Du börjar med att skapa och registrera en avbildning. I det här steget konfigureras Python-miljön och dess beroenden, tillsammans med ett skript för att definiera formatet för begäranden och svar för webbtjänsten. När du har skapat en avbildning skapar du en distributionskonfiguration som anger processorkärnor och minnesparametrar för beräkningsmålet. Bifoga sedan din avbildning.

ComputeTarget, RunConfiguration och ScriptRunConfig

Namnområde: azureml.core.compute.ComputeTarget
Namnområde: azureml.core.runconfig.RunConfiguration
Namnområde: azureml.core.script_run_config.ScriptRunConfig

Klassen ComputeTarget är en abstrakt överordnad klass som du använder för att skapa och hantera beräkningsmål. Ett beräkningsmål representerar en rad olika resurser där du kan träna dina maskininlärningsmodeller. Ett beräkningsmål kan vara antingen en lokal dator eller en molnresurs, till exempel Azure Machine Learning Compute, Azure HDInsight eller en virtuell fjärrdator.

Använd beräkningsmål för att dra nytta av kraftfulla virtuella datorer för modellträning och konfigurera antingen beständiga beräkningsmål eller temporära mål som anropas vid körning. En omfattande guide om hur du konfigurerar och hanterar beräkningsmål finns i instruktionerna.

Följande kod visar ett enkelt exempel på hur du konfigurerar ett AmlCompute-mål (underordnad klass av ComputeTarget). Det här målet skapar en fjärrberäkningsresurs som anropas under körning i ditt Workspace-objekt. Resursen skalas automatiskt när ett jobb skickas. Den tas bort automatiskt när körningen är klar.

Återanvänd den enkla scikit-learn-omsättningsmodellen och bygg den till en egen fil, train.py, i den aktuella katalogen. Skapa en ny katalog med namnet outputs i slutet av filen. I det här steget skapas en katalog i molnet (din arbetsyta) för att lagra din inlärda modell som serialiserats med joblib.dump().

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Därefter skapar du beräkningsmålet genom att instansiera ett RunConfiguration-objekt och ange typ och storlek. I det här exemplet används den minsta resursstorleken (1 processorkärna och 3,5 GB minne). Variabeln list_vms innehåller en lista över virtuella datorer som stöds och deras storlek.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Skapa beroenden för fjärrberäkningsresursens Python-miljö med hjälp av klassen CondaDependencies. Filen train.py använder scikit-learn och numpy, som måste installeras i miljön. Du kan också ange versioner av beroenden. Använd dependencies-objektet för att ange miljön i compute_config.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Nu är du redo att skicka experimentet. Använd klassen ScriptRunConfig för att koppla beräkningsmålkonfigurationen och för att ange sökvägen/filen till träningsskriptet train.py. Skicka experimentet genom att ange parametern config för funktionen submit(). Anropa wait_for_completion på den resulterande körningen för att se asynkrona körningsutdata när miljön initieras och modellen tränas.

Varning

Följande är begränsningar kring specifika tecken när de används i ScriptRunConfig parametrar:

  • Tecknen ", $, ;och \ är undantagna av serverdelen, eftersom de betraktas som reserverade tecken för att separera bash-kommandon.
  • Tecknen (, ), %, !, ^<, >, &, och | är undantagna för lokala körningar i Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

När körningen är klar är filen för den inlärda modellen, churn-model.pkl, tillgänglig på din arbetsyta.

Miljö

Namnområde: azureml.core.environment

Azure Machine Learning-miljöer anger Python-paket, miljövariabler och programvaruinställningar runt dina tränings- och bedömningsskript. Förutom Python kan du även konfigurera PySpark, Docker och R för miljöer. Internt resulterar miljöer i Docker-avbildningar som används för att köra träning och bedömningsprocesser på beräkningsmålet. Miljöerna är hanterade och versionshanterade entiteter på din Machine Learning-arbetsyta som möjliggör reproducerbara, granskningsbara och portabla maskininlärningsarbetsflöden över en mängd olika beräkningsmål och beräkningstyper.

Du kan använda ett Environment -objekt för att:

  • Utveckla ditt träningsskript.
  • Återanvänd samma miljö på Azure Machine Learning Compute för modellträning i stor skala.
  • Distribuera din modell med samma miljö utan att vara knuten till en specifik beräkningstyp.

Följande kod importerar Environment klassen från SDK och instansierar ett miljöobjekt.

from azureml.core.environment import Environment
Environment(name="myenv")

Lägg till paket i en miljö med hjälp av Conda-, pip- eller privata hjulfiler. Ange varje paketberoende med hjälp CondaDependency av klassen för att lägga till den i miljöns PythonSection.

I följande exempel läggs till i miljön. Den lägger till version 1.17.0 av numpy. Det lägger också till pillow paketet i miljön, myenv. I exemplet används add_conda_package() metoden respektive add_pip_package() metoden .

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Om du vill skicka en träningskörning måste du kombinera din miljö, beräkningsmål och ditt Python-träningsskript till en körningskonfiguration. Den här konfigurationen är ett omslutningsobjekt som används för att skicka körningar.

När du skickar en träningskörning kan det ta flera minuter att skapa en ny miljö. Varaktigheten beror på storleken på de beroenden som krävs. Miljöerna cachelagras av tjänsten. Så länge miljödefinitionen förblir oförändrad ådrar du dig fullständig installationstid bara en gång.

I följande exempel visas var du skulle använda ScriptRunConfig som omslutningsobjekt.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Om du inte anger en miljö i körningskonfigurationen innan du skickar körningen skapas en standardmiljö åt dig.

Se avsnittet Modelldistribution för att använda miljöer för att distribuera en webbtjänst.

Pipeline, PythonScriptStep

Namnområde: azureml.pipeline.core.pipeline.Pipeline
Namnområde: azureml.pipeline.steps.python_script_step.PythonScriptStep

En Azure Machine Learning-pipeline är ett automatiserat arbetsflöde för en komplett maskininlärningsaktivitet. Underaktiviteter kapslas in som en serie steg i pipelinen. En Azure Machine Learning-pipeline kan mycket enkel, till exempel ett steg som anropar ett Python-skript. Pipelines innefattar funktioner för:

  • Förberedelse av data, inklusive import, validering och rensning, omvandling och transformering, normalisering och mellanlagring
  • Träningskonfiguration, inklusive parametrisera argument, sökvägar och loggnings-/rapporteringskonfigurationer
  • Träning och validering på ett effektivt och upprepat sätt, vilket kan omfatta att ange specifika delmängder av data, olika maskinvaruberäkningsresurser, distribuerad databehandling och förloppsövervakning
  • Distribution, inklusive versionshantering, skalning, etablering och åtkomstkontroll
  • Publicera en pipeline till en REST-slutpunkt för körning på nytt från ett HTTP-bibliotek

PythonScriptStep är ett inbyggt grundläggande steg för att köra ett Python-skript på ett beräkningsmål. Det tar ett skriptnamn och andra valfria parametrar som argument för skriptet, beräkningsmål, indata och utdata. Följande kod är ett enkelt exempel på ett PythonScriptStep. Ett exempel på ett train.py-skript finns i underavsnittet i självstudien.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

När minst ett steg har skapats kan steg länkas samman och publiceras som en enkel automatiserad pipeline.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Om du vill ha ett omfattande exempel på hur du skapar ett pipelinearbetsflöde kan du följa den avancerade självstudien.

Mönster för att skapa och använda pipelines

En Azure Machine Learning-pipeline är associerad med en Azure Machine Learning-arbetsyta och ett pipelinesteg associeras med ett beräkningsmål som är tillgängligt på den arbetsytan. Mer information finns i den här artikeln om arbetsytor eller den här förklaringen av beräkningsmål.

Ett vanligt mönster för pipelinesteg:

  1. Ange arbetsyta, beräkning och lagring
  2. Konfigurera indata och utdata med
    1. Datauppsättning som gör ett befintligt Azure-datalager tillgängligt
    2. PipelineDataset som kapslar in tabelldata
    3. PipelineData som används för mellanliggande fil- eller katalogdata som skrivits av ett steg och som är avsedda att användas av ett annat
  3. Definiera ett eller flera pipelinesteg
  4. Instansiera en pipeline med hjälp av din arbetsyta och dina steg
  5. Skapa ett experiment som du skickar pipelinen till
  6. Övervaka experimentresultatet

Den här anteckningsboken är ett bra exempel på det här mönstret. jobb

Mer information om Azure Machine Learning-pipelines och hur de skiljer sig från andra typer av pipelines finns i den här artikeln.

AutoMLConfig

Namnområde: azureml.train.automl.automlconfig.AutoMLConfig

Använd klassen AutoMLConfig för att konfigurera parametrar för automatiserad maskininlärningsträning. Den automatiserade maskininlärningen itererar över flera kombinationer av maskininlärningsalgoritmer och hyperparameterinställningar. Sedan söker den efter den modell som passar bäst utifrån det precisionsmått som du har valt. Med konfiguration kan du ange:

  • Aktivitetstyp (klassificering, regression, prognosticering)
  • Antal algoritmiterationer och maximal tid per iteration
  • Precisionsmått för optimering
  • Algoritmer för blockliste/allowlist
  • Antal korsvalideringar
  • Beräkningsmål
  • Träningsdata

Anteckning

Använd automl i installationen om du vill använda automatiserad maskininlärning.

Detaljerade guider och exempel på hur du konfigurerar automatiserade maskininlärningsexperiment finns i självstudien och i instruktionerna.

Följande kod visar hur du bygger ett automatiserat konfigurationsobjekt för maskininlärning för en klassificeringsmodell, och använder det när du skickar ett experiment.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Använd automl_config-objektet för att skicka ett experiment.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

När du har skickat experimentet visar utdata inlärningsprecisionen för varje iteration när den har slutförts. När körningen är klar returneras ett AutoMLRun-objekt (som utökar klassen Run). Hämta den modell som passar bäst genom att returnera ett Model-objekt med hjälp av funktionen get_output().

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Modelldistribution

Namnområde: azureml.core.model.InferenceConfig
Namnområde: azureml.core.webservice.webservice.Webservice

Klassen InferenceConfig är avsedd för konfigurationsinställningar som beskriver den miljö som krävs för att vara värd för modellen och webbtjänsten.

Webservice är en abstrakt överordnad klass för att skapa och distribuera webbtjänster för dina modeller. En detaljerad guide om hur du förbereder för modelldistribution och distribution av webbtjänster finns i den här instruktioner.

Du kan använda miljöer när du distribuerar din modell som en webbtjänst. Miljöer möjliggör ett reproducerbart, anslutet arbetsflöde där du kan distribuera din modell med samma bibliotek i både din träningsberäkning och din slutsatsdragningsberäkning. Internt implementeras miljöer som Docker-avbildningar. Du kan använda antingen avbildningar som tillhandahålls av Microsoft eller använda dina egna anpassade Docker-avbildningar. Om du tidigare använde ContainerImage klassen för distributionen DockerSection kan du läsa klassen för att utföra ett liknande arbetsflöde med miljöer.

Om du vill distribuera en webbtjänst kombinerar du miljön, slutsatsdragningsberäkning, bedömningsskript och registrerad modell i distributionsobjektet, deploy().

I följande exempel förutsätter vi att du redan har slutfört en träningskörning med hjälp av miljön , myenvoch vill distribuera modellen till Azure Container Instances.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

I det här exemplet skapas en Azure Container Instances-webbtjänst, som passar bäst för testning och snabb distribution i liten skala. Om du vill distribuera din modell som en webbtjänst i produktionsskala använder du Azure Kubernetes Service (AKS). Mer information finns i klassen AksCompute.

Datamängd

Namnområde: azureml.core.dataset.Dataset
Namnområde: azureml.data.file_dataset.FileDataset
Namnområde: azureml.data.tabular_dataset.TabularDataset

Klassen Dataset är en grundläggande resurs för att utforska och hantera data i Azure Machine Learning. Du kan utforska dina data med sammanfattningsstatistik och spara datauppsättningen till din AML-arbetsyta och använda funktioner för versionshantering och reproducerbarhet. Datauppsättningar kan enkelt användas av modeller under träningen. Detaljerade användningsexempel finns i instruktionsguiden.

  • TabularDataset representerar data i ett tabellformat som skapats genom att parsa en fil eller lista med filer.
  • FileDataset refererar till en eller flera filer i datalager eller från offentliga URL:er.

I följande exempel visas hur du skapar en TabularDataset som pekar på en enskild sökväg i ett datalager.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

I följande exempel visas hur du skapar en FileDataset referens till flera fil-URL:er.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Nästa steg

Prova följande steg och lär dig hur du använder Azure Machine Learning-SDK för Python:

  • Följ självstudien och lär dig hur du bygger, tränar och distribuerar en modell i Python.

  • Leta upp klasser och moduler i referensdokumentationen på den här webbplatsen med hjälp av innehållsförteckningen till vänster.