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

  • Artikel
  • 15 minuter för att läsa

Dataforskare och AI-utvecklare använder Azure Machine Learning-SDK för Python till att skapa och köra Machine Learning-arbetsflöden med tjänsten Azure Machine Learning. Du kan interagera med tjänsten i valfri Python-miljö, inklusive Jupyter-anteckningsböcker, 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 automatisk maskin inlärning, som godkänner konfigurations parametrar och tränings data. 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 tillhandahåller både stabila och experimentella funktioner i samma SDK.

Stabila funktioner

De stabila funktionerna rekommenderas för de flesta användnings fall och produktions miljöer. De uppdateras oftare än experimentella funktioner.

Experimentella funktioner (utveckling)

Experimentella funktioner är nyligen utvecklade funktioner & uppdateringar som kanske inte är klara eller helt testade för produktions användning. Funktionerna är vanligt vis funktionella, men de kan innehålla vissa avbrytande ändringar. Experimentella funktioner används för att stryka på SDK-filbuggar och tar bara emot uppdateringar under test periodens varaktighet.

När namnet indikerar är experimentella funktioner för experimentering och betraktas inte som felfria eller stabila. Därför rekommenderar vi bara experimentella funktioner för avancerade användare som vill testa tidiga versioner av funktioner och uppdateringar och tänker delta i rapportering av buggar och problem.

Experimentella funktioner är märkta med en not-sektion i SDK-referensen.

Arbetsyta

Namnrymd: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.

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

Namnrymd: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

Namnrymd: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

Namnrymd: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

Namnrymd:azureml.core.compute.ComputeTarget
Namnrymd:azureml.core.runconfig.RunConfiguration
Namnrymd: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.

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ö

Namnrymd:azureml.core.environment

Azure Machine Learning miljöer anger python-paket, miljövariabler och program varu inställningar kring dina utbildnings-och bedömnings skript. Förutom python kan du också konfigurera PySpark, Docker och R för miljöer. Internt resulterar i miljöer i Docker-avbildningar som används för att köra utbildnings-och poängsättnings processerna på beräknings målet. Miljöer är hanterade och versions bara entiteter inom din Machine Learning arbets yta som möjliggör återskapande, gransknings bara och bärbara Machine Learning-arbetsflöden över flera olika beräknings mål och beräknings typer.

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

  • Utveckla ditt utbildnings skript.
  • Återanvänd samma miljö på Azure Machine Learning beräkning för modell träning i stor skala.
  • Distribuera din modell med samma miljö utan att vara knuten till en speciell beräknings typ.

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 Conda-, pip-eller privata Wheel-filer. Ange varje paket beroende genom CondaDependency att använda klassen för att lägga till det i miljöns PythonSection .

Följande exempel lägger till i miljön. Den lägger till version 1.17.0 av numpy . Paketet läggs också pillow till i miljön myenv . Exemplet använder metoden respektive add_conda_package() add_pip_package() metod.

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 utbildnings körning måste du kombinera din miljö, Beräkna måloch ditt Python-skript i en körnings konfiguration. Den här konfigurationen är ett wrapper-objekt som används för att skicka körningar.

När du skickar in en utbildnings körning kan det ta flera minuter att skapa en ny miljö. Varaktigheten beror på storleken på de nödvändiga beroendena. Miljöerna cachelagras av tjänsten. Så länge miljö definitionen är oförändrad, tillkommer du bara den fullständiga konfigurations tiden en gång.

I följande exempel visas var du ska använda ScriptRunConfig som wrapper-objekt.

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örnings konfigurationen innan du skickar körningen, skapas en standard miljö åt dig.

Se avsnittet modell distribution för att använda miljöer för att distribuera en webb tjänst.

Pipeline, PythonScriptStep

Namnrymd:azureml.pipeline.core.pipeline.Pipeline
Namnrymd: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 kopplad till en Azure Machine Learning arbets yta och ett steg i pipeline är associerat med ett beräknings mål som är tillgängligt i arbets ytan. 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. Data uppsättning som gör tillgängligt för ett befintligt Azure-datalager
    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. uppgift

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

Namnrymd: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 svartlista/vitlista
  • 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)

Modell distribution

Namnrymd:azureml.core.model.InferenceConfig
Namnrymd:azureml.core.webservice.webservice.Webservice

InferenceConfigKlassen är för konfigurations inställningar som beskriver den miljö som krävs för att vara värd för modellen och webb tjä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 modell distribution och distribuerar webb tjänster finns i den här instruktionen.

Du kan använda miljöer när du distribuerar din modell som en webb tjänst. Miljöer möjliggör ett reproducerat, anslutet arbets flöde där du kan distribuera din modell med samma bibliotek i både din utbildning och din härlednings berä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 din distribution, se DockerSection klassen för att utföra ett liknande arbets flöde med miljöer.

Om du vill distribuera en webb tjänst kombinerar du miljön, ett bedömnings beräknings skript och en registrerad modell i ditt distributions objekt deploy() .

I följande exempel förutsätter vi att du redan har slutfört en utbildning som körs med hjälp av miljön, myenv och 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.

Datauppsättning

Namnrymd:azureml.core.dataset.Dataset
Namnrymd:azureml.data.file_dataset.FileDataset
Namnrymd: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.

  • TabularDatasetrepresenterar data i tabell format som skapats genom att parsa en fil eller en 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.