Wat is de Azure Machine Learning-SDK voor Python?What is the Azure Machine Learning SDK for Python?

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.Data scientists and AI developers use the Azure Machine Learning SDK for Python to build and run machine learning workflows with the 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.You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE.

De belangrijkste functies van de SDK zijn:Key areas of the SDK include:

  • De levenscyclus van uw gegevenssets die worden gebruikt in machine learning-experimenten verkennen, voorbereiden en beheren.Explore, prepare and manage the lifecycle of your datasets used in machine learning experiments.
  • Cloudresources voor het bewaken, loggen en organiseren van uw machine-leerexperimenten beheren.Manage cloud resources for monitoring, logging, and organizing your machine learning experiments.
  • Modellen trainen, lokaal of met behulp van cloudresources, inclusief GPU-versnelde modeltraining.Train models either locally or by using cloud resources, including GPU-accelerated model training.
  • Automatische machine learning gebruiken, waarmee configuratie parameters en trainings gegevens worden geaccepteerd.Use automated machine learning, which accepts configuration parameters and training data. Er worden automatisch algoritmen en hyperparameter-instellingen doorlopen om het beste model voor het uitvoeren van voorspellingen te vinden.It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions.
  • Webservices implementeren om uw getrainde modellen om te zetten in RESTful-services die in elke toepassing kunnen worden gebruikt.Deploy web services to convert your trained models into RESTful services that can be consumed in any application.

Raadpleeg de zelfstudie voor een stapsgewijze uitleg over hoe u aan de slag kunt gaan.For a step-by-step walkthrough of how to get started, try the tutorial.

De volgende secties bevatten overzichten van een aantal van de belangrijkste klassen in de SDK en veelgebruikte ontwerppatronen voor het gebruik ervan.The following sections are overviews of some of the most important classes in the SDK, and common design patterns for using them. Raadpleeg de installatiehandleiding voor het downloaden van de SDK.To get the SDK, see the installation guide.

Stabiel versus experimenteelStable vs experimental

De Azure Machine Learning SDK voor python biedt zowel stabiele als experimentele functies in dezelfde SDK.The Azure Machine Learning SDK for Python provides both stable and experimental features in the same SDK.

Stabiele functiesStable features

De stabiele functies worden aanbevolen voor de meeste gebruiks scenario's en productie omgevingen.The stable features are recommended for most use cases and production environments. Ze worden minder vaak bijgewerkt dan experimentele functies.They are updated less frequently then experimental features.

Experimentele functies (ontwikkeling)Experimental features (developmental)

De experimentele functies zijn nieuw ontwikkelde mogelijkheden & updates die mogelijk niet gereed zijn of volledig getest zijn voor productie gebruik.The experimental features are newly developed capabilities & updates that may not be ready or fully tested for production usage. Hoewel de functies normaal werken, kunnen ze een aantal belang rijke wijzigingen bevatten.While the features are typically functional, they can include some breaking changes. Experimentele functies worden gebruikt om SDK-breuk fouten te verstrijken en zullen alleen updates ontvangen voor de duur van de test periode.Experimental features are used to iron out SDK breaking bugs, and will only receive updates for the duration of the testing period.

Zoals de naam aangeeft, zijn de experimentele functies voor het experimenteren en worden deze niet als bug gratis of stabiel beschouwd.As the name indicates, the experimental features are for experimenting and is not considered bug free or stable. 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.For this reason, we only recommend experimental features to advanced users who wish to try out early versions of capabilities and updates, and intend to participate in the reporting of bugs and glitches.

Experimentele functies worden gekenmerkt door een notitie sectie in de SDK-verwijzing.Experimental features are labelled by a note section in the SDK reference.

WerkruimteWorkspace

Naam ruimte:azureml.core.workspace.WorkspaceNamespace: 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.The Workspace class is a foundational resource in the cloud that you use to experiment, train, and deploy machine learning models. De klasse bindt uw Azure-abonnement en resourcegroep aan een eenvoudig te verbruiken object.It ties your Azure subscription and resource group to an easily consumed object.

Importeer de klasse en maak een nieuwe werkruimte met behulp van de volgende code.Import the class and create a new workspace by using the following code. Stel create_resource_group in op False als u een bestaande Azure-resourcegroep hebt die u wilt gebruiken voor de werkruimte.Set create_resource_group to False if you have a previously existing Azure resource group that you want to use for the workspace. Bij sommige functies wordt u mogelijk gevraagd om Azure-verificatiereferenties.Some functions might prompt for Azure authentication credentials.

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.Use the same workspace in multiple environments by first writing it to a configuration JSON file. Hiermee worden de gegevens van uw abonnement, resource en werkruimtenaam opgeslagen.This saves your subscription, resource, and workspace name data.

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

Laad uw werkruimte door het configuratiebestand te lezen.Load your workspace by reading the configuration file.

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.Alternatively, use the static get() method to load an existing workspace without using configuration files.

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.The variable ws represents a Workspace object in the following code examples.

ExperimentExperiment

Naam ruimte:azureml.core.experiment.ExperimentNamespace: azureml.core.experiment.Experiment

De klasse Experiment is een andere basiscloudresource die een verzameling proeven vertegenwoordigt (afzonderlijke modeluitvoeringen).The Experiment class is another foundational cloud resource that represents a collection of trials (individual model runs). Met de volgende code wordt een Experiment-object op naam opgehaald uit Workspace of een nieuw Experiment-object gemaakt als de naam niet bestaat.The following code fetches an Experiment object from within Workspace by name, or it creates a new Experiment object if the name doesn't exist.

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.Run the following code to get a list of all Experiment objects contained in Workspace.

list_experiments = Experiment.list(ws)

Gebruik de functie get_runs om een lijst met Run-objecten (proeven) op te halen uit Experiment.Use the get_runs function to retrieve a list of Run objects (trials) from Experiment. Met de volgende code worden de uitvoeringen opgehaald en wordt elke run-ID afgedrukt.The following code retrieves the runs and prints each run ID.

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

Er zijn twee manieren om een experimentproef uit te voeren.There are two ways to execute an experiment trial. Als u interactief wilt experimenteren in een Jupyter-notebook, gebruikt u de functie start_logging.If you're interactively experimenting in a Jupyter notebook, use the start_logging function. Als u een experiment wilt versturen vanuit een standaard Python-omgeving, gebruikt u de functie submit.If you're submitting an experiment from a standard Python environment, use the submit function. Met beide functies wordt een Run-object geretourneerd.Both functions return a Run object. De variabele experiment vertegenwoordigt een Experiment-object in de volgende codevoorbeelden.The experiment variable represents an Experiment object in the following code examples.

UitvoerenRun

Naam ruimte:azureml.core.run.RunNamespace: azureml.core.run.Run

Een uitvoering vertegenwoordigt één proef van een experiment.A run represents a single trial of an 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.Run is the object that you use to monitor the asynchronous execution of a trial, store the output of the trial, analyze results, and access generated artifacts. U gebruikt Run in uw experimentcode om metrische gegevens en artefacten vast te leggen in de uitvoeringsgeschiedenisservice.You use Run inside your experimentation code to log metrics and artifacts to the Run History service. De functionaliteit omvat:Functionality includes:

  • Metrische en andere gegevens opslaan en ophalen.Storing and retrieving metrics and data.
  • Tags en de onderliggende hiërarchie gebruiken om eerdere uitvoeringen eenvoudig op te zoeken.Using tags and the child hierarchy for easy lookup of past runs.
  • Opgeslagen modelbestanden registreren voor implementatie.Registering stored model files for deployment.
  • De eigenschappen van een uitvoering opslaan, wijzigen en ophalen.Storing, modifying, and retrieving properties of a run.

Een Run-object maken door een Experiment-object in te dienen met een uitvoeringsconfiguratie-object.Create a Run object by submitting an Experiment object with a run configuration object. De parameter tags gebruiken om aangepaste categorieën en labels aan uw uitvoeringen te koppelen.Use the tags parameter to attach custom categories and labels to your runs. U kunt ze later gemakkelijk vinden en ophalen uit Experiment.You can easily find and retrieve them later from 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.Use the static list function to get a list of all Run objects from Experiment. Geef de parameter tags op om te filteren op uw eerder gemaakte tag.Specify the tags parameter to filter by your previously created 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.Use the get_details function to retrieve the detailed output for the run.

run_details = run.get_details()

De uitvoer voor deze functie is een woordenlijst die het volgende bevat:Output for this function is a dictionary that includes:

  • Uitvoerings-idRun ID
  • StatusStatus
  • Begin- en eindtijdStart and end time
  • Rekendoel (lokaal versus cloud)Compute target (local versus cloud)
  • In de uitvoering gebruikte afhankelijkheden en versiesDependencies and versions used in the run
  • Trainingsspecifieke gegevens (afhankelijk van het modeltype)Training-specific data (differs depending on model type)

Raadpleeg de instructies voor meer voorbeelden van het configureren en bewaken van uitvoeringen.For more examples of how to configure and monitor runs, see the how-to.

ModelModel

Naam ruimte:azureml.core.model.ModelNamespace: azureml.core.model.Model

De klasse Model wordt gebruikt voor het werken met cloudrepresentaties van machine learning-modellen.The Model class is used for working with cloud representations of machine learning models. Met methoden kunt u modellen overdragen tussen lokale ontwikkelomgevingen en het Workspace-object in de cloud.Methods help you transfer models between local development environments and the Workspace object in the cloud.

U kunt modelregistratie gebruiken om uw modellen op te slaan en de versies ervan te beheren in uw werkruimte in de Azure-cloud.You can use model registration to store and version your models in the Azure cloud, in your workspace. Geregistreerde modellen worden geïdentificeerd met naam en versie.Registered models are identified by name and version. Telkens wanneer u een model registreert met dezelfde naam als een bestaand model, wordt de versie in het register verhoogd.Each time you register a model with the same name as an existing one, the registry increments the version. Azure Machine Learning ondersteunt elk model dat kan worden geladen via python 3, niet alleen Azure Machine Learning modellen.Azure Machine Learning supports any model that can be loaded through Python 3, not just Azure Machine Learning models.

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.The following example shows how to build a simple local classification model with scikit-learn, register the model in Workspace, and download the model from the cloud.

Maak een eenvoudige classificatie, clf, om het verloop van klanten te voorspellen op basis van hun leeftijd.Create a simple classifier, clf, to predict customer churn based on their age. Dump het model vervolgens naar een .pkl-bestand in dezelfde directory.Then dump the model to a .pkl file in the same 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.Use the register function to register the model in your workspace. Geef het pad naar het lokale model en de naam van het model op.Specify the local model path and the model name. Als dezelfde naam meer dan één keer wordt geregistreerd, wordt er een nieuwe versie gemaakt.Registering the same name more than once will create a new version.

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.Now that the model is registered in your workspace, it's easy to manage, download, and organize your models. 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.To retrieve a model (for example, in another environment) object from Workspace, use the class constructor and specify the model name and any optional parameters. Gebruik vervolgens de functie download om het model te downloaden, met inbegrip van de cloudmapstructuur.Then, use the download function to download the model, including the cloud folder structure.

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.Use the delete function to remove the model from Workspace.

model.delete()

Wanneer u een geregistreerd model hebt, is het implementeren van de service als een webservice een eenvoudig proces.After you have a registered model, deploying it as a web service is a straightforward process. Eerst maakt en registreert u een installatiekopie.First you create and register an image. 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.This step configures the Python environment and its dependencies, along with a script to define the web service request and response formats. Nadat u een installatiekopie hebt gemaakt, maakt u een implementatieconfiguratie die de CPU-kernen en de geheugenparameters voor het rekendoel instelt.After you create an image, you build a deploy configuration that sets the CPU cores and memory parameters for the compute target. Vervolgens koppelt u uw installatiekopie.You then attach your image.

ComputeTarget, RunConfiguration en ScriptRunConfigComputeTarget, RunConfiguration, and ScriptRunConfig

Naam ruimte:azureml.core.compute.ComputeTargetNamespace: azureml.core.compute.ComputeTarget
Naam ruimte:azureml.core.runconfig.RunConfigurationNamespace: azureml.core.runconfig.RunConfiguration
Naam ruimte:azureml.core.script_run_config.ScriptRunConfigNamespace: azureml.core.script_run_config.ScriptRunConfig

De klasse ComputeTarget is de abstracte bovenliggende klasse voor het maken en beheren van rekendoelen.The ComputeTarget class is the abstract parent class for creating and managing compute targets. Een rekendoel vertegenwoordigt een aantal resources waarmee u uw machine learning modellen kunt trainen.A compute target represents a variety of resources where you can train your machine learning models. Een rekendoel kan een lokale machine of een cloudresource zijn, zoals Azure Machine Learning Compute, Azure HDInsight of een externe virtuele machine.A compute target can be either a local machine or a cloud resource, such as Azure Machine Learning Compute, Azure HDInsight, or a remote virtual machine.

Gebruik rekendoelen om te profiteren van krachtige virtuele machines voor modeltraining en stel persistente rekendoelen of tijdelijke, door runtime aangeroepen doelen in.Use compute targets to take advantage of powerful virtual machines for model training, and set up either persistent compute targets or temporary runtime-invoked targets. Raadpleeg de instructies voor een uitgebreide handleiding voor het instellen en beheren van rekendoelen.For a comprehensive guide on setting up and managing compute targets, see the how-to.

De volgende code toont een eenvoudig voorbeeld van het instellen van een AmlCompute-doel (onderliggende klasse van ComputeTarget).The following code shows a simple example of setting up an AmlCompute (child class of ComputeTarget) target. Met dit doel maakt u een externe runtime-rekenresource in uw Workspace-object.This target creates a runtime remote compute resource in your Workspace object. De resource wordt automatisch geschaald wanneer er een taak wordt ingediend.The resource scales automatically when a job is submitted. De resource wordt automatisch verwijderd wanneer de uitvoering is voltooid.It's deleted automatically when the run finishes.

Gebruik het eenvoudige scikit-learn-verloopmodel opnieuw en maak er een eigen bestand, train.py, van in de huidige map.Reuse the simple scikit-learn churn model and build it into its own file, train.py, in the current directory. Maak aan het einde van het bestand een nieuwe directory met de naam outputs.At the end of the file, create a new directory called 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.This step creates a directory in the cloud (your workspace) to store your trained model that joblib.dump() serialized.

# 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.Next you create the compute target by instantiating a RunConfiguration object and setting the type and size. In dit voorbeeld wordt de kleinste resourcegrootte gebruikt (1 CPU-kern, 3,5 GB geheugen).This example uses the smallest resource size (1 CPU core, 3.5 GB of memory). De variabele list_vms bevat een lijst met ondersteunde virtuele machines en hun grootte.The list_vms variable contains a list of supported virtual machines and their sizes.

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.Create dependencies for the remote compute resource's Python environment by using the CondaDependencies class. Het bestand train.py maakt gebruik van scikit-learn en numpy, die in de omgeving moeten worden geïnstalleerd.The train.py file is using scikit-learn and numpy, which need to be installed in the environment. U kunt ook versies van afhankelijkheden opgeven.You can also specify versions of dependencies. Gebruik het dependencies-object om de omgeving in compute_config in te stellen.Use the dependencies object to set the environment in 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

U bent nu klaar om het experiment in te dienen.Now you're ready to submit the experiment. 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.Use the ScriptRunConfig class to attach the compute target configuration, and to specify the path/file to the training script train.py. Verzend het experiment door de parameter config van de functie submit() op te geven.Submit the experiment by specifying the config parameter of the submit() function. 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.Call wait_for_completion on the resulting run to see asynchronous run output as the environment is initialized and the model is trained.

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.After the run finishes, the trained model file churn-model.pkl is available in your workspace.

OmgevingEnvironment

Naam ruimte:azureml.core.environmentNamespace: azureml.core.environment

In Azure Machine Learning omgevingen worden de Python-pakketten, omgevings variabelen en software-instellingen voor uw trainings-en Score scripts opgegeven.Azure Machine Learning environments specify the Python packages, environment variables, and software settings around your training and scoring scripts. Naast python kunt u ook PySpark, docker en R configureren voor omgevingen.In addition to Python, you can also configure PySpark, Docker and R for environments. Interne omgevingen resulteren in docker-installatie kopieën die worden gebruikt voor het uitvoeren van de trainings-en Score processen op het berekenings doel.Internally, environments result in Docker images that are used to run the training and scoring processes on the compute target. 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.The environments are managed and versioned entities within your Machine Learning workspace that enable reproducible, auditable, and portable machine learning workflows across a variety of compute targets and compute types.

U kunt een Environment object gebruiken voor het volgende:You can use an Environment object to:

  • Ontwikkel uw trainings script.Develop your training script.
  • Gebruik dezelfde omgeving op Azure Machine Learning Compute for model-training op schaal.Reuse the same environment on Azure Machine Learning Compute for model training at scale.
  • Implementeer uw model met dezelfde omgeving zonder te zijn gekoppeld aan een specifiek reken type.Deploy your model with that same environment without being tied to a specific compute type.

Met de volgende code wordt de Environment klasse uit de SDK geïmporteerd en wordt een omgevings object geïnstantieerd.The following code imports the Environment class from the SDK and to instantiates an environment object.

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

Voeg pakketten toe aan een omgeving met behulp van Conda-, PIP-of privé-wiel bestanden.Add packages to an environment by using Conda, pip, or private wheel files. Geef elke pakket afhankelijkheid op met behulp van de- CondaDependency klasse om deze toe te voegen aan de omgeving PythonSection .Specify each package dependency by using the CondaDependency class to add it to the environment's PythonSection.

In het volgende voor beeld wordt toegevoegd aan de omgeving.The following example adds to the environment. Er wordt versie 1.17.0 van toegevoegd numpy .It adds version 1.17.0 of numpy. Ook het pakket wordt toegevoegd pillow aan de omgeving myenv .It also adds the pillow package to the environment, myenv. In het voor beeld worden add_conda_package() respectievelijk de methode en de add_pip_package() methode gebruikt.The example uses the add_conda_package() method and the add_pip_package() method, respectively.

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.To submit a training run, you need to combine your environment, compute target, and your training Python script into a run configuration. Deze configuratie is een wrapper-object dat wordt gebruikt voor het verzenden van uitvoeringen.This configuration is a wrapper object that's used for submitting runs.

Wanneer u een trainings uitvoering verzendt, kan het maken van een nieuwe omgeving enkele minuten duren.When you submit a training run, the building of a new environment can take several minutes. De duur is afhankelijk van de grootte van de vereiste afhankelijkheden.The duration depends on the size of the required dependencies. De omgevingen worden in de cache opgeslagen door de service.The environments are cached by the service. Als de omgevings definitie ongewijzigd blijft, maakt u de volledige instel tijd slechts één keer.So as long as the environment definition remains unchanged, you incur the full setup time only once.

In het volgende voor beeld ziet u waar u gebruikt ScriptRunConfig als uw wrapper-object.The following example shows where you would use ScriptRunConfig as your 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.If you don't specify an environment in your run configuration before you submit the run, then a default environment is created for you.

Zie de sectie model implementeren voor het gebruik van omgevingen voor het implementeren van een webservice.See the Model deploy section to use environments to deploy a web service.

Pipeline, PythonScriptStepPipeline, PythonScriptStep

Naam ruimte:azureml.pipeline.core.pipeline.PipelineNamespace: azureml.pipeline.core.pipeline.Pipeline
Naam ruimte:azureml.pipeline.steps.python_script_step.PythonScriptStepNamespace: azureml.pipeline.steps.python_script_step.PythonScriptStep

Een Azure Machine Learning pijplijn is een geautomatiseerde werkstroom van een volledige machine learning-taak.An Azure Machine Learning pipeline is an automated workflow of a complete machine learning task. Subtaken worden ingekapseld als een reeks stappen in de pijplijn.Subtasks are encapsulated as a series of steps within the pipeline. Een Azure Machine Learning-pijplijn kan zo eenvoudig zijn als één stap die een Python-script aanroept.An Azure Machine Learning pipeline can be as simple as one step that calls a Python script. Pijplijnen bevatten functionaliteit voor:Pipelines include functionality for:

  • Gegevensvoorbereiding, waaronder importeren, valideren en opschonen, munging en transformatie, normalisatie en faseringData preparation including importing, validating and cleaning, munging and transformation, normalization, and staging
  • Trainingsconfiguratie met inbegrip van parameteriseren van argumenten, bestandspaden en logboek-/rapportageconfiguratieTraining configuration including parameterizing arguments, filepaths, and logging / reporting configurations
  • Training en validatie op efficiënte en herhaalbare wijze, waaronder het opgeven van specifieke gegevenssubsets, verschillende hardware-rekenresources, gedistribueerde verwerking en voortgangsbewakingTraining and validating efficiently and repeatably, which might include specifying specific data subsets, different hardware compute resources, distributed processing, and progress monitoring
  • Implementatie, inclusief versiebeheer, schalen, inrichten en toegangsbeheerDeployment, including versioning, scaling, provisioning, and access control
  • Een pijplijn naar een REST-eindpunt publiceren om opnieuw uit te voeren vanuit HTTP-bibliothekenPublishing a pipeline to a REST endpoint to rerun from any HTTP library

Een PythonScriptStep is een ingebouwde basisstap voor het uitvoeren van een Python-script op een rekendoel.A PythonScriptStep is a basic, built-in step to run a Python Script on a compute target. Het maakt gebruik van een scriptnaam en andere optionele parameters, zoals argumenten voor het script, rekendoel, in- en uitvoer.It takes a script name and other optional parameters like arguments for the script, compute target, inputs and outputs. De volgende code is een eenvoudig voorbeeld van een PythonScriptStep.The following code is a simple example of a PythonScriptStep. Raadpleeg de subsectie zelfstudie voor een voorbeeld van een train.py-script.For an example of a train.py script, see the tutorial sub-section.

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.After at least one step has been created, steps can be linked together and published as a simple automated pipeline.

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.For a comprehensive example of building a pipeline workflow, follow the advanced tutorial.

Patroon voor het maken en gebruiken van pijplijnenPattern for creating and using pipelines

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.An Azure Machine Learning pipeline is associated with an Azure Machine Learning workspace and a pipeline step is associated with a compute target available within that workspace. Raadpleeg voor meer informatie dit artikel over werkruimten of deze uitleg over rekendoelen.For more information, see this article about workspaces or this explanation of compute targets.

Een veelvoorkomend patroon voor pijplijnstappen is:A common pattern for pipeline steps is:

  1. Werkruimte, compute en opslag opgevenSpecify workspace, compute, and storage
  2. Uw invoer- en uitvoergegevens configureren met behulp vanConfigure your input and output data using
    1. Gegevensset die een bestaand Azure-gegevens archief beschikbaar maaktDataset which makes available an existing Azure datastore
    2. PipelineDataset, waardoor getypte tabellaire gegevens worden ingekapseldPipelineDataset which encapsulates typed tabular data
    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 stapPipelineData which is used for intermediate file or directory data written by one step and intended to be consumed by another
  3. Een of meer pijplijnstappen definiërenDefine one or more pipeline steps
  4. Een pijplijn instantiëren met behulp van uw werkruimte en stappenInstantiate a pipeline using your workspace and steps
  5. Een experiment maken waarbij u de pijplijn indientCreate an experiment to which you submit the pipeline
  6. De resultaten van het experiment bewakenMonitor the experiment results

Dit notitieblok is een goed voorbeeld van dit patroon.This notebook is a good example of this pattern. taakjob

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.For more information about Azure Machine Learning Pipelines, and in particular how they are different from other types of pipelines, see this article.

AutoMLConfigAutoMLConfig

Naam ruimte:azureml.train.automl.automlconfig.AutoMLConfigNamespace: azureml.train.automl.automlconfig.AutoMLConfig

Gebruik de klasse AutoMLConfig om parameters te configureren voor automatische machine learning-training.Use the AutoMLConfig class to configure parameters for automated machine learning training. Automatische machine learning doorloopt een groot aantal combinaties van machine learning-algoritmen en hyperparameterinstellingen.Automated machine learning iterates over many combinations of machine learning algorithms and hyperparameter settings. Vervolgens wordt het beste model gevonden op basis van uw gekozen metrische gegevens voor nauwkeurigheid.It then finds the best-fit model based on your chosen accuracy metric. Met de configuratie kunt u het volgende opgeven:Configuration allows for specifying:

  • Taaktype (classificatie, regressie, prognose)Task type (classification, regression, forecasting)
  • Aantal algoritme-iteraties en maximumtijd per herhalingNumber of algorithm iterations and maximum time per iteration
  • Metrische gegevens voor nauwkeurigheid om te optimaliserenAccuracy metric to optimize
  • Algoritmen voor zwarte/witte lijstAlgorithms to blacklist/whitelist
  • Aantal kruisvalidatiesNumber of cross-validations
  • RekendoelenCompute targets
  • TrainingsgegevensTraining data

Notitie

Gebruik de extra automl in uw installatie om geautomatiseerde machine learning te gebruiken.Use the automl extra in your installation to use automated machine learning.

Raadpleeg de zelfstudie en instructies voor gedetailleerde handleidingen en voorbeelden van het opzetten van geautomatiseerde machine learning-experimenten.For detailed guides and examples of setting up automated machine learning experiments, see the tutorial and how-to.

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.The following code illustrates building an automated machine learning configuration object for a classification model, and using it when you're submitting an 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.Use the automl_config object to submit an experiment.

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.After you submit the experiment, output shows the training accuracy for each iteration as it finishes. Nadat de uitvoering is voltooid, wordt er een AutoMLRun-object (dat de Run-klasse uitbreidt) geretourneerd.After the run is finished, an AutoMLRun object (which extends the Run class) is returned. Zoek het best passende model door de get_output()-functie te gebruiken om een Model-object te retourneren.Get the best-fit model by using the get_output() function to return a Model object.

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

Model implementerenModel deploy

Naam ruimte:azureml.core.model.InferenceConfigNamespace: azureml.core.model.InferenceConfig
Naam ruimte:azureml.core.webservice.webservice.WebserviceNamespace: 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.The InferenceConfig class is for configuration settings that describe the environment needed to host the model and web service.

Webservice is de abstracte bovenliggende klasse voor het creëren en implementeren van webservices voor uw modellen.Webservice is the abstract parent class for creating and deploying web services for your models. Voor een gedetailleerde hand leiding over het voorbereiden van model implementatie en het implementeren van webservices raadpleegt u deze How to.For a detailed guide on preparing for model deployment and deploying web services, see this how-to.

U kunt omgevingen gebruiken wanneer u uw model als een webservice implementeert.You can use environments when you deploy your model as a web service. 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.Environments enable a reproducible, connected workflow where you can deploy your model using the same libraries in both your training compute and your inference compute. Intern worden omgevingen geïmplementeerd als docker-installatie kopieën.Internally, environments are implemented as Docker images. U kunt ofwel installatie kopieën van micro soft gebruiken, of uw eigen aangepaste docker-installatie kopieën gebruiken.You can use either images provided by Microsoft, or use your own custom Docker images. 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.If you were previously using the ContainerImage class for your deployment, see the DockerSection class for accomplishing a similar workflow with environments.

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() .To deploy a web service, combine the environment, inference compute, scoring script, and registered model in your deployment 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.The following example, assumes you already completed a training run using environment, myenv, and want to deploy that model to 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.This example creates an Azure Container Instances web service, which is best for small-scale testing and quick deployments. Gebruik Azure Kubernetes Service (AKS) om uw model te implementeren als een webservice op productieschaal.To deploy your model as a production-scale web service, use Azure Kubernetes Service (AKS). Raadpleeg AksCompute class voor meer informatie.For more information, see AksCompute class.

GegevenssetDataset

Naam ruimte:azureml.core.dataset.DatasetNamespace: azureml.core.dataset.Dataset
Naam ruimte:azureml.data.file_dataset.FileDatasetNamespace: azureml.data.file_dataset.FileDataset
Naam ruimte:azureml.data.tabular_dataset.TabularDatasetNamespace: azureml.data.tabular_dataset.TabularDataset

De Dataset-klasse is een fundamentele resource voor het verkennen en beheren van gegevens binnen Azure Machine Learning.The Dataset class is a foundational resource for exploring and managing data within 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.You can explore your data with summary statistics, and save the Dataset to your AML workspace to get versioning and reproducibility capabilities. Gegevenssets kunnen tijdens de training gemakkelijk door de modellen worden verbruikt.Datasets are easily consumed by models during training. Raadpleeg de instructiegids voor gedetailleerde gebruiksvoorbeelden.For detailed usage examples, see the how-to guide.

  • TabularDatasetDit object vertegenwoordigt gegevens in een tabellaire indeling die is gemaakt door het parseren van een bestand of lijst met bestanden.TabularDataset represents data in a tabular format created by parsing a file or list of files.
  • FileDataset verwijst naar een of meer bestanden in gegevensopslag of van openbare URL's.FileDataset references single or multiple files in datastores or from public URLs.

In het volgende voorbeeld ziet u hoe u een TabularDataset kunt maken die verwijst naar één pad in een gegevensopslag.The following example shows how to create a TabularDataset pointing to a single path in a datastore.

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.The following example shows how to create a FileDataset referencing multiple file URLs.

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 stappenNext steps

Doe het volgende om te leren hoe u de Azure Machine Learning-SDK voor Python kunt gebruiken:Try these next steps to learn how to use the Azure Machine Learning SDK for Python:

  • Volg de zelfstudie om te leren hoe u een model in Python kunt bouwen, trainen en implementeren.Follow the tutorial to learn how to build, train, and deploy a model in Python.

  • Zoek klassen en modules op in de referentiedocumentatie op deze site door gebruik te maken van de inhoudsopgave aan de linkerkant.Look up classes and modules in the reference documentation on this site by using the table of contents on the left.