Scikit trainen-modellen op schaal leren met Azure Machine LearningTrain scikit-learn models at scale with Azure Machine Learning

In dit artikel leert u hoe u uw scikit-trainings scripts kunt uitvoeren met Azure Machine Learning.In this article, learn how to run your scikit-learn training scripts with Azure Machine Learning.

De voorbeeld scripts in dit artikel worden gebruikt voor het classificeren van Iris bloem installatie kopieën om een machine learning model te bouwen op basis van de Iris-gegevenssetvan scikit-leer.The example scripts in this article are used to classify iris flower images to build a machine learning model based on scikit-learn's iris dataset.

Of u nu op de hoogte bent van een machine learning scikit-model of u een bestaand model in de Cloud hebt, kunt u Azure Machine Learning gebruiken om open-source trainings taken uit te schalen met behulp van elastische Cloud Compute-resources.Whether you're training a machine learning scikit-learn model from the ground-up or you're bringing an existing model into the cloud, you can use Azure Machine Learning to scale out open-source training jobs using elastic cloud compute resources. U kunt modellen voor productie kwaliteit bouwen, implementeren, versie en bewaken met Azure Machine Learning.You can build, deploy, version, and monitor production-grade models with Azure Machine Learning.

VereistenPrerequisites

Voer deze code uit in een van de volgende omgevingen:Run this code on either of these environments:

Het experiment instellenSet up the experiment

In deze sectie wordt het trainings experiment opgesteld door het laden van de vereiste Python-pakketten, het initialiseren van een werk ruimte, het definiëren van de trainings omgeving en het voorbereiden van het trainings script.This section sets up the training experiment by loading the required Python packages, initializing a workspace, defining the training environment, and preparing the training script.

Een werk ruimte initialiserenInitialize a workspace

De Azure machine learning werk ruimte is de resource op het hoogste niveau voor de service.The Azure Machine Learning workspace is the top-level resource for the service. Het biedt u een centrale locatie voor het werken met alle artefacten die u maakt.It provides you with a centralized place to work with all the artifacts you create. In de python-SDK hebt u toegang tot de werkruimte artefacten door een workspace object te maken.In the Python SDK, you can access the workspace artifacts by creating a workspace object.

Maak een werkruimte object op basis van het config.json bestand dat in de sectie vereistenis gemaakt.Create a workspace object from the config.json file created in the prerequisites section.

from azureml.core import Workspace

ws = Workspace.from_config()

Scripts voorbereidenPrepare scripts

In deze zelf studie is het trainings script train_iris. py al voor u beschikbaar.In this tutorial, the training script train_iris.py is already provided for you here. In de praktijk moet u een aangepast trainings script kunnen uitvoeren zoals dat is en dit kan worden uitgevoerd met Azure ML zonder dat u de code hoeft te wijzigen.In practice, you should be able to take any custom training script as is and run it with Azure ML without having to modify your code.

Opmerkingen:Notes:

  • In het meegeleverde trainings script ziet u hoe u met het Run object binnen het script enkele metrische gegevens registreert bij uw Azure ml-uitvoering.The provided training script shows how to log some metrics to your Azure ML run using the Run object within the script.
  • In het meegeleverde trainings script worden voorbeeld gegevens van de iris = datasets.load_iris() functie gebruikt.The provided training script uses example data from the iris = datasets.load_iris() function. Zie How to Train with data sets om gegevens beschikbaar te maken tijdens de training om uw eigen gegevens te gebruiken en te openen.To use and access your own data, see how to train with datasets to make data available during training.

Uw omgeving definiërenDefine your environment

Als u de Azure ML- omgeving wilt definiëren waarin de afhankelijkheden van uw trainings script worden ingekapseld, kunt u een aangepaste omgeving of gebruik en Azure ml-omgeving definiëren.To define the Azure ML Environment that encapsulates your training script's dependencies, you can either define a custom environment or use and Azure ML curated environment.

Een aangepaste omgeving makenCreate a custom environment

Als u uw eigen aangepaste omgeving wilt maken, definieert u de Conda-afhankelijkheden in een YAML-bestand. in dit voor beeld heeft het bestand de naam conda_dependencies.yml .To create your own custom environment, define your conda dependencies in a YAML file; in this example the file is named conda_dependencies.yml.

dependencies:
  - python=3.6.2
  - scikit-learn
  - numpy
  - pip:
    - azureml-defaults

Een Azure ML-omgeving maken op basis van deze Conda Environment-specificatie.Create an Azure ML environment from this Conda environment specification. De omgeving wordt tijdens runtime ingepakt in een docker-container.The environment will be packaged into a Docker container at runtime.

from azureml.core import Environment

sklearn_env = Environment.from_conda_specification(name='sklearn-env', file_path='conda_dependencies.yml')

Zie software omgevingen maken en gebruiken in azure machine learningvoor meer informatie over het maken van en het gebruik van omgevingen.For more information on creating and using environments, see Create and use software environments in Azure Machine Learning.

Een gecuratore omgeving gebruikenUse a curated environment

Azure ML biedt eventueel vooraf ontwikkelde, gegroepeerde omgevingen als u geen eigen installatie kopie wilt maken.Optionally, Azure ML provides prebuilt, curated environments if you don't want to build your own image. Zie hiervoor meer informatie.For more info, see here. Als u een gewerkte omgeving wilt gebruiken, kunt u in plaats daarvan de volgende opdracht uitvoeren:If you want to use a curated environment, you can run the following command instead:

sklearn_env = Environment.get(workspace=ws, name='AzureML-Tutorial')

Uw trainings uitvoering configureren en verzendenConfigure and submit your training run

Een ScriptRunConfig makenCreate a ScriptRunConfig

Maak een ScriptRunConfig-object om de configuratie gegevens van uw trainings taak op te geven, met inbegrip van het trainings script, de omgeving die u wilt gebruiken en het reken doel om uit te voeren.Create a ScriptRunConfig object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. Eventuele argumenten voor uw trainings script worden door gegeven via de opdracht regel indien opgegeven in de arguments para meter.Any arguments to your training script will be passed via command line if specified in the arguments parameter.

Met de volgende code wordt een ScriptRunConfig-object geconfigureerd voor het verzenden van uw taak voor uitvoering op uw lokale computer.The following code will configure a ScriptRunConfig object for submitting your job for execution on your local machine.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      environment=sklearn_env)

Als u in plaats daarvan uw taak wilt uitvoeren op een extern cluster, kunt u het gewenste Compute-doel opgeven voor de compute_target para meter ScriptRunConfig.If you want to instead run your job on a remote cluster, you can specify the desired compute target to the compute_target parameter of ScriptRunConfig.

from azureml.core import ScriptRunConfig

compute_target = ws.compute_targets['<my-cluster-name>']
src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      compute_target=compute_target,
                      environment=sklearn_env)

Uw uitvoering verzendenSubmit your run

from azureml.core import Experiment

run = Experiment(ws,'train-iris').submit(src)
run.wait_for_completion(show_output=True)

Waarschuwing

Azure Machine Learning trainings scripts worden uitgevoerd door de hele bronmap te kopiëren.Azure Machine Learning runs training scripts by copying the entire source directory. Als u gevoelige gegevens hebt die u niet wilt uploaden, gebruikt u een . ignore-bestand of neemt u het niet op in de bron directory.If you have sensitive data that you don't want to upload, use a .ignore file or don't include it in the source directory . In plaats daarvan kunt u toegang krijgen tot uw gegevens met behulp van een Azure ML- gegevensset.Instead, access your data using an Azure ML dataset.

Wat er gebeurt tijdens de uitvoering van het programmaWhat happens during run execution

Wanneer de uitvoering wordt uitgevoerd, worden de volgende fasen door lopen:As the run is executed, it goes through the following stages:

  • Voorbereiden: een docker-installatie kopie wordt gemaakt volgens de gedefinieerde omgeving.Preparing: A docker image is created according to the environment defined. De afbeelding wordt geüpload naar het container register van de werk ruimte en opgeslagen in de cache voor latere uitvoeringen.The image is uploaded to the workspace's container registry and cached for later runs. Logboeken worden ook gestreamd naar de uitvoerings geschiedenis en kunnen worden weer gegeven om de voortgang te bewaken.Logs are also streamed to the run history and can be viewed to monitor progress. Als er in plaats daarvan een gecuratorde omgeving wordt opgegeven, wordt er een back-up van de in de cache opgeslagen installatie kopie gebruikt.If a curated environment is specified instead, the cached image backing that curated environment will be used.

  • Schalen: het cluster probeert omhoog te schalen als het batch AI-cluster meer knoop punten nodig heeft om de uitvoering uit te voeren dan momenteel beschikbaar zijn.Scaling: The cluster attempts to scale up if the Batch AI cluster requires more nodes to execute the run than are currently available.

  • Uitvoeren: alle scripts in de map script worden geüpload naar het Compute-doel, gegevens archieven worden gekoppeld of gekopieerd en de script wordt uitgevoerd.Running: All scripts in the script folder are uploaded to the compute target, data stores are mounted or copied, and the script is executed. Uitvoer van stdout en de map ./logs worden gestreamd naar de uitvoerings geschiedenis en kunnen worden gebruikt om de uitvoering te bewaken.Outputs from stdout and the ./logs folder are streamed to the run history and can be used to monitor the run.

  • Na de verwerking: de map ./outputs van de uitvoering wordt gekopieerd naar de uitvoerings geschiedenis.Post-Processing: The ./outputs folder of the run is copied over to the run history.

Het model opslaan en registrerenSave and register the model

Zodra u het model hebt getraind, kunt u het opslaan en registreren in uw werk ruimte.Once you've trained the model, you can save and register it to your workspace. Met model registratie kunt u uw modellen in uw werk ruimte opslaan en versieren om het model beheer en de implementatiete vereenvoudigen.Model registration lets you store and version your models in your workspace to simplify model management and deployment.

Voeg de volgende code toe aan het trainings script, train_iris. py, om het model op te slaan.Add the following code to your training script, train_iris.py, to save the model.

import joblib

joblib.dump(svm_model_linear, 'model.joblib')

Registreer het model in uw werk ruimte met de volgende code.Register the model to your workspace with the following code. Door de para meters op te geven, en wordt de model_framework model_framework_version implementatie van resource_configuration geen code model beschikbaar.By specifying the parameters model_framework, model_framework_version, and resource_configuration, no-code model deployment becomes available. Met de implementatie van geen code model kunt u uw model rechtstreeks implementeren als een webservice vanuit het geregistreerde model ResourceConfiguration . het object definieert de reken resource voor de webservice.No-code model deployment allows you to directly deploy your model as a web service from the registered model, and the ResourceConfiguration object defines the compute resource for the web service.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='sklearn-iris', 
                           model_path='outputs/model.joblib',
                           model_framework=Model.Framework.SCIKITLEARN,
                           model_framework_version='0.19.1',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

ImplementatieDeployment

Het model dat u zojuist hebt geregistreerd, kan op dezelfde manier worden geïmplementeerd als andere geregistreerde modellen in azure ML.The model you just registered can be deployed the exact same way as any other registered model in Azure ML. De implementatie-instructie bevat een sectie over het registreren van modellen, maar u kunt direct door gaan naar het maken van een reken doel voor implementatie, omdat u al een geregistreerd model hebt.The deployment how-to contains a section on registering models, but you can skip directly to creating a compute target for deployment, since you already have a registered model.

Evaluatie Implementatie van geen code model(Preview) No-code model deployment

In plaats van de traditionele implementatie route kunt u ook de functie voor het implementeren van geen code (preview) gebruiken voor scikit-learn.Instead of the traditional deployment route, you can also use the no-code deployment feature (preview) for scikit-learn. Implementatie van geen code model wordt ondersteund voor alle ingebouwde scikit-informatie over model typen.No-code model deployment is supported for all built-in scikit-learn model types. Als u het model registreert zoals hierboven wordt weer gegeven, model_framework model_framework_version resource_configuration kunt u gewoon de deploy() statische functie gebruiken om uw model te implementeren.By registering your model as shown above with the model_framework, model_framework_version, and resource_configuration parameters, you can simply use the deploy() static function to deploy your model.

web_service = Model.deploy(ws, "scikit-learn-service", [model])

Opmerking: deze afhankelijkheden zijn opgenomen in de vooraf gemaakte scikit.NOTE: These dependencies are included in the pre-built scikit-learn inference container.

    - azureml-defaults
    - inference-schema[numpy-support]
    - scikit-learn
    - numpy

De volledige instructies voor het implementeren van een implementatie in azure machine learning meer dieper.The full how-to covers deployment in Azure Machine Learning in greater depth.

Volgende stappenNext steps

In dit artikel hebt u een scikit-leer model getraind en geregistreerd en hebt u geleerd over implementatie opties.In this article, you trained and registered a scikit-learn model, and learned about deployment options. Raadpleeg de volgende artikelen voor meer informatie over Azure Machine Learning.See these other articles to learn more about Azure Machine Learning.