Wat is de Azure Machine Learning-SDK voor Python?

  • Artikel

Gegevenswetenschappers en AI-ontwikkelaars gebruiken de Azure Machine Learning SDK voor Python om machine learning-werkstromen te bouwen en uit te voeren met de Azure Machine Learning-service. U kunt communiceren met de service in elke Python-omgeving, waaronder Jupyter Notebooks, Visual Studio Code of uw favoriete Python IDE.

De belangrijkste functies van de SDK zijn:

  • De levenscyclus van uw gegevenssets die worden gebruikt in machine learning-experimenten verkennen, voorbereiden en beheren.
  • Cloudresources voor het bewaken, loggen en organiseren van uw machine-leerexperimenten beheren.
  • Modellen trainen, lokaal of met behulp van cloudresources, inclusief GPU-versnelde modeltraining.
  • Gebruik geautomatiseerde machine learning, die configuratieparameters en trainingsgegevens accepteert. Er worden automatisch algoritmen en hyperparameter-instellingen doorlopen om het beste model voor het uitvoeren van voorspellingen te vinden.
  • Webservices implementeren om uw getrainde modellen om te zetten in RESTful-services die in elke toepassing kunnen worden gebruikt.

Raadpleeg de zelfstudie voor een stapsgewijze uitleg over hoe u aan de slag kunt gaan.

De volgende secties bevatten overzichten van een aantal van de belangrijkste klassen in de SDK en veelgebruikte ontwerppatronen voor het gebruik ervan. Raadpleeg de installatiehandleiding voor het downloaden van de SDK.

Stabiel versus experimenteel

De Azure Machine Learning SDK voor Python biedt zowel stabiele als experimentele functies in dezelfde SDK.

Functie-/mogelijkheidsstatus Description
Stabiele functies Gereed voor productie

Deze functies worden aanbevolen voor de meeste gebruiksscenario's en productieomgevingen. Ze worden minder vaak bijgewerkt dan experimentele functies.
Experimentele functies Developmental

Deze functies zijn nieuw ontwikkelde mogelijkheden & updates die mogelijk niet gereed of volledig zijn getest op productiegebruik. Hoewel de functies doorgaans functioneel zijn, kunnen ze enkele belangrijke wijzigingen bevatten. Experimentele functies worden gebruikt om sdk-fouten te verhelpen die fouten veroorzaken en ontvangen alleen updates voor de duur van de testperiode. Experimentele functies worden ook wel functies genoemd die in preview zijn.

Zoals de naam aangeeft, zijn de experimentele functies (preview) bedoeld om te experimenteren en worden ze niet beschouwd als vrij van fouten of stabiel. Daarom raden we alleen experimentele functies aan voor ervaren gebruikers die vroege versies van mogelijkheden en updates willen uitproberen en van plan zijn deel te nemen aan het melden van bugs en storingen.

Experimentele functies worden gelabeld door een notitiesectie in de SDK-verwijzing en aangeduid met tekst, zoals (preview) in de Documentatie van Azure Machine Learning.

Werkruimte

Naamruimte: azureml.core.workspace.Workspace

De klasse Workspace is de basisresource in de cloud die u gebruikt voor het experimenteren met en trainen en implementeren van machine learning-modellen. De klasse bindt uw Azure-abonnement en resourcegroep aan een eenvoudig te verbruiken object.

Bekijk alle parameters van de methode Werkruimte maken om bestaande exemplaren (Storage, Key Vault, App-Insights en Azure Container Registry-ACR) opnieuw te gebruiken en aanvullende instellingen te wijzigen, zoals configuratie van privé-eindpunten en rekendoel.

Importeer de klasse en maak een nieuwe werkruimte met behulp van de volgende code. Stel create_resource_group in op False als u een bestaande Azure-resourcegroep hebt die u wilt gebruiken voor de werkruimte. Bij sommige functies wordt u mogelijk gevraagd om Azure-verificatiereferenties.

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

Gebruik dezelfde werkruimte in meerdere omgevingen door deze eerst naar een JSON-configuratiebestand te schrijven. Hiermee worden de gegevens van uw abonnement, resource en werkruimtenaam opgeslagen.

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

Laad uw werkruimte door het configuratiebestand te lezen.

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

U kunt ook de statische get()-methode gebruiken om een bestaande werkruimte te laden zonder configuratiebestand te gebruiken.

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

De variabele ws vertegenwoordigt een Workspace-object in de volgende codevoorbeelden.

Experiment

Naamruimte: azureml.core.experiment.Experiment

De klasse Experiment is een andere basiscloudresource die een verzameling proeven vertegenwoordigt (afzonderlijke modeluitvoeringen). Met de volgende code wordt een Experiment-object op naam opgehaald uit Workspace of een nieuw Experiment-object gemaakt als de naam niet bestaat.

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

Voer de volgende code uit om een lijst op te halen met alle Experiment-objecten in Workspace.

list_experiments = Experiment.list(ws)

Gebruik de functie get_runs om een lijst met Run-objecten (proeven) op te halen uit Experiment. Met de volgende code worden de uitvoeringen opgehaald en wordt elke run-ID afgedrukt.

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

Er zijn twee manieren om een experimentproef uit te voeren. Als u interactief wilt experimenteren in een Jupyter-notebook, gebruikt u de functie start_logging. Als u een experiment wilt versturen vanuit een standaard Python-omgeving, gebruikt u de functie submit. Met beide functies wordt een Run-object geretourneerd. De variabele experiment vertegenwoordigt een Experiment-object in de volgende codevoorbeelden.

Uitvoeren

Naamruimte: azureml.core.run.Run

Een uitvoering vertegenwoordigt één proef van een experiment. Run is het object dat u gebruikt om de asynchrone uitvoering van een proef te bewaken, de uitvoer van de proef op te slaan, resultaten te analyseren en toegang te krijgen tot gegenereerde artefacten. U gebruikt Run in uw experimentcode om metrische gegevens en artefacten vast te leggen in de uitvoeringsgeschiedenisservice. De functionaliteit omvat:

  • Metrische en andere gegevens opslaan en ophalen.
  • Tags en de onderliggende hiërarchie gebruiken om eerdere uitvoeringen eenvoudig op te zoeken.
  • Opgeslagen modelbestanden registreren voor implementatie.
  • De eigenschappen van een uitvoering opslaan, wijzigen en ophalen.

Een Run-object maken door een Experiment-object in te dienen met een uitvoeringsconfiguratie-object. De parameter tags gebruiken om aangepaste categorieën en labels aan uw uitvoeringen te koppelen. U kunt ze later gemakkelijk vinden en ophalen uit Experiment.

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

Gebruik de statische functie list om een lijst met alle Run-objecten op te halen uit Experiment. Geef de parameter tags op om te filteren op uw eerder gemaakte tag.

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

Gebruik de functie get_details om de gedetailleerde uitvoer van de uitvoering op te halen.

run_details = run.get_details()

De uitvoer voor deze functie is een woordenlijst die het volgende bevat:

  • Uitvoerings-id
  • Status
  • Begin- en eindtijd
  • Rekendoel (lokaal versus cloud)
  • In de uitvoering gebruikte afhankelijkheden en versies
  • Trainingsspecifieke gegevens (afhankelijk van het modeltype)

Raadpleeg de instructies voor meer voorbeelden van het configureren en bewaken van uitvoeringen.

Model

Naamruimte: azureml.core.model.Model

De klasse Model wordt gebruikt voor het werken met cloudrepresentaties van machine learning-modellen. Met methoden kunt u modellen overdragen tussen lokale ontwikkelomgevingen en het Workspace-object in de cloud.

U kunt modelregistratie gebruiken om uw modellen op te slaan en de versies ervan te beheren in uw werkruimte in de Azure-cloud. Geregistreerde modellen worden geïdentificeerd met naam en versie. Telkens wanneer u een model registreert met dezelfde naam als een bestaand model, wordt de versie in het register verhoogd. Azure Machine Learning ondersteunt elk model dat kan worden geladen via Python 3, niet alleen Azure Machine Learning-modellen.

In het volgende voorbeeld ziet u hoe u een eenvoudig lokaal classificatiemodel maakt met scikit-learn, het model registreert in Workspace en het model downloadt uit de cloud.

Maak een eenvoudige classificatie, clf, om het verloop van klanten te voorspellen op basis van hun leeftijd. Dump het model vervolgens naar een .pkl-bestand in dezelfde directory.

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

Gebruik de functie register om het model in uw werkruimte te registreren. Geef het pad naar het lokale model en de naam van het model op. Als dezelfde naam meer dan één keer wordt geregistreerd, wordt er een nieuwe versie gemaakt.

from azureml.core.model import Model

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

Nu het model is geregistreerd in uw werkruimte, is het eenvoudig om uw modellen te beheren, te downloaden en te organiseren. Als u een modelobject (bijvoorbeeld in een andere omgeving) van Workspace wilt ophalen, gebruikt u de klassenconstructor en geeft u de naam van het model en eventuele optionele parameters op. Gebruik vervolgens de functie download om het model te downloaden, met inbegrip van de cloudmapstructuur.

from azureml.core.model import Model
import os

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

Gebruik de functie delete om het model te verwijderen uit Workspace.

model.delete()

Wanneer u een geregistreerd model hebt, is het implementeren van de service als een webservice een eenvoudig proces. Eerst maakt en registreert u een installatiekopie. Met deze stap configureert u de Python-omgeving en de bijbehorende afhankelijkheden, samen met een script voor het definiëren van de indeling van de webservice-aanvraag en het antwoord. Nadat u een installatiekopie hebt gemaakt, maakt u een implementatieconfiguratie die de CPU-kernen en de geheugenparameters voor het rekendoel instelt. Vervolgens koppelt u uw installatiekopie.

ComputeTarget, RunConfiguration en ScriptRunConfig

Naamruimte: azureml.core.compute.ComputeTarget
Naamruimte: azureml.core.runconfig.RunConfiguration
Naamruimte: azureml.core.script_run_config.ScriptRunConfig

De klasse ComputeTarget is de abstracte bovenliggende klasse voor het maken en beheren van rekendoelen. Een rekendoel vertegenwoordigt een aantal resources waarmee u uw machine learning modellen kunt trainen. Een rekendoel kan een lokale machine of een cloudresource zijn, zoals Azure Machine Learning Compute, Azure HDInsight of een externe virtuele machine.

Gebruik rekendoelen om te profiteren van krachtige virtuele machines voor modeltraining en stel persistente rekendoelen of tijdelijke, door runtime aangeroepen doelen in. Raadpleeg de instructies voor een uitgebreide handleiding voor het instellen en beheren van rekendoelen.

De volgende code toont een eenvoudig voorbeeld van het instellen van een AmlCompute-doel (onderliggende klasse van ComputeTarget). Met dit doel maakt u een externe runtime-rekenresource in uw Workspace-object. De resource wordt automatisch geschaald wanneer er een taak wordt ingediend. De resource wordt automatisch verwijderd wanneer de uitvoering is voltooid.

Gebruik het eenvoudige scikit-learn-verloopmodel opnieuw en maak er een eigen bestand, train.py, van in de huidige map. Maak aan het einde van het bestand een nieuwe directory met de naam outputs. Met deze stap maakt u een map in de cloud (uw werkruimte) om uw getrainde model op te slaan dat met joblib.dump() is geserialiseerd.

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

Vervolgens maakt u het rekendoel door een RunConfiguration-object te instantiëren en het type en de grootte in te stellen. In dit voorbeeld wordt de kleinste resourcegrootte gebruikt (1 CPU-kern, 3,5 GB geheugen). De variabele list_vms bevat een lijst met ondersteunde virtuele machines en hun grootte.

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"

Maak afhankelijkheden voor de Python-omgeving van de externe rekenresource met behulp van de klasse CondaDependencies. Het bestand train.py maakt gebruik van scikit-learn en numpy, die in de omgeving moeten worden geïnstalleerd. U kunt ook versies van afhankelijkheden opgeven. Gebruik het dependencies-object om de omgeving in compute_config in te stellen.

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

U bent nu klaar om het experiment in te dienen. Gebruik de klasse ScriptRunConfig om de configuratie van het rekendoel te koppelen en om het pad, inclusief de bestandsnaam, naar het trainingsscript train.py op te geven. Verzend het experiment door de parameter config van de functie submit() op te geven. Roep wait_for_completion aan bij de resulterende uitvoering om asynchrone run-uitvoer te zien terwijl de omgeving wordt geïnitialiseerd en het model wordt getraind.

Waarschuwing

Hier volgen beperkingen met betrekking tot specifieke tekens wanneer deze worden gebruikt in ScriptRunConfig parameters:

  • De "tekens , $, ;en \ worden door de back-end ge escaped, omdat ze worden beschouwd als gereserveerde tekens voor het scheiden van bash-opdrachten.
  • De (tekens , ), %, !, ^, <, &>, en | worden escape-tekens gebruikt voor lokale uitvoeringen in 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)

Nadat de uitvoering is voltooid, is het getrainde modelbestand churn-model.pkl beschikbaar in uw werkruimte.

Omgeving

Naamruimte: azureml.core.environment

Azure Machine Learning-omgevingen specificeren de Python-pakketten, omgevingsvariabelen en software-instellingen voor uw trainings- en scorescripts. Naast Python kunt u ook PySpark, Docker en R configureren voor omgevingen. Intern resulteren omgevingen in Docker-installatiekopieën die worden gebruikt voor het uitvoeren van de trainings- en scoreprocessen op het rekendoel. De omgevingen zijn beheerde en versie-entiteiten binnen uw Machine Learning-werkruimte die reproduceerbare, controleerbare en draagbare machine learning-werkstromen mogelijk maken voor verschillende rekendoelen en rekentypen.

U kunt een Environment object gebruiken voor het volgende:

  • Ontwikkel uw trainingsscript.
  • Gebruik dezelfde omgeving op Azure Machine Learning Compute opnieuw voor modeltraining op schaal.
  • Implementeer uw model met dezelfde omgeving zonder te zijn gekoppeld aan een specifiek rekentype.

Met de volgende code importeert u de Environment klasse uit de SDK en om een omgevingsobject te instantiëren.

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

Voeg pakketten toe aan een omgeving met behulp van Conda-, pip- of privéwielbestanden. Geef elke pakketafhankelijkheid op met behulp van de CondaDependency -klasse om deze toe te voegen aan de omgeving PythonSection.

In het volgende voorbeeld wordt toegevoegd aan de omgeving. Hiermee wordt versie 1.17.0 van numpytoegevoegd. Het pakket wordt ook toegevoegd pillow aan de omgeving, myenv. In het voorbeeld wordt respectievelijk de add_conda_package() methode en de add_pip_package() methode gebruikt.

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

Als u een trainingsuitvoering wilt verzenden, moet u uw omgeving, rekendoel en uw Python-trainingsscript combineren in een uitvoeringsconfiguratie. Deze configuratie is een wrapper-object dat wordt gebruikt voor het verzenden van uitvoeringen.

Wanneer u een trainingsuitvoering indient, kan het bouwen van een nieuwe omgeving enkele minuten duren. De duur is afhankelijk van de grootte van de vereiste afhankelijkheden. De omgevingen worden in de cache opgeslagen door de service. Zolang de omgevingsdefinitie ongewijzigd blijft, wordt de volledige installatietijd slechts eenmaal uitgevoerd.

In het volgende voorbeeld ziet u waar u het wrapperobject wilt gebruiken ScriptRunConfig .

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)

Als u geen omgeving opgeeft in uw uitvoeringsconfiguratie voordat u de uitvoering verzendt, wordt er een standaardomgeving voor u gemaakt.

Zie de sectie Model implementeren om omgevingen te gebruiken om een webservice te implementeren.

Pipeline, PythonScriptStep

Naamruimte: azureml.pipeline.core.pipeline.Pipeline
Naamruimte: azureml.pipeline.steps.python_script_step.PythonScriptStep

Een Azure Machine Learning pijplijn is een geautomatiseerde werkstroom van een volledige machine learning-taak. Subtaken worden ingekapseld als een reeks stappen in de pijplijn. Een Azure Machine Learning-pijplijn kan zo eenvoudig zijn als één stap die een Python-script aanroept. Pijplijnen bevatten functionaliteit voor:

  • Gegevensvoorbereiding, waaronder importeren, valideren en opschonen, munging en transformatie, normalisatie en fasering
  • Trainingsconfiguratie met inbegrip van parameteriseren van argumenten, bestandspaden en logboek-/rapportageconfiguratie
  • Training en validatie op efficiënte en herhaalbare wijze, waaronder het opgeven van specifieke gegevenssubsets, verschillende hardware-rekenresources, gedistribueerde verwerking en voortgangsbewaking
  • Implementatie, inclusief versiebeheer, schalen, inrichten en toegangsbeheer
  • Een pijplijn naar een REST-eindpunt publiceren om opnieuw uit te voeren vanuit HTTP-bibliotheken

Een PythonScriptStep is een ingebouwde basisstap voor het uitvoeren van een Python-script op een rekendoel. Het maakt gebruik van een scriptnaam en andere optionele parameters, zoals argumenten voor het script, rekendoel, in- en uitvoer. De volgende code is een eenvoudig voorbeeld van een PythonScriptStep. Raadpleeg de subsectie zelfstudie voor een voorbeeld van een train.py-script.

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
)

Nadat er ten minste één stap is gemaakt, kunnen de stappen worden gekoppeld en worden gepubliceerd als een eenvoudige automatische pijplijn.

from azureml.pipeline.core import Pipeline

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

Volg de geavanceerde zelfstudie voor een uitgebreid voorbeeld van het bouwen van een pijplijnwerkstroom.

Patroon voor het maken en gebruiken van pijplijnen

Een Azure Machine Learning-pijplijn is gekoppeld aan een Azure Machine Learning-werkruimte en een pijplijnstap is gekoppeld aan een rekendoel dat beschikbaar is in die werkruimte. Raadpleeg voor meer informatie dit artikel over werkruimten of deze uitleg over rekendoelen.

Een veelvoorkomend patroon voor pijplijnstappen is:

  1. Werkruimte, compute en opslag opgeven
  2. Uw invoer- en uitvoergegevens configureren met behulp van
    1. Gegevensset die een bestaand Azure-gegevensarchief beschikbaar maakt
    2. PipelineDataset, waardoor getypte tabellaire gegevens worden ingekapseld
    3. PipelineData, dat wordt gebruikt voor tussenliggende bestands- of directorygegevens die door één stap worden geschreven en bedoeld zijn om te worden gebruikt in een andere stap
  3. Een of meer pijplijnstappen definiëren
  4. Een pijplijn instantiëren met behulp van uw werkruimte en stappen
  5. Een experiment maken waarbij u de pijplijn indient
  6. De resultaten van het experiment bewaken

Dit notitieblok is een goed voorbeeld van dit patroon. taak

Raadpleeg dit artikel voor meer informatie over Azure Machine Learning-pijplijnen en in het bijzonder over de manier waarop deze verschillen van andere soorten pijplijnen.

AutoMLConfig

Naamruimte: azureml.train.automl.automlconfig.AutoMLConfig

Gebruik de klasse AutoMLConfig om parameters te configureren voor automatische machine learning-training. Automatische machine learning doorloopt een groot aantal combinaties van machine learning-algoritmen en hyperparameterinstellingen. Vervolgens wordt het beste model gevonden op basis van uw gekozen metrische gegevens voor nauwkeurigheid. Met de configuratie kunt u het volgende opgeven:

  • Taaktype (classificatie, regressie, prognose)
  • Aantal algoritme-iteraties en maximumtijd per herhaling
  • Metrische gegevens voor nauwkeurigheid om te optimaliseren
  • Algoritmen voor blokkerings-/acceptatielijst
  • Aantal kruisvalidaties
  • Rekendoelen
  • Trainingsgegevens

Notitie

Gebruik de extra automl in uw installatie om geautomatiseerde machine learning te gebruiken.

Raadpleeg de zelfstudie en instructies voor gedetailleerde handleidingen en voorbeelden van het opzetten van geautomatiseerde machine learning-experimenten.

De volgende code illustreert het bouwen van een geautomatiseerd machine learning-configuratieobject voor een classificatiemodel en het gebruik ervan bij het indienen van een 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
                            )

Gebruik het automl_config-object om een experiment in te dienen.

from azureml.core.experiment import Experiment

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

Nadat u het experiment hebt ingediend, toont de uitvoer de trainingsnauwkeurigheid voor elke iteratie als deze afloopt. Nadat de uitvoering is voltooid, wordt er een AutoMLRun-object (dat de Run-klasse uitbreidt) geretourneerd. Zoek het best passende model door de get_output()-functie te gebruiken om een Model-object te retourneren.

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

Model implementeren

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

De InferenceConfig klasse is voor configuratie-instellingen die de omgeving beschrijven die nodig is om het model en de webservice te hosten.

Webservice is de abstracte bovenliggende klasse voor het creëren en implementeren van webservices voor uw modellen. Zie deze instructies voor een gedetailleerde handleiding over het voorbereiden van modelimplementatie en het implementeren van webservices.

U kunt omgevingen gebruiken wanneer u uw model als een webservice implementeert. Omgevingen maken een reproduceerbare, verbonden werkstroom mogelijk, waarin u uw model kunt implementeren met behulp van dezelfde bibliotheken in zowel uw trainings- als deductieberekening. Intern worden omgevingen geïmplementeerd als Docker-installatiekopieën. U kunt installatiekopieën van Microsoft gebruiken of uw eigen aangepaste Docker-installatiekopieën gebruiken. Als u eerder de ContainerImage klasse voor uw implementatie gebruikte, raadpleegt u de klasse voor het DockerSection uitvoeren van een vergelijkbare werkstroom met omgevingen.

Als u een webservice wilt implementeren, combineert u de omgeving, deductieberekening, het scorescript en het geregistreerde model in uw implementatieobject, deploy().

In het volgende voorbeeld wordt ervan uitgegaan dat u al een trainingsuitvoering hebt uitgevoerd met behulp van de omgeving, myenv, en dat u dat model wilt implementeren in 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)

In dit voorbeeld wordt een Azure Container Instances-webservice gemaakt, die het best geschikt is voor kleinschalig testen en snelle implementaties. Gebruik Azure Kubernetes Service (AKS) om uw model te implementeren als een webservice op productieschaal. Raadpleeg AksCompute class voor meer informatie.

Gegevensset

Naamruimte: azureml.core.dataset.Dataset
Naamruimte: azureml.data.file_dataset.FileDataset
Naamruimte: azureml.data.tabular_dataset.TabularDataset

De Dataset-klasse is een fundamentele resource voor het verkennen en beheren van gegevens binnen Azure Machine Learning. U kunt uw gegevens verkennen met samenvattende statistieken, en de gegevensset opslaan in uw AML-werkruimte om versiebeheer en reproduceerbaarheidsmogelijkheden te krijgen. Gegevenssets kunnen tijdens de training gemakkelijk door de modellen worden verbruikt. Raadpleeg de instructiegids voor gedetailleerde gebruiksvoorbeelden.

  • TabularDataset vertegenwoordigt gegevens in een tabelindeling die is gemaakt door een bestand of lijst met bestanden te parseren.
  • FileDataset verwijst naar een of meer bestanden in gegevensopslag of van openbare URL's.

In het volgende voorbeeld ziet u hoe u een TabularDataset kunt maken die verwijst naar één pad in een gegevensopslag.

from azureml.core import Dataset

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

In het volgende voorbeeld ziet u hoe u een FileDataset maakt die verwijst naar meerdere bestands-URL's.

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)

Volgende stappen

Doe het volgende om te leren hoe u de Azure Machine Learning-SDK voor Python kunt gebruiken:

  • Volg de zelfstudie om te leren hoe u een model in Python kunt bouwen, trainen en implementeren.

  • Zoek klassen en modules op in de referentiedocumentatie op deze site door gebruik te maken van de inhoudsopgave aan de linkerkant.