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

Dataforskare och AI-utvecklare använder Azure Machine Learning SDK v1 för Python för att skapa och köra arbetsflöden för maskininlärning med Azure Machine Learning-tjänsten. Du kan interagera med tjänsten i valfri Python-miljö, inklusive Jupyter Notebooks, Visual Studio Codeeller din favorit python-IDE.

Viktiga områden i SDK:et är:

• Utforska, förbereda och hantera livscykeln för dina datauppsättningar som används i maskininlärningsexperiment.
• Hantera molnresurser för övervakning, loggning och organisering av dina maskininlärningsexperiment.
• 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. Den itererar automatiskt via 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 tränade modeller till RESTful-tjänster som kan användas i alla program.

Om du vill ha en stegvis genomgång av hur du kommer igång kan du prova självstudien.

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

Stabil kontra experimentell

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

Experimentella funktioner är märkta med ett anteckningsavsnitt i SDK-referensen och anges med text, till exempel (förhandsversion) i hela Azure Machine Learning-dokumentationen.

Arbetsyta

namnområde: azureml.core.workspace.Workspace

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

Visa alla parametrar för metoden create Workspace återanvända befintliga instanser (Storage, Key Vault, App-Insights och Azure Container Registry-ACR) samt ändra ytterligare inställningar som 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 har en tidigare befintlig Azure-resursgrupp som du vill använda för arbetsytan. Vissa funktioner kan fråga efter autentiseringsuppgifter för Azure.

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 dina prenumerations-, resurs- och arbetsytenamndata.

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

Läs in arbetsytan 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 metoden static get() för 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 utvärderingsversioner (enskilda modellkörningar). Följande kod hämtar ett Experiment-objekt inifrån Workspace efter namn, eller så skapas 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 (utvärderingsversioner) 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 utvärderingsversion av experimentet. Om du experimenterar interaktivt i en Jupyter-notebook-fil använder du funktionen start_logging. Om du skickar ett experiment från en Standard Python-miljö använder du funktionen submit. Båda funktionerna returnerar ett Run objekt. Variabeln experiment representerar ett Experiment objekt i följande kodexempel.

Springa

namnområde: azureml.core.run.Run

En körning representerar en enda utvärderingsversion av ett experiment. Run är det objekt som du använder för att övervaka den asynkrona körningen av en utvärderingsversion, lagra utdata från utvärderingsversionen, analysera resultat och komma åt genererade artefakter. Du använder Run i experimentkoden för att logga mått och artefakter till körningshistoriktjänsten. Funktionerna omfattar:

• Lagra och hämta mått och data.
• Använda taggar och den underordnade hierarkin för enkel sökning efter tidigare körningar.
• Registrera lagrade modellfiler för distribution.
• Lagra, ändra och hämta egenskaper för en körning.

Skapa ett Run objekt genom att skicka ett Experiment objekt med en köra konfiguration 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 funktionen static list för att hämta en lista över alla Run objekt från Experiment. Ange den tags parameter som ska filtreras efter taggen som 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ör ID
• Status
• Start- och sluttid
• Beräkningsmål (lokalt kontra moln)
• Beroenden och versioner som används i körningen
• Träningsspecifika data (varierar beroende på modelltyp)

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

Modell

namnområde: azureml.core.model.Model

Klassen Model används för att arbeta med molnrepresentationer av maskininlärningsmodeller. Metoder hjälper dig att överföra modeller mellan lokala utvecklingsmiljöer och det Workspace objektet i molnet.

Du kan använda modellregistrering för att lagra och version dina modeller i Azure-molnet på din arbetsyta. Registrerade modeller identifieras med namn och version. Varje gång du registrerar en modell med samma namn som en befintlig, ökar registret versionen. 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 Workspaceoch laddar ned modellen från molnet.

Skapa en enkel klassificerare, clf, för att förutsäga kundomsättning baserat på deras å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 sökvägen till den lokala 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 Workspaceanvänder du klasskonstruktorn och anger modellnamnet och 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. Först du skapa och registrera en avbildning. Det här steget konfigurerar Python-miljön och dess beroenden, tillsammans med ett skript för att definiera webbtjänstens begäran- och svarsformat. När du har skapat en avbildning du skapa en distributionskonfiguration som anger processorkärnor och minnesparametrar för beräkningsmålet. Sedan bifogar du avbildningen.

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 den abstrakta överordnade klassen för att skapa och hantera beräkningsmål. Ett beräkningsmål representerar en mängd 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 tillfälliga körningsanropade mål. En omfattande guide om hur du konfigurerar och hanterar beräkningsmål finns i instruktioner.

Följande kod visar ett enkelt exempel på hur du konfigurerar ett AmlCompute (underordnad klass ComputeTarget) mål. Det här målet skapar en fjärrberäkningsresurs för 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 churn-modellen och skapa den i en egen fil, train.py, i den aktuella katalogen. I slutet av filen skapar du en ny katalog med namnet outputs. Det här steget skapar en katalog i molnet (din arbetsyta) för att lagra din tränade modell som joblib.dump() serialiserad.

# 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")

Sedan 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 CPU-kärna, 3,5 GB minne). Variabeln list_vms innehåller en lista över virtuella datorer som stöds och deras storlekar.

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 konfigurationen av beräkningsmål och 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 den tränade modellfilen 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 kring 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 bärbara 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 kopplad till en specifik beräkningstyp.

Följande kod importerar klassen Environment 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 av klassen CondaDependency för att lägga till det 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 metoden add_conda_package() respektive metoden add_pip_package().

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åloch ditt Python-träningsskript i 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 nödvändiga beroendena. Miljöerna cachelagras av tjänsten. Så länge miljödefinitionen förblir oförändrad ådrar du dig den fullständiga installationstiden 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 Model deploy (distribuera) 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 fullständig maskininlärningsuppgift. Underaktiviteter kapslas in som en serie steg i pipelinen. En Azure Machine Learning-pipeline kan vara så enkel som ett steg som anropar ett Python-skript. Pipelines innehåller funktioner för:

• Förberedelse av data, inklusive import, validering och rensning, munging och transformering, normalisering och mellanlagring
• Träningskonfiguration, inklusive parameterisering av argument, filsökvägar och konfigurationer för loggning/rapportering
• Träning och validering effektivt och upprepat, vilket kan innefatta att ange specifika dataunderuppsättningar, olika maskinvaruberäkningsresurser, distribuerad bearbetning och förloppsövervakning
• Distribution, inklusive versionshantering, skalning, etablering och åtkomstkontroll
• Publicera en pipeline till en REST-slutpunkt för att köras igen från alla HTTP-bibliotek

En PythonScriptStep är ett grundläggande, inbyggt 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å en PythonScriptStep. Ett exempel på ett train.py skript finns i självstudie underavsnittet.

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)

Ett omfattande exempel på hur du skapar ett pipelinearbetsflöde finns i 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 är associerat 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 är:

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

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

Mer information om Azure Machine Learning-pipelines och i synnerhet 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. Automatiserad maskininlärning itererar över många kombinationer av maskininlärningsalgoritmer och inställningar för hyperparameter. Den hittar sedan den modell som passar bäst baserat på ditt valda noggrannhetsmått. Med konfiguration kan du ange:

• Uppgiftstyp (klassificering, regression, prognostisering)
• Antal iterationer för algoritmer och maximal tid per iteration
• Noggrannhetsmått för att optimera
• Algoritmer för blocklistning/tillåtlista
• Antal korsvalideringar
• Beräkningsmål
• Träningsdata

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

Följande kod visar hur du skapar ett automatiserat maskininlärningskonfigurationsobjekt 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 träningsnoggrannheten för varje iteration när den är klar. När körningen är klar returneras ett AutoMLRun -objekt (som utökar Run-klassen). Hämta modellen som passar bäst med hjälp av funktionen get_output() för att returnera ett Model objekt.

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 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 den abstrakta överordnade klassen 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 klassen ContainerImage för distributionen kan du läsa klassen DockerSection för att utföra ett liknande arbetsflöde med miljöer.

Om du vill distribuera en webbtjänst kombinerar du miljön, inferensberäkningen, bedömningsskriptet och den registrerade modellen 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ö, 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)

Det här exemplet skapar en Azure Container Instances-webbtjänst, som är bäst för småskalig testning och snabbdistributioner. 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.

Dataset

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 på din AML-arbetsyta för att få funktioner för versionshantering och reproducerbarhet. Datauppsättningar används enkelt av modeller under träning. Detaljerade användningsexempel finns i instruktioner för.

• TabularDataset representerar data i 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 enda 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 som refererar 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 för att lära dig hur du använder Azure Machine Learning SDK för Python:

• Följ självstudien för att lära dig hur du skapar, 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.