Delen via

Wat is de Azure Machine Learning SDK v1 voor Python?

  • Artikel

Belangrijk

Dit artikel gaat over de Azure Machine Learning SDK v1, die niet de huidige SDK is. De huidige SDK-versie is de Azure Machine Learning Python SDK v2. Lees Upgrade naar v2voor informatie over verschillen tussen de SDK-versies.

Gegevenswetenschappers en AI-ontwikkelaars gebruiken de Azure Machine Learning SDK v1 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 Codeof uw favoriete Python IDE.

Belangrijke gebieden van de SDK zijn:

  • Verken, bereid en beheer de levenscyclus van uw gegevenssets die worden gebruikt in machine learning-experimenten.
  • Cloudresources beheren voor het bewaken, registreren en organiseren van uw machine learning-experimenten.
  • Train modellen lokaal of met behulp van cloudresources, waaronder gpu-versnelde modeltraining.
  • Gebruik geautomatiseerde machine learning, die configuratieparameters en trainingsgegevens accepteert. Het doorloopt automatisch algoritmen en hyperparameterinstellingen om het beste model voor het uitvoeren van voorspellingen te vinden.
  • Implementeer webservices om uw getrainde modellen te converteren naar RESTful-services die in elke toepassing kunnen worden gebruikt.

Probeer de zelfstudievoor stapsgewijze instructies voor het aan de slag gaan.

De volgende secties bevatten een overzicht van enkele van de belangrijkste klassen in de SDK en algemene ontwerppatronen voor het gebruik ervan. Zie de installatiehandleidingom de SDK op te halen.

Stabiel versus experimenteel

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

Functie-/functiestatus Beschrijving
Stabiele functies gereed voor productie

Deze functies worden aanbevolen voor de meeste gebruiksvoorbeelden 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 voor productiegebruik. Hoewel de functies doorgaans functioneel zijn, kunnen ze enkele belangrijke wijzigingen bevatten. Experimentele functies worden gebruikt om fouten die fouten veroorzaken in de SDK te verhelpen en ontvangen alleen updates voor de duur van de testperiode. Experimentele functies worden ook wel functies genoemd die zich in preview-bevinden.

Zoals de naam aangeeft, zijn de experimentele (preview)-functies bedoeld om te experimenteren en wordt niet beschouwd als foutvrij of stabiel. Daarom raden we alleen experimentele functies aan voor geavanceerde gebruikers die vroege versies van mogelijkheden en updates willen uitproberen en willen deelnemen aan de rapportage van bugs en glitches.

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

Werkruimte

naamruimte: azureml.core.workspace.Workspace

De Workspace-klasse is een basisresource in de cloud die u gebruikt om machine learning-modellen te experimenteren, te trainen en te implementeren. Het koppelt uw Azure-abonnement en resourcegroep aan een eenvoudig te gebruiken object.

Bekijk alle parameters van de methode Werkruimte maken 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 eerder bestaande Azure-resourcegroep hebt die u voor de werkruimte wilt gebruiken. Sommige functies vragen mogelijk om Referenties voor Azure-verificatie.

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 uw abonnements-, resource- en werkruimtenaamgegevens 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 configuratiebestanden 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 Experiment-klasse is een andere fundamentele cloudresource die een verzameling proefversies (afzonderlijke modeluitvoeringen) vertegenwoordigt. Met de volgende code wordt een Experiment object opgehaald uit Workspace op naam of wordt er 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 (proefversies) op te halen uit Experiment. Met de volgende code worden de uitvoeringen opgehaald en elke uitvoerings-id afgedrukt.

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

Er zijn twee manieren om een experimentversie uit te voeren. Als u interactief experimenteert in een Jupyter-notebook, gebruikt u de functie start_logging. Als u een experiment verzendt vanuit een standaard Python-omgeving, gebruikt u de functie submit. Beide functies retourneren een Run-object. De variabele experiment vertegenwoordigt een Experiment-object in de volgende codevoorbeelden.

Rennen

naamruimte: azureml.core.run.Run

Een uitvoering vertegenwoordigt één proefversie van een experiment. Run is het object dat u gebruikt om de asynchrone uitvoering van een proefversie te bewaken, de uitvoer van de proefversie op te slaan, resultaten te analyseren en gegenereerde artefacten te openen. U gebruikt Run in uw experimentencode om metrische gegevens en artefacten te registreren bij de run history-service. Functionaliteit omvat:

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

Maak een Run-object door een Experiment-object in te dienen met een configuratie object uit te voeren. Gebruik de parameter tags om aangepaste categorieën en labels toe te voegen aan uw uitvoeringen. 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 functie statische list om een lijst op te halen met alle Run objecten uit Experiment. Geef de parameter tags op om te filteren op de 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 voor de uitvoering op te halen.

run_details = run.get_details()

Uitvoer voor deze functie is een woordenlijst met:

  • Uitvoerings-id
  • Status
  • Begin- en eindtijd
  • Rekendoel (lokaal versus cloud)
  • Afhankelijkheden en versies die in de uitvoering worden gebruikt
  • Trainingspecifieke gegevens (verschilt afhankelijk van het modeltype)

Zie de instructies voorvoor meer voorbeelden van het configureren en bewaken van uitvoeringen.

Model

naamruimte: azureml.core.model.Model

De Model-klasse wordt gebruikt voor het werken met cloudweergaven van machine learning-modellen. Methoden helpen u modellen over te dragen tussen lokale ontwikkelomgevingen en het Workspace-object in de cloud.

U kunt modelregistratie gebruiken om uw modellen op te slaan en te versien in de Azure-cloud, in uw werkruimte. Geregistreerde modellen worden geïdentificeerd op naam en versie. Telkens wanneer u een model registreert met dezelfde naam als een bestaand model, wordt de versie 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 bouwt met scikit-learn, het model registreert in Workspaceen 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 map.

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 u dezelfde naam meerdere keren registreert, 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, kunt u uw modellen eenvoudig beheren, downloaden en organiseren. Als u een modelobject (bijvoorbeeld in een andere omgeving) wilt ophalen uit Workspace, gebruikt u de klasseconstructor en geeft u de modelnaam en eventuele optionele parameters op. Gebruik vervolgens de functie download om het model te downloaden, inclusief de structuur van de cloudmap.

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 uit Workspacete verwijderen.

model.delete()

Nadat u een geregistreerd model hebt, is het implementeren als een webservice een eenvoudig proces. Eerst u een installatiekopieënmaken en registreren. Met deze stap configureert u de Python-omgeving en de bijbehorende afhankelijkheden, samen met een script voor het definiëren van de aanvraag- en antwoordindelingen van de webservice. Nadat u een installatiekopieën hebt gemaakt, u een implementatieconfiguratie bouwen waarmee de CPU-kernen en geheugenparameters voor het rekendoel worden ingesteld. Vervolgens voegt u de afbeelding toe.

ComputeTarget, RunConfiguration en ScriptRunConfig

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

De ComputeTarget-klasse is de abstracte bovenliggende klasse voor het maken en beheren van rekendoelen. Een rekendoel vertegenwoordigt een verscheidenheid aan resources waar 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 permanente rekendoelen of tijdelijke runtime-aangeroepen doelen in. Zie de instructies voorvoor een uitgebreide handleiding over het instellen en beheren van rekendoelen.

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

Gebruik het eenvoudige scikit-learn verloopmodel opnieuw en bouw het in een eigen bestand, train.py, in de huidige map. Maak aan het einde van het bestand een nieuwe map met de naam outputs. Met deze stap maakt u een map in de cloud (uw werkruimte) om uw getrainde model op te slaan dat joblib.dump() 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 list_vms variabele bevat een lijst met ondersteunde virtuele machines en hun grootten.

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 CondaDependencies-klasse. Het train.py-bestand gebruikt 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_configin 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 ScriptRunConfig-klasse om de configuratie van het rekendoel te koppelen en om het pad/bestand op te geven aan het trainingsscript train.py. 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 uitvoeringsuitvoer te zien wanneer de omgeving wordt geïnitialiseerd en het model wordt getraind.

Waarschuwing

Hier volgen beperkingen voor specifieke tekens wanneer deze worden gebruikt in ScriptRunConfig parameters:

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

Milieu

naamruimte: azureml.core.environment

Azure Machine Learning-omgevingen geven de Python-pakketten, omgevingsvariabelen en software-instellingen op rond 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 om de trainings- en scoreprocessen op het rekendoel uit te voeren. De omgevingen zijn beheerde en versie-entiteiten in 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 om het volgende te doen:

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

Met de volgende code wordt de Environment-klasse uit de SDK geïmporteerd en wordt een omgevingsobject geïnstitueert.

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

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

Het volgende voorbeeld wordt toegevoegd aan de omgeving. Er wordt versie 1.17.0 van numpytoegevoegd. Het pillow pakket wordt ook toegevoegd aan de omgeving, myenv. In het voorbeeld worden respectievelijk de methode add_conda_package() 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 combineren, rekendoelen uw Python-trainingsscript 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, krijgt u slechts één keer de volledige installatietijd.

In het volgende voorbeeld ziet u waar u ScriptRunConfig als wrapper-object zou gebruiken.

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.

Pijplijn, 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 net 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, waaronder het parameteriseren van argumenten, bestandspaden en logboekregistratie/rapportageconfiguraties
  • Het trainen en valideren van efficiënt en herhaalbaar, waaronder het opgeven van specifieke gegevenssubsets, verschillende hardware-rekenresources, gedistribueerde verwerking en voortgangsbewaking
  • Implementatie, inclusief versiebeheer, schalen, inrichten en toegangsbeheer
  • Een pijplijn publiceren naar een REST-eindpunt om opnieuw uit te voeren vanuit een HTTP-bibliotheek

Een PythonScriptStep is een eenvoudige, ingebouwde stap voor het uitvoeren van een Python-script op een rekendoel. Hiervoor zijn een scriptnaam en andere optionele parameters nodig, zoals argumenten voor het script, rekendoel, invoer en uitvoer. De volgende code is een eenvoudig voorbeeld van een PythonScriptStep. Zie de zelfstudie subsectie 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 ten minste één stap is gemaakt, kunnen stappen worden gekoppeld en gepubliceerd als een eenvoudige geautomatiseerde pijplijn.

from azureml.pipeline.core import Pipeline

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

Volg de geavanceerde zelfstudievoor 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. Zie dit artikel over werkruimten of deze uitleg van rekendoelenvoor meer informatie.

Een veelvoorkomend patroon voor pijplijnstappen is:

  1. Werkruimte, berekening en opslag opgeven
  2. Uw invoer- en uitvoergegevens configureren met behulp van
    1. Dataset die een bestaand Azure-gegevensarchief beschikbaar maakt
    2. PipelineDataset waarin getypte tabelgegevens worden ingekapseld
    3. PipelineData- die wordt gebruikt voor tussenliggende bestand- of mapgegevens die in één stap zijn geschreven en bedoeld zijn voor gebruik door een andere
  3. Een of meer pijplijnstappen definiëren
  4. Een pijplijn instantiëren met behulp van uw werkruimte en stappen
  5. Een experiment maken waarmee u de pijplijn verzendt
  6. De resultaten van het experiment bewaken

Dit notitieblok is een goed voorbeeld van dit patroon. baan

Zie dit artikelvoor meer informatie over Azure Machine Learning-pijplijnen en met name over hoe deze verschillen van andere typen pijplijnen.

AutoMLConfig

naamruimte: azureml.train.automl.automlconfig.AutoMLConfig

Gebruik de AutoMLConfig-klasse om parameters te configureren voor geautomatiseerde machine learning-training. Geautomatiseerde machine learning doorloopt veel combinaties van machine learning-algoritmen en hyperparameterinstellingen. Vervolgens wordt het best passende model gevonden op basis van de metrische gegevens voor nauwkeurigheid die u hebt gekozen. Met configuratie kunt u het volgende opgeven:

  • Taaktype (classificatie, regressie, prognoses)
  • Aantal iteraties van algoritmen en maximale tijd per iteratie
  • Metrische gegevens voor nauwkeurigheid om te optimaliseren
  • Algoritmen voor het blokkeren/toestaan van een lijst
  • Aantal kruisvalidaties
  • Rekendoelen
  • Trainingsgegevens

Notitie

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

Voor gedetailleerde handleidingen en voorbeelden van het instellen van geautomatiseerde machine learning-experimenten, raadpleegt u de zelfstudie en instructies voor.

De volgende code illustreert het bouwen van een geautomatiseerd machine learning-configuratieobject voor een classificatiemodel en het gebruik ervan wanneer u een experiment verzendt.

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 te verzenden.

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 verzonden, toont de uitvoer de nauwkeurigheid van de training voor elke iteratie zodra het is voltooid. Nadat de uitvoering is voltooid, wordt een AutoMLRun object (dat de Run klasse uitbreidt) geretourneerd. Haal het best passende model op met behulp van de functie get_output() 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 bedoeld 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 maken en implementeren van webservices voor uw modellen. Zie deze instructies voor hetvoor een gedetailleerde handleiding over het voorbereiden van modelimplementatie en het implementeren van webservices.

U kunt omgevingen gebruiken wanneer u uw model als webservice implementeert. Omgevingen maken een reproduceerbare, verbonden werkstroom mogelijk, waar u uw model kunt implementeren met behulp van dezelfde bibliotheken in zowel uw trainings- als deductie-rekenkracht. 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 gebruikt, raadpleegt u de DockerSection-klasse voor het uitvoeren van een vergelijkbare werkstroom met omgevingen.

Als u een webservice wilt implementeren, combineert u de omgeving, deductie berekenen, scorescript en geregistreerd model in uw implementatieobject, deploy().

In het volgende voorbeeld wordt ervan uitgegaan dat u al een trainingsuitvoering hebt voltooid met behulp van de omgeving, myenven 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. Dit is het meest geschikt voor kleinschalige tests en snelle implementaties. Als u uw model wilt implementeren als een webservice op productieschaal, gebruikt u Azure Kubernetes Service (AKS). Zie klasse AksComputevoor meer informatie.

Dataset

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

De Dataset-klasse is een basisresource voor het verkennen en beheren van gegevens in Azure Machine Learning. U kunt uw gegevens verkennen met overzichtsstatistieken en de gegevensset opslaan in uw AML-werkruimte om versiebeheer- en reproduceermogelijkheden te verkrijgen. Gegevenssets worden eenvoudig gebruikt door modellen tijdens de training. Zie de handleidingvoor gedetailleerde gebruiksvoorbeelden.

  • TabularDataset vertegenwoordigt gegevens in tabelvorm die zijn gemaakt door een bestand of lijst met bestanden te parseren.
  • FileDataset verwijst naar één of meerdere bestanden in gegevensarchieven of vanuit openbare URL's.

In het volgende voorbeeld ziet u hoe u een TabularDataset maakt die verwijst naar één pad in een gegevensarchief.

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

Voer de volgende stappen uit om te leren hoe u de Azure Machine Learning SDK voor Python gebruikt:

  • Volg de zelfstudie voor meer informatie over het bouwen, trainen en implementeren van een model in Python.

  • Zoek klassen en modules op in de referentiedocumentatie op deze site met behulp van de inhoudsopgave aan de linkerkant.