Wat is de Azure Machine Learning-SDK voor Python?

  • Artikel
  • 17 minuten om te lezen

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 met de service werken in elke Python-omgeving, zoals 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.
  • Automatische machine learning gebruiken, waarmee configuratie parameters en trainings gegevens worden geaccepteerd. 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.

Stabiele functies

De stabiele functies worden aanbevolen voor de meeste gebruiks scenario's en productie omgevingen. Ze worden minder vaak bijgewerkt dan experimentele functies.

Experimentele functies (ontwikkeling)

De experimentele functies zijn nieuw ontwikkelde mogelijkheden & updates die mogelijk niet gereed zijn of volledig getest zijn voor productie gebruik. Hoewel de functies normaal werken, kunnen ze een aantal belang rijke wijzigingen bevatten. Experimentele functies worden gebruikt om SDK-breuk fouten te verstrijken en zullen alleen updates ontvangen voor de duur van de test periode.

Zoals de naam aangeeft, zijn de experimentele functies voor het experimenteren en worden deze niet als bug gratis of stabiel beschouwd. Daarom raden wij alleen experimentele functies aan voor geavanceerde gebruikers die vroege versies van mogelijkheden en updates willen uitproberen, en willen deel nemen aan de rapportage van bugs en storingen.

Experimentele functies worden gekenmerkt door een notitie sectie in de SDK-verwijzing.

Werkruimte

Naam ruimte: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.

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

Naam ruimte: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

Naam ruimte: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

Naam ruimte: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

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

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

Naam ruimte:azureml.core.environment

In Azure Machine Learning omgevingen worden de Python-pakketten, omgevings variabelen en software-instellingen voor uw trainings-en Score scripts opgegeven. Naast python kunt u ook PySpark, docker en R configureren voor omgevingen. Interne omgevingen resulteren in docker-installatie kopieën die worden gebruikt voor het uitvoeren van de trainings-en Score processen op het berekenings doel. De omgevingen zijn beheerde en geversiede entiteiten in uw Machine Learning-werk ruimte waarmee u reproduceer bare, audit bare en Portable machine learning werk stromen kunt maken in verschillende reken doelen en reken typen.

U kunt een Environment object gebruiken voor het volgende:

  • Ontwikkel uw trainings script.
  • Gebruik dezelfde omgeving op Azure Machine Learning Compute for model-training op schaal.
  • Implementeer uw model met dezelfde omgeving zonder te zijn gekoppeld aan een specifiek reken type.

Met de volgende code wordt de Environment klasse uit de SDK geïmporteerd en wordt een omgevings object geïnstantieerd.

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

Voeg pakketten toe aan een omgeving met behulp van Conda-, PIP-of privé-wiel bestanden. Geef elke pakket afhankelijkheid op met behulp van de- CondaDependency klasse om deze toe te voegen aan de omgeving PythonSection .

In het volgende voor beeld wordt toegevoegd aan de omgeving. Er wordt versie 1.17.0 van toegevoegd numpy . Ook het pakket wordt toegevoegd pillow aan de omgeving myenv . In het voor beeld worden add_conda_package() respectievelijk de 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 trainings uitvoering wilt verzenden, moet u uw omgeving, het reken doelen het python-script van uw training combi neren in een uitvoerings configuratie. Deze configuratie is een wrapper-object dat wordt gebruikt voor het verzenden van uitvoeringen.

Wanneer u een trainings uitvoering verzendt, kan het maken 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. Als de omgevings definitie ongewijzigd blijft, maakt u de volledige instel tijd slechts één keer.

In het volgende voor beeld ziet u waar u gebruikt ScriptRunConfig als uw wrapper-object.

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 uitvoerings configuratie voordat u de uitvoering verzendt, wordt er een standaard omgeving voor u gemaakt.

Zie de sectie model implementeren voor het gebruik van omgevingen voor het implementeren van een webservice.

Pipeline, PythonScriptStep

Naam ruimte:azureml.pipeline.core.pipeline.Pipeline
Naam ruimte: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 pijp lijn is gekoppeld aan een Azure Machine Learning-werk ruimte en een pijplijn stap is gekoppeld aan een berekenings doel dat in die werk ruimte beschikbaar is. 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-gegevens archief 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

Naam ruimte: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 zwarte/witte lijst
  • 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

Naam ruimte:azureml.core.model.InferenceConfig
Naam ruimte:azureml.core.webservice.webservice.Webservice

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

Webservice is de abstracte bovenliggende klasse voor het creëren en implementeren van webservices voor uw modellen. Voor een gedetailleerde hand leiding over het voorbereiden van model implementatie en het implementeren van webservices raadpleegt u deze How to.

U kunt omgevingen gebruiken wanneer u uw model als een webservice implementeert. Omgevingen bieden een reproduceer bare, verbonden werk stroom waar u uw model kunt implementeren met dezelfde bibliotheken in zowel uw trainings Compute als uw berekenings berekening. Intern worden omgevingen geïmplementeerd als docker-installatie kopieën. U kunt ofwel installatie kopieën van micro soft gebruiken, of uw eigen aangepaste docker-installatie kopieën gebruiken. Als u eerder de-klasse hebt gebruikt ContainerImage voor uw implementatie, raadpleegt u de DockerSection klasse voor het uitvoeren van een vergelijk bare werk stroom met omgevingen.

Als u een webservice wilt implementeren, combineert u de omgeving, verlaagt u de reken kracht, het Score script en het geregistreerde model in uw implementatie object deploy() .

In het volgende voor beeld wordt ervan uitgegaan dat u al een training hebt uitgevoerd met behulp van de omgeving, myenv en 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

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

  • TabularDatasetDit object vertegenwoordigt gegevens in een tabellaire indeling die is gemaakt door het parseren van een bestand of lijst met bestanden.
  • 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 voor beeld ziet u hoe u een FileDataset verwijzing naar meerdere bestands-url's maakt.

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.