Vad är Azure Machine Learning-SDK för Python?What is the Azure Machine Learning SDK for Python?

Dataforskare och AI-utvecklare använder Azure Machine Learning-SDK för Python till att skapa och köra Machine Learning-arbetsflöden med tjänsten Azure Machine Learning.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. Du kan interagera med tjänsten i valfri Python-miljö, inklusive Jupyter-anteckningsböcker, Visual Studio Code eller valfri Python IDE.You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE.

Huvuddelar i SDK:n:Key areas of the SDK include:

  • Utforska, förbered och hantera livscykeln för dina datauppsättningar som används i Machine Learning-experiment.Explore, prepare and manage the lifecycle of your datasets used in machine learning experiments.
  • Hantera molnresurser för övervakning, loggning och organisering av Machine Learning-experiment.Manage cloud resources for monitoring, logging, and organizing your machine learning experiments.
  • Träna modeller, antingen lokalt eller med hjälp av molnresurser, inklusive GPU-accelererad modellträning.Train models either locally or by using cloud resources, including GPU-accelerated model training.
  • Använd automatisk maskin inlärning, som godkänner konfigurations parametrar och tränings data.Use automated machine learning, which accepts configuration parameters and training data. Funktionen itererar automatiskt igenom algoritmer och hyperparameterinställningar för att hitta den bästa modellen för att köra förutsägelser.It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions.
  • Distribuera webbtjänster för att konvertera dina inlärda modeller till RESTful-tjänster som kan användas i alla program.Deploy web services to convert your trained models into RESTful services that can be consumed in any application.

En stegvis genomgång som hjälper dig att komma igång finns i den här självstudien.For a step-by-step walkthrough of how to get started, try the tutorial.

Följande avsnitt visar översikter över några av de viktigaste klasserna i SDK:n, och vanliga designmönster för hur du kan använda dem.The following sections are overviews of some of the most important classes in the SDK, and common design patterns for using them. Information om hur du hämtar SDK:n finns i installationsguiden.To get the SDK, see the installation guide.

Stabila och experimentella versionerStable vs experimental

Azure Machine Learning SDK för python tillhandahåller både stabila och experimentella funktioner i samma SDK.The Azure Machine Learning SDK for Python provides both stable and experimental features in the same SDK.

Stabila funktionerStable features

De stabila funktionerna rekommenderas för de flesta användnings fall och produktions miljöer.The stable features are recommended for most use cases and production environments. De uppdateras oftare än experimentella funktioner.They are updated less frequently then experimental features.

Experimentella funktioner (utveckling)Experimental features (developmental)

Experimentella funktioner är nyligen utvecklade funktioner & uppdateringar som kanske inte är klara eller helt testade för produktions användning.The experimental features are newly developed capabilities & updates that may not be ready or fully tested for production usage. Funktionerna är vanligt vis funktionella, men de kan innehålla vissa avbrytande ändringar.While the features are typically functional, they can include some breaking changes. Experimentella funktioner används för att stryka på SDK-filbuggar och tar bara emot uppdateringar under test periodens varaktighet.Experimental features are used to iron out SDK breaking bugs, and will only receive updates for the duration of the testing period.

När namnet indikerar är experimentella funktioner för experimentering och betraktas inte som felfria eller stabila.As the name indicates, the experimental features are for experimenting and is not considered bug free or stable. Därför rekommenderar vi bara experimentella funktioner för avancerade användare som vill testa tidiga versioner av funktioner och uppdateringar och tänker delta i rapportering av buggar och problem.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.

Experimentella funktioner är märkta med en not-sektion i SDK-referensen.Experimental features are labelled by a note section in the SDK reference.

ArbetsytaWorkspace

Namnrymd:azureml.core.workspace.WorkspaceNamespace: azureml.core.workspace.Workspace

Klassen Workspace är en grundläggande resurs i det moln som du använder för att experimentera, träna och distribuera maskininlärningsmodeller.The Workspace class is a foundational resource in the cloud that you use to experiment, train, and deploy machine learning models. Den binder din Azure-prenumeration och resursgrupp till ett objekt som är enkelt att använda.It ties your Azure subscription and resource group to an easily consumed object.

Importera klassen och skapa en ny arbetsyta med hjälp av följande kod.Import the class and create a new workspace by using the following code. Ange create_resource_group till False om du redan har en Azure-resursgrupp som du vill använda för arbetsytan.Set create_resource_group to False if you have a previously existing Azure resource group that you want to use for the workspace. Vissa funktioner kan fråga efter Azure-autentiseringsuppgifter.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'
                     )

Använd samma arbetsyta i flera miljöer genom att först skriva den till en JSON-konfigurationsfil.Use the same workspace in multiple environments by first writing it to a configuration JSON file. Detta sparar information om prenumerationen, resursen och arbetsytenamnet.This saves your subscription, resource, and workspace name data.

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

Läs in din arbetsyta genom att läsa konfigurationsfilen.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")

Du kan också använda den statiska metoden get() till att läsa in en befintlig arbetsyta utan att använda konfigurationsfiler.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')

Variabeln ws representerar ett Workspace-objekt i följande kodexempel.The variable ws represents a Workspace object in the following code examples.

ExperimentExperiment

Namnrymd:azureml.core.experiment.ExperimentNamespace: azureml.core.experiment.Experiment

Klassen Experiment är en annan grundläggande molnresurs som representerar en samling av provkörningar (enskilda modellkörningar).The Experiment class is another foundational cloud resource that represents a collection of trials (individual model runs). Följande kod hämtar ett Experiment-objekt inifrån Workspace efter namn, eller skapar ett nytt Experiment-objekt om namnet inte finns.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')

Kör följande kod för att hämta en lista över alla Experiment-objekt som finns i Workspace.Run the following code to get a list of all Experiment objects contained in Workspace.

list_experiments = Experiment.list(ws)

Använd funktionen get_runs för att hämta en lista över Run-objekt (provkörningar) från Experiment.Use the get_runs function to retrieve a list of Run objects (trials) from Experiment. Följande kod hämtar körningarna och skriver ut varje körnings-ID.The following code retrieves the runs and prints each run ID.

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

Det finns två sätt att köra en experimentell provkörning.There are two ways to execute an experiment trial. Om du experimenterar interaktivt i en Jupyter-anteckningsbok använder du funktionen start_logging.If you're interactively experimenting in a Jupyter notebook, use the start_logging function. Om du skickar ett experiment från en vanlig Python-miljö använder du funktionen submit.If you're submitting an experiment from a standard Python environment, use the submit function. Båda funktionerna returnerar ett Run-objekt.Both functions return a Run object. Variabeln experiment representerar ett Experiment-objekt i följande kodexempel.The experiment variable represents an Experiment object in the following code examples.

KörRun

Namnrymd:azureml.core.run.RunNamespace: azureml.core.run.Run

En körning representerar en enda provkörning av ett experiment.A run represents a single trial of an experiment. Run är det objekt som du använder för att övervaka den asynkrona provkörningen, lagra utdata för provkörningen, analysera resultat och komma åt genererade artefakter.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. Du kan använda Run inuti din experimentkod för att logga mått och artefakter till tjänsten för körningshistorik.You use Run inside your experimentation code to log metrics and artifacts to the Run History service. Funktionerna omfattar:Functionality includes:

  • Lagring och hämtning av mått och data.Storing and retrieving metrics and data.
  • Användning av taggar och underordnad hierarki för enkel sökning efter tidigare körningar.Using tags and the child hierarchy for easy lookup of past runs.
  • Registrering av lagrade modellfiler för distribution.Registering stored model files for deployment.
  • Lagring, ändring och hämtning av egenskaper för en körning.Storing, modifying, and retrieving properties of a run.

Skapa ett Run-objekt genom att skicka ett Experiment-objekt med ett run configuration-objekt.Create a Run object by submitting an Experiment object with a run configuration object. Använd parametern tags för att koppla anpassade kategorier och etiketter till dina körningar.Use the tags parameter to attach custom categories and labels to your runs. Du kan enkelt hitta och hämta dem senare från 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)

Använd den statiska funktionen list för att hämta en lista över alla Run-objekt från Experiment.Use the static list function to get a list of all Run objects from Experiment. Ange parametern tags för att filtrera efter taggen du skapade tidigare.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)

Använd funktionen get_details för att hämta detaljerade utdata för körningen.Use the get_details function to retrieve the detailed output for the run.

run_details = run.get_details()

Utdata för den här funktionen är en ordlista som innehåller:Output for this function is a dictionary that includes:

  • Körnings-IDRun ID
  • StatusStatus
  • Start- och sluttidStart and end time
  • Beräkningsmål (lokalt och moln)Compute target (local versus cloud)
  • Beroenden och versioner som användes i körningenDependencies and versions used in the run
  • Träningsspecifika data (varierar beroende på modelltyp)Training-specific data (differs depending on model type)

Fler exempel på hur du konfigurerar och övervakar körningar finns i instruktionerna.For more examples of how to configure and monitor runs, see the how-to.

ModellModel

Namnrymd:azureml.core.model.ModelNamespace: azureml.core.model.Model

Klassen Model används för att arbeta med molnrepresentationer av Machine Learning-modeller.The Model class is used for working with cloud representations of machine learning models. Med metoder kan du överföra modeller mellan lokala utvecklingsmiljöer och Workspace-objektet i molnet.Methods help you transfer models between local development environments and the Workspace object in the cloud.

Du kan använda modellregistrering för att lagra och versionshantera dina modeller i Azure-molnet, på din arbetsyta.You can use model registration to store and version your models in the Azure cloud, in your workspace. Registrerade modeller identifieras med namn och version.Registered models are identified by name and version. Varje gång du registrerar en modell med ett namn som redan finns ökar versionsnumret.Each time you register a model with the same name as an existing one, the registry increments the version. Azure Machine Learning stöder alla modeller som kan läsas in via python 3, inte bara Azure Machine Learning modeller.Azure Machine Learning supports any model that can be loaded through Python 3, not just Azure Machine Learning models.

I följande exempel visas hur du skapar en enkel lokal klassificeringsmodell med scikit-learn, registrerar modellen i Workspace och laddar ned modellen från molnet.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.

Skapa en enkel klassificerare, clf, för att förutsäga kundomsättningen utifrån ålder.Create a simple classifier, clf, to predict customer churn based on their age. Dumpa sedan modellen till en .pkl-fil i samma katalog.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")

Använd funktionen register för att registrera modellen på din arbetsyta.Use the register function to register the model in your workspace. Ange den lokala sökvägen för modellen och modellnamnet.Specify the local model path and the model name. Om du registrerar samma namn mer än en gång skapas en ny version.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 när modellen har registrerats på din arbetsyta är det enkelt att hantera, ladda ned och organisera dina modeller.Now that the model is registered in your workspace, it's easy to manage, download, and organize your models. Om du vill hämta ett modellobjekt (till exempel i en annan miljö) från Workspace använder du klasskonstruktorn och anger modellnamnet och eventuella valfria parametrar.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. Använd sedan funktionen download för att ladda ned modellen, inklusive molnmappstrukturen.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())

Använd funktionen delete för att ta bort modellen från Workspace.Use the delete function to remove the model from Workspace.

model.delete()

När du har en registrerad modell är det enkelt att distribuera den som en webbtjänst.After you have a registered model, deploying it as a web service is a straightforward process. Du börjar med att skapa och registrera en avbildning.First you create and register an image. I det här steget konfigureras Python-miljön och dess beroenden, tillsammans med ett skript för att definiera formatet för begäranden och svar för webbtjänsten.This step configures the Python environment and its dependencies, along with a script to define the web service request and response formats. När du har skapat en avbildning skapar du en distributionskonfiguration som anger processorkärnor och minnesparametrar för beräkningsmålet.After you create an image, you build a deploy configuration that sets the CPU cores and memory parameters for the compute target. Bifoga sedan din avbildning.You then attach your image.

ComputeTarget, RunConfiguration och ScriptRunConfigComputeTarget, RunConfiguration, and ScriptRunConfig

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

Klassen ComputeTarget är en abstrakt överordnad klass som du använder för att skapa och hantera beräkningsmål.The ComputeTarget class is the abstract parent class for creating and managing compute targets. Ett beräkningsmål representerar en rad olika resurser där du kan träna dina maskininlärningsmodeller.A compute target represents a variety of resources where you can train your machine learning models. Ett beräkningsmål kan vara antingen en lokal dator eller en molnresurs, till exempel Azure Machine Learning Compute, Azure HDInsight eller en virtuell fjärrdator.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.

Använd beräkningsmål för att dra nytta av kraftfulla virtuella datorer för modellträning och konfigurera antingen beständiga beräkningsmål eller temporära mål som anropas vid körning.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. En omfattande guide om hur du konfigurerar och hanterar beräkningsmål finns i instruktionerna.For a comprehensive guide on setting up and managing compute targets, see the how-to.

Följande kod visar ett enkelt exempel på hur du konfigurerar ett AmlCompute-mål (underordnad klass av ComputeTarget).The following code shows a simple example of setting up an AmlCompute (child class of ComputeTarget) target. Det här målet skapar en fjärrberäkningsresurs som anropas under körning i ditt Workspace-objekt.This target creates a runtime remote compute resource in your Workspace object. Resursen skalas automatiskt när ett jobb skickas.The resource scales automatically when a job is submitted. Den tas bort automatiskt när körningen är klar.It's deleted automatically when the run finishes.

Återanvänd den enkla scikit-learn-omsättningsmodellen och bygg den till en egen fil, train.py, i den aktuella katalogen.Reuse the simple scikit-learn churn model and build it into its own file, train.py, in the current directory. Skapa en ny katalog med namnet outputs i slutet av filen.At the end of the file, create a new directory called outputs. I det här steget skapas en katalog i molnet (din arbetsyta) för att lagra din inlärda modell som serialiserats med joblib.dump().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")

Därefter skapar du beräkningsmålet genom att instansiera ett RunConfiguration-objekt och ange typ och storlek.Next you create the compute target by instantiating a RunConfiguration object and setting the type and size. I det här exemplet används den minsta resursstorleken (1 processorkärna och 3,5 GB minne).This example uses the smallest resource size (1 CPU core, 3.5 GB of memory). Variabeln list_vms innehåller en lista över virtuella datorer som stöds och deras storlek.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"

Skapa beroenden för fjärrberäkningsresursens Python-miljö med hjälp av klassen CondaDependencies.Create dependencies for the remote compute resource's Python environment by using the CondaDependencies class. Filen train.py använder scikit-learn och numpy, som måste installeras i miljön.The train.py file is using scikit-learn and numpy, which need to be installed in the environment. Du kan också ange versioner av beroenden.You can also specify versions of dependencies. Använd dependencies-objektet för att ange miljön i compute_config.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

Nu är du redo att skicka experimentet.Now you're ready to submit the experiment. Använd klassen ScriptRunConfig för att koppla beräkningsmålkonfigurationen och för att ange sökvägen/filen till träningsskriptet train.py.Use the ScriptRunConfig class to attach the compute target configuration, and to specify the path/file to the training script train.py. Skicka experimentet genom att ange parametern config för funktionen submit().Submit the experiment by specifying the config parameter of the submit() function. Anropa wait_for_completion på den resulterande körningen för att se asynkrona körningsutdata när miljön initieras och modellen tränas.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)

När körningen är klar är filen för den inlärda modellen, churn-model.pkl, tillgänglig på din arbetsyta.After the run finishes, the trained model file churn-model.pkl is available in your workspace.

MiljöEnvironment

Namnrymd:azureml.core.environmentNamespace: azureml.core.environment

Azure Machine Learning miljöer anger python-paket, miljövariabler och program varu inställningar kring dina utbildnings-och bedömnings skript.Azure Machine Learning environments specify the Python packages, environment variables, and software settings around your training and scoring scripts. Förutom python kan du också konfigurera PySpark, Docker och R för miljöer.In addition to Python, you can also configure PySpark, Docker and R for environments. Internt resulterar i miljöer i Docker-avbildningar som används för att köra utbildnings-och poängsättnings processerna på beräknings målet.Internally, environments result in Docker images that are used to run the training and scoring processes on the compute target. Miljöer är hanterade och versions bara entiteter inom din Machine Learning arbets yta som möjliggör återskapande, gransknings bara och bärbara Machine Learning-arbetsflöden över flera olika beräknings mål och beräknings typer.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.

Du kan använda ett Environment objekt för att:You can use an Environment object to:

  • Utveckla ditt utbildnings skript.Develop your training script.
  • Återanvänd samma miljö på Azure Machine Learning beräkning för modell träning i stor skala.Reuse the same environment on Azure Machine Learning Compute for model training at scale.
  • Distribuera din modell med samma miljö utan att vara knuten till en speciell beräknings typ.Deploy your model with that same environment without being tied to a specific compute type.

Följande kod importerar Environment klassen från SDK och instansierar ett miljö objekt.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")

Lägg till paket i en miljö med Conda-, pip-eller privata Wheel-filer.Add packages to an environment by using Conda, pip, or private wheel files. Ange varje paket beroende genom CondaDependency att använda klassen för att lägga till det i miljöns PythonSection .Specify each package dependency by using the CondaDependency class to add it to the environment's PythonSection.

Följande exempel lägger till i miljön.The following example adds to the environment. Den lägger till version 1.17.0 av numpy .It adds version 1.17.0 of numpy. Paketet läggs också pillow till i miljön myenv .It also adds the pillow package to the environment, myenv. Exemplet använder metoden respektive add_conda_package() add_pip_package() metod.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

Om du vill skicka en utbildnings körning måste du kombinera din miljö, Beräkna måloch ditt Python-skript i en körnings konfiguration.To submit a training run, you need to combine your environment, compute target, and your training Python script into a run configuration. Den här konfigurationen är ett wrapper-objekt som används för att skicka körningar.This configuration is a wrapper object that's used for submitting runs.

När du skickar in en utbildnings körning kan det ta flera minuter att skapa en ny miljö.When you submit a training run, the building of a new environment can take several minutes. Varaktigheten beror på storleken på de nödvändiga beroendena.The duration depends on the size of the required dependencies. Miljöerna cachelagras av tjänsten.The environments are cached by the service. Så länge miljö definitionen är oförändrad, tillkommer du bara den fullständiga konfigurations tiden en gång.So as long as the environment definition remains unchanged, you incur the full setup time only once.

I följande exempel visas var du ska använda ScriptRunConfig som wrapper-objekt.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)

Om du inte anger en miljö i körnings konfigurationen innan du skickar körningen, skapas en standard miljö åt dig.If you don't specify an environment in your run configuration before you submit the run, then a default environment is created for you.

Se avsnittet modell distribution för att använda miljöer för att distribuera en webb tjänst.See the Model deploy section to use environments to deploy a web service.

Pipeline, PythonScriptStepPipeline, PythonScriptStep

Namnrymd:azureml.pipeline.core.pipeline.PipelineNamespace: azureml.pipeline.core.pipeline.Pipeline
Namnrymd:azureml.pipeline.steps.python_script_step.PythonScriptStepNamespace: azureml.pipeline.steps.python_script_step.PythonScriptStep

En Azure Machine Learning-pipeline är ett automatiserat arbetsflöde för en komplett maskininlärningsaktivitet.An Azure Machine Learning pipeline is an automated workflow of a complete machine learning task. Underaktiviteter kapslas in som en serie steg i pipelinen.Subtasks are encapsulated as a series of steps within the pipeline. En Azure Machine Learning-pipeline kan mycket enkel, till exempel ett steg som anropar ett Python-skript.An Azure Machine Learning pipeline can be as simple as one step that calls a Python script. Pipelines innefattar funktioner för:Pipelines include functionality for:

  • Förberedelse av data, inklusive import, validering och rensning, omvandling och transformering, normalisering och mellanlagringData preparation including importing, validating and cleaning, munging and transformation, normalization, and staging
  • Träningskonfiguration, inklusive parametrisera argument, sökvägar och loggnings-/rapporteringskonfigurationerTraining configuration including parameterizing arguments, filepaths, and logging / reporting configurations
  • Träning och validering på ett effektivt och upprepat sätt, vilket kan omfatta att ange specifika delmängder av data, olika maskinvaruberäkningsresurser, distribuerad databehandling och förloppsövervakningTraining and validating efficiently and repeatably, which might include specifying specific data subsets, different hardware compute resources, distributed processing, and progress monitoring
  • Distribution, inklusive versionshantering, skalning, etablering och åtkomstkontrollDeployment, including versioning, scaling, provisioning, and access control
  • Publicera en pipeline till en REST-slutpunkt för körning på nytt från ett HTTP-bibliotekPublishing a pipeline to a REST endpoint to rerun from any HTTP library

PythonScriptStep är ett inbyggt grundläggande steg för att köra ett Python-skript på ett beräkningsmål.A PythonScriptStep is a basic, built-in step to run a Python Script on a compute target. Det tar ett skriptnamn och andra valfria parametrar som argument för skriptet, beräkningsmål, indata och utdata.It takes a script name and other optional parameters like arguments for the script, compute target, inputs and outputs. Följande kod är ett enkelt exempel på ett PythonScriptStep.The following code is a simple example of a PythonScriptStep. Ett exempel på ett train.py-skript finns i underavsnittet i självstudien.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
)

När minst ett steg har skapats kan steg länkas samman och publiceras som en enkel automatiserad pipeline.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)

Om du vill ha ett omfattande exempel på hur du skapar ett pipelinearbetsflöde kan du följa den avancerade självstudien.For a comprehensive example of building a pipeline workflow, follow the advanced tutorial.

Mönster för att skapa och använda pipelinesPattern for creating and using pipelines

En Azure Machine Learning pipeline är kopplad till en Azure Machine Learning arbets yta och ett steg i pipeline är associerat med ett beräknings mål som är tillgängligt i arbets ytan.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. Mer information finns i den här artikeln om arbetsytor eller den här förklaringen av beräkningsmål.For more information, see this article about workspaces or this explanation of compute targets.

Ett vanligt mönster för pipelinesteg:A common pattern for pipeline steps is:

  1. Ange arbetsyta, beräkning och lagringSpecify workspace, compute, and storage
  2. Konfigurera indata och utdata medConfigure your input and output data using
    1. Data uppsättning som gör tillgängligt för ett befintligt Azure-datalagerDataset which makes available an existing Azure datastore
    2. PipelineDataset som kapslar in tabelldataPipelineDataset which encapsulates typed tabular data
    3. PipelineData som används för mellanliggande fil- eller katalogdata som skrivits av ett steg och som är avsedda att användas av ett annatPipelineData which is used for intermediate file or directory data written by one step and intended to be consumed by another
  3. Definiera ett eller flera pipelinestegDefine one or more pipeline steps
  4. Instansiera en pipeline med hjälp av din arbetsyta och dina stegInstantiate a pipeline using your workspace and steps
  5. Skapa ett experiment som du skickar pipelinen tillCreate an experiment to which you submit the pipeline
  6. Övervaka experimentresultatetMonitor the experiment results

Den här anteckningsboken är ett bra exempel på det här mönstret.This notebook is a good example of this pattern. uppgiftjob

Mer information om Azure Machine Learning-pipelines och hur de skiljer sig från andra typer av pipelines finns i den här artikeln.For more information about Azure Machine Learning Pipelines, and in particular how they are different from other types of pipelines, see this article.

AutoMLConfigAutoMLConfig

Namnrymd:azureml.train.automl.automlconfig.AutoMLConfigNamespace: azureml.train.automl.automlconfig.AutoMLConfig

Använd klassen AutoMLConfig för att konfigurera parametrar för automatiserad maskininlärningsträning.Use the AutoMLConfig class to configure parameters for automated machine learning training. Den automatiserade maskininlärningen itererar över flera kombinationer av maskininlärningsalgoritmer och hyperparameterinställningar.Automated machine learning iterates over many combinations of machine learning algorithms and hyperparameter settings. Sedan söker den efter den modell som passar bäst utifrån det precisionsmått som du har valt.It then finds the best-fit model based on your chosen accuracy metric. Med konfiguration kan du ange:Configuration allows for specifying:

  • Aktivitetstyp (klassificering, regression, prognosticering)Task type (classification, regression, forecasting)
  • Antal algoritmiterationer och maximal tid per iterationNumber of algorithm iterations and maximum time per iteration
  • Precisionsmått för optimeringAccuracy metric to optimize
  • Algoritmer för svartlista/vitlistaAlgorithms to blacklist/whitelist
  • Antal korsvalideringarNumber of cross-validations
  • BeräkningsmålCompute targets
  • TräningsdataTraining data

Anteckning

Använd automl i installationen om du vill använda automatiserad maskininlärning.Use the automl extra in your installation to use automated machine learning.

Detaljerade guider och exempel på hur du konfigurerar automatiserade maskininlärningsexperiment finns i självstudien och i instruktionerna.For detailed guides and examples of setting up automated machine learning experiments, see the tutorial and how-to.

Följande kod visar hur du bygger ett automatiserat konfigurationsobjekt för maskininlärning för en klassificeringsmodell, och använder det när du skickar ett 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
                            )

Använd automl_config-objektet för att skicka ett experiment.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)

När du har skickat experimentet visar utdata inlärningsprecisionen för varje iteration när den har slutförts.After you submit the experiment, output shows the training accuracy for each iteration as it finishes. När körningen är klar returneras ett AutoMLRun-objekt (som utökar klassen Run).After the run is finished, an AutoMLRun object (which extends the Run class) is returned. Hämta den modell som passar bäst genom att returnera ett Model-objekt med hjälp av funktionen get_output().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)

Modell distributionModel deploy

Namnrymd:azureml.core.model.InferenceConfigNamespace: azureml.core.model.InferenceConfig
Namnrymd:azureml.core.webservice.webservice.WebserviceNamespace: azureml.core.webservice.webservice.Webservice

InferenceConfigKlassen är för konfigurations inställningar som beskriver den miljö som krävs för att vara värd för modellen och webb tjänsten.The InferenceConfig class is for configuration settings that describe the environment needed to host the model and web service.

Webservice är en abstrakt överordnad klass för att skapa och distribuera webbtjänster för dina modeller.Webservice is the abstract parent class for creating and deploying web services for your models. En detaljerad guide om hur du förbereder modell distribution och distribuerar webb tjänster finns i den här instruktionen.For a detailed guide on preparing for model deployment and deploying web services, see this how-to.

Du kan använda miljöer när du distribuerar din modell som en webb tjänst.You can use environments when you deploy your model as a web service. Miljöer möjliggör ett reproducerat, anslutet arbets flöde där du kan distribuera din modell med samma bibliotek i både din utbildning och din härlednings beräkning.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. Internt implementeras miljöer som Docker-avbildningar.Internally, environments are implemented as Docker images. Du kan använda antingen avbildningar som tillhandahålls av Microsoft eller använda dina egna anpassade Docker-avbildningar.You can use either images provided by Microsoft, or use your own custom Docker images. Om du tidigare använde ContainerImage klassen för din distribution, se DockerSection klassen för att utföra ett liknande arbets flöde med miljöer.If you were previously using the ContainerImage class for your deployment, see the DockerSection class for accomplishing a similar workflow with environments.

Om du vill distribuera en webb tjänst kombinerar du miljön, ett bedömnings beräknings skript och en registrerad modell i ditt distributions objekt deploy() .To deploy a web service, combine the environment, inference compute, scoring script, and registered model in your deployment object, deploy().

I följande exempel förutsätter vi att du redan har slutfört en utbildning som körs med hjälp av miljön, myenv och vill distribuera modellen till 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)

I det här exemplet skapas en Azure Container Instances-webbtjänst, som passar bäst för testning och snabb distribution i liten skala.This example creates an Azure Container Instances web service, which is best for small-scale testing and quick deployments. Om du vill distribuera din modell som en webbtjänst i produktionsskala använder du Azure Kubernetes Service (AKS).To deploy your model as a production-scale web service, use Azure Kubernetes Service (AKS). Mer information finns i klassen AksCompute.For more information, see AksCompute class.

DatauppsättningDataset

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

Klassen Dataset är en grundläggande resurs för att utforska och hantera data i Azure Machine Learning.The Dataset class is a foundational resource for exploring and managing data within Azure Machine Learning. Du kan utforska dina data med sammanfattningsstatistik och spara datauppsättningen till din AML-arbetsyta och använda funktioner för versionshantering och reproducerbarhet.You can explore your data with summary statistics, and save the Dataset to your AML workspace to get versioning and reproducibility capabilities. Datauppsättningar kan enkelt användas av modeller under träningen.Datasets are easily consumed by models during training. Detaljerade användningsexempel finns i instruktionsguiden.For detailed usage examples, see the how-to guide.

  • TabularDatasetrepresenterar data i tabell format som skapats genom att parsa en fil eller en lista med filer.TabularDataset represents data in a tabular format created by parsing a file or list of files.
  • FileDataset refererar till en eller flera filer i datalager eller från offentliga URL:er.FileDataset references single or multiple files in datastores or from public URLs.

I följande exempel visas hur du skapar en TabularDataset som pekar på en enskild sökväg i ett datalager.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()

I följande exempel visas hur du skapar en FileDataset referens till flera fil-URL: er.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)

Nästa stegNext steps

Prova följande steg och lär dig hur du använder Azure Machine Learning-SDK för Python:Try these next steps to learn how to use the Azure Machine Learning SDK for Python:

  • Följ självstudien och lär dig hur du bygger, tränar och distribuerar en modell i Python.Follow the tutorial to learn how to build, train, and deploy a model in Python.

  • Leta upp klasser och moduler i referensdokumentationen på den här webbplatsen med hjälp av innehållsförteckningen till vänster.Look up classes and modules in the reference documentation on this site by using the table of contents on the left.