O que é o SDK do Azure Machine Learning para Python?What is the Azure Machine Learning SDK for Python?

Cientistas de dados e desenvolvedores de IA usam O SDK do Azure Machine Learning para o Python a fim de compilar e executar fluxos de trabalho de aprendizado de máquina com o Serviço do 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. Você pode interagir com o serviço em qualquer ambiente de Python, incluindo Jupyter Notebooks, Visual Studio Code ou seu IDE favorito do Python.You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE.

As principais áreas do SDK incluem:Key areas of the SDK include:

  • Explorar, preparar e gerenciar o ciclo de vida de seus conjuntos de informações usados em experimentos de machine learning.Explore, prepare and manage the lifecycle of your datasets used in machine learning experiments.
  • Gerenciar recursos de nuvem para monitorar, registrar em log e organizar seus experimentos de machine learning.Manage cloud resources for monitoring, logging, and organizing your machine learning experiments.
  • Treine modelos localmente ou usando recursos de nuvem, incluindo o treinamento de modelo com aceleração de GPU.Train models either locally or by using cloud resources, including GPU-accelerated model training.
  • Use o machine learning automatizado, que aceita parâmetros de configuração e dados de treinamento.Use automated machine learning, which accepts configuration parameters and training data. Ele itera automaticamente por meio de algoritmos e configurações de hiperparâmetro para encontrar o melhor modelo para executar previsões.It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions.
  • Implante os serviços Web para converter seus modelos treinados em serviços RESTful que podem ser consumidos em qualquer aplicativo.Deploy web services to convert your trained models into RESTful services that can be consumed in any application.

Para obter uma explicação passo a passo de como começar, experimente o tutorial.For a step-by-step walkthrough of how to get started, try the tutorial.

As seções a seguir são visões gerais de algumas das classes mais importantes no SDK e padrões de design comuns para usá-las.The following sections are overviews of some of the most important classes in the SDK, and common design patterns for using them. Consulte o guia de instalação para obter o SDK.To get the SDK, see the installation guide.

WorkspaceWorkspace

Namespace: azureml.core.workspace.WorkspaceNamespace: azureml.core.workspace.Workspace

A classe Workspace é o recurso fundamental na nuvem que você usa para experimentar, treinar e implantar modelos de machine learning.The Workspace class is a foundational resource in the cloud that you use to experiment, train, and deploy machine learning models. Ele vincula sua assinatura do Azure e o grupo de recursos a um objeto facilmente consumido.It ties your Azure subscription and resource group to an easily consumed object.

Importe a classe e crie um novo workspace usando o código a seguir.Import the class and create a new workspace by using the following code. Defina create_resource_group para False se você tiver um grupo de recursos do Azure já existente que você deseje usar para o workspace.Set create_resource_group to False if you have a previously existing Azure resource group that you want to use for the workspace. Algumas funções podem solicitar credenciais de autenticação do Azure.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'
                     )

Use o mesmo workspace em vários ambientes. Para isso, primeiro grave-o em um arquivo JSON de configuração.Use the same workspace in multiple environments by first writing it to a configuration JSON file. Isso salva a assinatura, o recurso e os dados de nome do workspace.This saves your subscription, resource, and workspace name data.

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

Carregue o workspace lendo o arquivo de configuração.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")

Como alternativa, use o método estático get() para carregar um workspace existente sem usar arquivos de configuração.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')

A variável ws representa um objeto Workspace nos exemplos de código a seguir.The variable ws represents a Workspace object in the following code examples.

ExperimentoExperiment

Namespace: azureml.core.experiment.ExperimentNamespace: azureml.core.experiment.Experiment

A classe Experiment é outro recurso de nuvem fundamental que representa uma coleção de avaliações (execuções de modelo individuais).The Experiment class is another foundational cloud resource that represents a collection of trials (individual model runs). O código a seguir busca um objeto Experiment de dentro de Workspace por nome ou cria um novo objeto Experiment se o nome não existe.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')

Execute o código a seguir para obter uma lista de todos os objetos Experiment contidos em Workspace.Run the following code to get a list of all Experiment objects contained in Workspace.

list_experiments = Experiment.list(ws)

Use a função get_runs para recuperar uma lista de objetos Run (testes) de Experiment.Use the get_runs function to retrieve a list of Run objects (trials) from Experiment. O código a seguir recupera as execuções e imprime cada ID de execução.The following code retrieves the runs and prints each run ID.

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

Há duas maneiras de realizar um teste de experimento.There are two ways to execute an experiment trial. Se você estiver experimentando interativamente em um Jupyter notebook, use a função start_logging.If you're interactively experimenting in a Jupyter notebook, use the start_logging function. Se você estiver enviando um experimento de um ambiente padrão do Python, use a função submit.If you're submitting an experiment from a standard Python environment, use the submit function. Ambas as funções retornam um objeto Run.Both functions return a Run object. A variável experiment representa um objeto Experiment nos exemplos de código a seguir.The experiment variable represents an Experiment object in the following code examples.

ExecutarRun

Namespace: azureml.core.run.RunNamespace: azureml.core.run.Run

Uma execução representa um único teste de um experimento.A run represents a single trial of an experiment. Run é o objeto que você usa para monitorar a execução assíncrona de uma avaliação, armazenar a saída da avaliação, analisar os resultados e acessar os artefatos gerados.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. Você usa Run dentro do código de experimentação para registrar métricas e artefatos no serviço de Histórico de Execuções.You use Run inside your experimentation code to log metrics and artifacts to the Run History service. A funcionalidade inclui:Functionality includes:

  • armazenamento e recuperação de métricas e dados;Storing and retrieving metrics and data.
  • uso de marcas e a hierarquia de filhos para facilitar a pesquisa de execuções anteriores;Using tags and the child hierarchy for easy lookup of past runs.
  • registro de arquivos de modelo armazenados para implantação;Registering stored model files for deployment.
  • armazenamento, modificação e recuperação de propriedades de uma execução.Storing, modifying, and retrieving properties of a run.

Crie um objeto Run enviando um objeto Experiment com um objeto de configuração de execução.Create a Run object by submitting an Experiment object with a run configuration object. Você usa o parâmetro tags para anexar categorias e rótulos personalizados às suas execuções.Use the tags parameter to attach custom categories and labels to your runs. Você pode encontrá-los e recuperá-los facilmente mais tarde de 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)

Use a função list estática para obter uma lista de todos os objetos Run de Experiment.Use the static list function to get a list of all Run objects from Experiment. Especifique o parâmetro tags para filtrar pela marca que você criou anteriormente.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)

Use a função get_details para recuperar a saída detalhada para a execução.Use the get_details function to retrieve the detailed output for the run.

run_details = run.get_details()

A saída para essa função é um dicionário que inclui:Output for this function is a dictionary that includes:

  • ID da execuçãoRun ID
  • StatusStatus
  • Horas de início e términoStart and end time
  • Destino de computação (local versus nuvem)Compute target (local versus cloud)
  • Dependências e versões usadas na execuçãoDependencies and versions used in the run
  • Dados específicos do treinamento (diferem dependendo do tipo de modelo)Training-specific data (differs depending on model type)

Para obter mais exemplos de como configurar e monitorar execuções, confira as instruções.For more examples of how to configure and monitor runs, see the how-to.

ModeloModel

Namespace: azureml.core.model.ModelNamespace: azureml.core.model.Model

A classe Model é usada para trabalhar com representações de nuvem de modelos de machine learning.The Model class is used for working with cloud representations of machine learning models. Os métodos ajudam a transferir modelos entre ambientes de desenvolvimento local e o objeto Workspace na nuvem.Methods help you transfer models between local development environments and the Workspace object in the cloud.

É possível usar o registro de modelo para armazenar e controlar a versão de seus modelos na nuvem do Azure no workspace.You can use model registration to store and version your models in the Azure cloud, in your workspace. Modelos registrados são identificados por nome e versão.Registered models are identified by name and version. Cada vez que você registra um modelo com o mesmo nome de um já existente, o Registro incrementa a versão.Each time you register a model with the same name as an existing one, the registry increments the version. O Azure Machine Learning é compatível com qualquer modelo que possa ser carregado por meio do Python 3, não apenas modelos do Azure Machine Learning.Azure Machine Learning supports any model that can be loaded through Python 3, not just Azure Machine Learning models.

O exemplo a seguir mostra como criar um modelo de classificação local simples com scikit-learn, registrar o modelo em Workspace e baixar o modelo da nuvem.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.

Crie um classificador simples, clf, para prever a rotatividade de clientes com base na idade deles.Create a simple classifier, clf, to predict customer churn based on their age. Em seguida, despeje o modelo em um arquivo de .pkl no mesmo diretório.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")

Use a função register para registrar o modelo no workspace.Use the register function to register the model in your workspace. Especifique o caminho do modelo local e o nome do modelo.Specify the local model path and the model name. Registrar o mesmo nome mais de uma vez criará uma nova versão.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")

Agora que o modelo está registrado no workspace, é fácil gerenciar, baixar e organizar os modelos.Now that the model is registered in your workspace, it's easy to manage, download, and organize your models. Para recuperar um objeto de modelo (por exemplo, em outro ambiente) de Workspace, use o construtor de classe e especifique o nome do modelo e os parâmetros opcionais.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. Em seguida, use a função download para baixar o modelo, incluindo a estrutura da pasta de nuvem.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())

Use a função delete para remover o modelo de Workspace.Use the delete function to remove the model from Workspace.

model.delete()

Depois que você tiver um modelo registrado, implantá-lo como um serviço Web será um processo simples.After you have a registered model, deploying it as a web service is a straightforward process. Primeiro, você cria e registra uma imagem.First you create and register an image. Esta etapa configura o ambiente do Python e as respectivas dependências, juntamente com um script para definir os formatos de solicitação e resposta do serviço Web.This step configures the Python environment and its dependencies, along with a script to define the web service request and response formats. Depois de criar uma imagem, você cria uma configuração de implantação que define os núcleos de CPU e os parâmetros de memória para o destino de computação.After you create an image, you build a deploy configuration that sets the CPU cores and memory parameters for the compute target. Em seguida, você anexa a imagem.You then attach your image.

ComputeTarget, RunConfiguration e ScriptRunConfigComputeTarget, RunConfiguration, and ScriptRunConfig

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

A classe ComputeTarget é a classe pai abstrata para criar e gerenciar destinos de computação.The ComputeTarget class is the abstract parent class for creating and managing compute targets. Um destino de computação representa uma variedade de recursos em que você pode treinar seus modelos de machine learning.A compute target represents a variety of resources where you can train your machine learning models. Um destino de computação pode ser um computador local ou um recurso de nuvem, tal como Computação do Azure Machine Learning, Azure HDInsight ou uma máquina virtual remota.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.

Use destinos de computação para tirar proveito de máquinas virtuais poderosas para treinamento de modelos e configurar destinos de computação persistentes ou destinos invocados por runtimes temporários.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. Para obter um guia abrangente sobre como configurar e gerenciar destinos de computação, confira as instruções.For a comprehensive guide on setting up and managing compute targets, see the how-to.

O código a seguir mostra um exemplo simples de configuração de um destino de AmlCompute (classe filho de ComputeTarget).The following code shows a simple example of setting up an AmlCompute (child class of ComputeTarget) target. Esse destino cria um recurso de computação remota em runtime no objeto Workspace.This target creates a runtime remote compute resource in your Workspace object. O recurso é dimensionado automaticamente quando um trabalho é enviado.The resource scales automatically when a job is submitted. Ele é excluído automaticamente quando a execução é concluída.It's deleted automatically when the run finishes.

Reutilize o modelo de rotatividade de scikit-learn simples e crie-o em seu próprio arquivo, train.py, no diretório atual.Reuse the simple scikit-learn churn model and build it into its own file, train.py, in the current directory. No final do arquivo, crie um diretório chamado outputs.At the end of the file, create a new directory called outputs. Essa etapa cria um diretório na nuvem (seu workspace) para armazenar o modelo treinado que joblib.dump() serializou.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")

Em seguida, você cria o destino de computação instanciando um objeto RunConfiguration e definindo o tipo e o tamanho.Next you create the compute target by instantiating a RunConfiguration object and setting the type and size. Este exemplo usa o menor tamanho de recurso (um núcleo de CPU, 3,5 GB de memória).This example uses the smallest resource size (1 CPU core, 3.5 GB of memory). A variável list_vms contém uma lista de máquinas virtuais compatíveis e os respectivos tamanhos.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"

Crie dependências para o ambiente do Python do recurso de computação remota usando a classe CondaDependencies.Create dependencies for the remote compute resource's Python environment by using the CondaDependencies class. O arquivo de train.py está usando scikit-learn e numpy, que precisam ser instalados no ambiente.The train.py file is using scikit-learn and numpy, which need to be installed in the environment. Você também pode especificar versões de dependências.You can also specify versions of dependencies. Use o objeto dependencies para definir o ambiente em 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

Agora você está pronto para enviar o experimento.Now you're ready to submit the experiment. Use a classe ScriptRunConfig para anexar a configuração de destino de computação e para especificar o caminho/arquivo para o script de treinamento train.py.Use the ScriptRunConfig class to attach the compute target configuration, and to specify the path/file to the training script train.py. Envie o experimento especificando o parâmetro config da função submit().Submit the experiment by specifying the config parameter of the submit() function. Chame wait_for_completion na execução resultante para ver a saída de execução assíncrona enquanto o ambiente é inicializado e o modelo é treinado.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)

Após a conclusão da execução, o arquivo de modelo treinado churn-model.pkl está disponível no workspace.After the run finishes, the trained model file churn-model.pkl is available in your workspace.

AmbienteEnvironment

Namespace: azureml.core.environmentNamespace: azureml.core.environment

Os ambientes do Azure Machine Learning especificam os pacotes Python, as variáveis de ambiente e as configurações de software em relação aos scripts de treinamento e pontuação.Azure Machine Learning environments specify the Python packages, environment variables, and software settings around your training and scoring scripts. Além do Python, você também pode configurar o PySpark, Docker e R para ambientes.In addition to Python, you can also configure PySpark, Docker and R for environments. Internamente, os ambientes resultam em imagens do Docker usadas para executar os processos de treinamento e pontuação no destino de computação.Internally, environments result in Docker images that are used to run the training and scoring processes on the compute target. Os ambientes são entidades gerenciadas e com controle de versão dentro de seu workspace do Machine Learning que habilitam fluxos de trabalho de aprendizado de máquina portáteis, reproduzíveis e auditáveis em uma variedade de destinos e tipos de computação.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.

Você pode usar um objeto Environment para:You can use an Environment object to:

  • Desenvolver seu script de treinamento.Develop your training script.
  • Reutilizar o mesmo ambiente na Computação do Azure Machine Learning para treinamento de modelos em escala.Reuse the same environment on Azure Machine Learning Compute for model training at scale.
  • Implantar seu modelo com esse mesmo ambiente sem estar vinculado a um tipo de computação específico.Deploy your model with that same environment without being tied to a specific compute type.

O código a seguir importa a classe Environment do SDK e cria uma instância de um objeto de ambiente.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")

Adicione pacotes a um ambiente usando arquivos Conda, pip ou de roda privada.Add packages to an environment by using Conda, pip, or private wheel files. Especifique cada dependência de pacote usando a classe CondaDependency para adicioná-la à PythonSection do ambiente.Specify each package dependency by using the CondaDependency class to add it to the environment's PythonSection.

O exemplo a seguir é adicionado ao ambiente.The following example adds to the environment. Ele adiciona a versão 1.17.0 de numpy.It adds version 1.17.0 of numpy. Ele também adiciona o pacote de pillow ao ambiente, myenv.It also adds the pillow package to the environment, myenv. O exemplo usa o método add_conda_package() e o método add_pip_package(), respectivamente.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

Para enviar uma execução de treinamento, você precisa combinar seu ambiente, o destino de computação e o script Python de treinamento em uma configuração de execução.To submit a training run, you need to combine your environment, compute target, and your training Python script into a run configuration. Essa configuração é um objeto wrapper usado para enviar execuções.This configuration is a wrapper object that's used for submitting runs.

Quando você envia uma execução de treinamento, a criação de um ambiente pode levar vários minutos.When you submit a training run, the building of a new environment can take several minutes. A duração depende do tamanho das dependências necessárias.The duration depends on the size of the required dependencies. Os ambientes são armazenados em cache pelo serviço.The environments are cached by the service. Assim, desde que a definição do ambiente permaneça inalterada, você incorrerá no tempo de configuração completa apenas uma vez.So as long as the environment definition remains unchanged, you incur the full setup time only once.

O exemplo a seguir mostra onde você poderia usar ScriptRunConfig como objeto wrapper.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)

Se você não especificar um ambiente em sua configuração de execução antes de enviar a execução, um ambiente padrão será criado para você.If you don't specify an environment in your run configuration before you submit the run, then a default environment is created for you.

Confira a seção Implantação de modelo para usar ambientes para implantar um serviço Web.See the Model deploy section to use environments to deploy a web service.

Pipeline, PythonScriptStepPipeline, PythonScriptStep

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

Um pipeline de Azure Machine Learning é um fluxo de trabalho automatizado de uma tarefa de machine learning completa.An Azure Machine Learning pipeline is an automated workflow of a complete machine learning task. As subtarefas são encapsuladas como uma série de etapas no pipeline.Subtasks are encapsulated as a series of steps within the pipeline. Um pipeline Azure Machine Learning pode ser tão simples quanto uma etapa que chama um script Python.An Azure Machine Learning pipeline can be as simple as one step that calls a Python script. Os pipelines incluem funcionalidade para:Pipelines include functionality for:

  • Preparação de dados, incluindo importação, validação e limpeza, mudanças irreversíveis e transformação, normalização e preparoData preparation including importing, validating and cleaning, munging and transformation, normalization, and staging
  • Configuração de treinamento, incluindo argumentos de parametrização, filePaths e configurações de log/relatórioTraining configuration including parameterizing arguments, filepaths, and logging / reporting configurations
  • Treinamento e validação com eficiência e repetição, o que pode incluir a especificação de subconjuntos de dados específicos, diferentes recursos de computação de hardware, processamento distribuído e monitoramento de progressoTraining and validating efficiently and repeatably, which might include specifying specific data subsets, different hardware compute resources, distributed processing, and progress monitoring
  • Implantação, incluindo controle de versão, dimensionamento, provisionamento e controle de acessoDeployment, including versioning, scaling, provisioning, and access control
  • Publicação de um pipeline em um ponto de extremidade REST para executar novamente de qualquer biblioteca HTTPPublishing a pipeline to a REST endpoint to rerun from any HTTP library

Uma PythonScriptStep é uma etapa básica e interna para executar um script do Python em um destino de computação.A PythonScriptStep is a basic, built-in step to run a Python Script on a compute target. Ele usa um nome de script e outros parâmetros opcionais, tais como argumentos para o script, destino de computação, entradas e saídas.It takes a script name and other optional parameters like arguments for the script, compute target, inputs and outputs. O código a seguir é um exemplo simples de um PythonScriptStep.The following code is a simple example of a PythonScriptStep. Para obter um exemplo de um script de train.py, consulte a subseção tutorial.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
)

Após a criação de pelo menos uma etapa, as etapas podem ser vinculadas e publicadas como um pipeline automatizado simples.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)

Para obter um exemplo abrangente de criação de um fluxo de trabalho de pipeline, siga o tutorial avançado.For a comprehensive example of building a pipeline workflow, follow the advanced tutorial.

Padrão para criar e usar pipelinesPattern for creating and using pipelines

Um pipeline do Azure Machine Learning é associado a um workspace do Azure Machine Learning e uma etapa de pipeline é associada a um destino de computação disponível nesse espaço de trabalho.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. Para obter mais informações, confira este artigo sobre workspaces ou esta explicação de destinos de computação.For more information, see this article about workspaces or this explanation of compute targets.

Um padrão comum para etapas de pipeline é:A common pattern for pipeline steps is:

  1. Especificar workspace, computação e armazenamentoSpecify workspace, compute, and storage
  2. Configurar os dados de entrada e saída usandoConfigure your input and output data using
    1. Dataset, que disponibiliza um armazenamento de dados existente do AzureDataset which makes available an existing Azure datastore
    2. PipelineDataset, que encapsula dados tabulares tipadosPipelineDataset which encapsulates typed tabular data
    3. PipelineData, que é usado para arquivos intermediários ou dados de diretório gravados por uma etapa e destinados a serem consumidos por outraPipelineData which is used for intermediate file or directory data written by one step and intended to be consumed by another
  3. Definir uma ou mais etapas de pipelineDefine one or more pipeline steps
  4. Criar uma instância de um pipeline usando seu workspace e suas etapasInstantiate a pipeline using your workspace and steps
  5. Criar um experimento para o qual você envia o pipelineCreate an experiment to which you submit the pipeline
  6. Monitorar os resultados do experimentoMonitor the experiment results

Este notebook é um bom exemplo desse padrão.This notebook is a good example of this pattern. trabalhojob

Para obter mais informações sobre pipelines de Azure Machine Learning e, em particular, como eles são diferentes de outros tipos de pipelines, consulte este artigo.For more information about Azure Machine Learning Pipelines, and in particular how they are different from other types of pipelines, see this article.

AutoMLConfigAutoMLConfig

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

Use a classe AutoMLConfig para configurar parâmetros para treinamento do machine learning automatizado.Use the AutoMLConfig class to configure parameters for automated machine learning training. O machine learning automatizado itera em várias combinações de algoritmos de machine learning e configurações de hiperparâmetro.Automated machine learning iterates over many combinations of machine learning algorithms and hyperparameter settings. Em seguida, ele encontra o modelo de melhor ajuste com base na métrica de precisão escolhida.It then finds the best-fit model based on your chosen accuracy metric. A configuração permite especificar:Configuration allows for specifying:

  • Tipo de tarefa (classificação, regressão, previsão)Task type (classification, regression, forecasting)
  • O número de iterações de algoritmos e o tempo máximo por iteraçãoNumber of algorithm iterations and maximum time per iteration
  • Métrica de precisão para otimizarAccuracy metric to optimize
  • Os algoritmos para adicionar à lista de bloqueios/lista de permissõesAlgorithms to blacklist/whitelist
  • Número de validações cruzadasNumber of cross-validations
  • Destinos de computaçãoCompute targets
  • Dados de treinamentoTraining data

Observação

Use o automl extra em sua instalação para usar o machine learning automatizado.Use the automl extra in your installation to use automated machine learning.

Para obter guias e exemplos detalhados de como configurar experiências de machine learning automatizado, confira o tutorial e as instruções.For detailed guides and examples of setting up automated machine learning experiments, see the tutorial and how-to.

O código a seguir ilustra como criar um objeto de configuração de machine learning automatizado para um modelo de classificação e usá-lo ao enviar um experimento.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
                            )

Use o objeto automl_config para enviar um experimento.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)

Depois de enviar o experimento, a saída mostra a precisão de treinamento para cada iteração à medida que ela é concluída.After you submit the experiment, output shows the training accuracy for each iteration as it finishes. Depois que a execução é concluída, um objeto AutoMLRun (que estende a classe Run) é retornado.After the run is finished, an AutoMLRun object (which extends the Run class) is returned. Obtenha o modelo de melhor ajuste usando a função get_output() para retornar um objeto Model.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)

Implantação de modeloModel deploy

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

A classe InferenceConfig é para definições de configuração que descrevem o ambiente necessário para hospedar o modelo e o serviço Web.The InferenceConfig class is for configuration settings that describe the environment needed to host the model and web service.

Webservice é a classe pai abstrata para criar e implantar serviços Web para seus modelos.Webservice is the abstract parent class for creating and deploying web services for your models. Para ver um guia detalhado sobre como se preparar para a implantação de modelo e como implantar serviços Web, confira estas instruções.For a detailed guide on preparing for model deployment and deploying web services, see this how-to.

Use ambientes ao implantar um modelo como um serviço Web.You can use environments when you deploy your model as a web service. Os ambientes habilitam um fluxo de trabalho reproduzível e conectado em que é possível implantar um modelo usando as mesmas bibliotecas na computação de treinamento e de inferência.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. Internamente, os ambientes são implementados como imagens do Docker.Internally, environments are implemented as Docker images. Você pode usar qualquer uma das imagens fornecidas pela Microsoft ou usar suas próprias imagens personalizadas do Docker.You can use either images provided by Microsoft, or use your own custom Docker images. Se você já tiver usado a classe ContainerImage na implantação, confira a classe DockerSection para criar um fluxo de trabalho semelhante com ambientes.If you were previously using the ContainerImage class for your deployment, see the DockerSection class for accomplishing a similar workflow with environments.

Para implantar um serviço Web, combine o ambiente, a computação de inferência, o script de pontuação e o modelo registrado em seu objeto de implantação, deploy().To deploy a web service, combine the environment, inference compute, scoring script, and registered model in your deployment object, deploy().

O exemplo a seguir pressupõe que você já concluiu uma execução de treinamento usando o ambiente, myenv, e deseja implantar esse modelo nas Instâncias de Contêiner do Azure.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)

Este exemplo cria um serviço Web de Instâncias de Contêiner do Azure, que é melhor para testes de pequena escala e implantações rápidas.This example creates an Azure Container Instances web service, which is best for small-scale testing and quick deployments. Para implantar o modelo como um serviço Web em escala de produção, use o AKS (Serviço de Kubernetes do Azure).To deploy your model as a production-scale web service, use Azure Kubernetes Service (AKS). Para obter mais informações, confira Classe AksCompute.For more information, see AksCompute class.

DatasetDataset

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

A classe Dataset é um recurso fundamental para explorar e gerenciar dados no Azure Machine Learning.The Dataset class is a foundational resource for exploring and managing data within Azure Machine Learning. Você pode explorar seus dados com estatísticas resumidas e salvá-lo no workspace do AML para obter funcionalidades de controle de versão e de reprodutibilidade.You can explore your data with summary statistics, and save the Dataset to your AML workspace to get versioning and reproducibility capabilities. Os conjuntos de dados são facilmente consumidos por modelos durante o treinamento.Datasets are easily consumed by models during training. Para obter exemplos de uso detalhados, confira o guia de instruções.For detailed usage examples, see the how-to guide.

  • TabularDataset representa dados em um formato tabular criado analisando um arquivo ou lista de arquivos.TabularDataset represents data in a tabular format created by parsing a file or list of files.
  • FileDataset faz referência a um ou vários arquivos em repositórios de armazenamento ou de URLs públicas.FileDataset references single or multiple files in datastores or from public URLs.

O exemplo a seguir mostra como criar um TabularDataset apontando para um único caminho em um armazenamento de dados.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()

O exemplo a seguir mostra como criar um FileDataset referenciando múltiplas URLs de arquivo.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)

Próximas etapasNext steps

Experimente estas próximas etapas para aprender a usar o SDK do Azure Machine Learning para Python:Try these next steps to learn how to use the Azure Machine Learning SDK for Python:

  • Siga o tutorial para aprender a criar, treinar e implantar um modelo em Python.Follow the tutorial to learn how to build, train, and deploy a model in Python.

  • Pesquise classes e módulos na documentação de referência deste site usando o sumário à esquerda.Look up classes and modules in the reference documentation on this site by using the table of contents on the left.