O que é o SDK do Azure Machine Learning v1 para Python?

Cientistas de dados e desenvolvedores de IA usam o SDK do Azure Machine Learning v1 para Python para criar e executar fluxos de trabalho de aprendizado de máquina com o serviço do Azure Machine Learning. Você pode interagir com o serviço em qualquer ambiente do Python, incluindo Jupyter Notebooks, do Visual Studio Code ou seu IDE do Python favorito.

As principais áreas do SDK incluem:

• Explore, prepare e gerencie o ciclo de vida de seus conjuntos de dados usados em experimentos de machine learning.
• Gerencie recursos de nuvem para monitorar, registrar em log e organizar seus experimentos de machine learning.
• Treine modelos localmente ou usando recursos de nuvem, incluindo treinamento de modelo acelerado por GPU.
• Use o machine learning automatizado, que aceita parâmetros de configuração e dados de treinamento. Ele itera automaticamente por meio de algoritmos e configurações de hiperparâmetro para encontrar o melhor modelo para executar previsões.
• Implante serviços Web para converter seus modelos treinados em serviços RESTful que podem ser consumidos em qualquer aplicativo.

Para obter um passo a passo passo de como começar, experimente o tutorial .

As seções a seguir são visões gerais de algumas das classes mais importantes do SDK e padrões de design comuns para usá-las. Para obter o SDK, consulte o guia de instalação .

Estável versus experimental

O SDK do Azure Machine Learning para Python fornece recursos estáveis e experimentais no mesmo SDK.

Os recursos experimentais são rotulados por uma seção de observação na referência do SDK e indicados por texto, como (versão prévia) em toda documentação do Azure Machine Learning.

Área de trabalho

do namespace :

A classe Workspace é um recurso fundamental na nuvem que você usa para experimentar, treinar e implantar modelos de machine learning. Ele vincula sua assinatura do Azure e o grupo de recursos a um objeto facilmente consumido.

Exiba todos os parâmetros do método create Workspace para reutilizar instâncias existentes (Storage, Key Vault, App-Insights e Azure Container Registry-ACR), bem como modificar configurações adicionais, como configuração de ponto de extremidade privado e destino de computação.

Importe a classe e crie um novo workspace usando o código a seguir. Defina create_resource_group para False se você tiver um grupo de recursos do Azure existente anteriormente que deseja usar para o workspace. Algumas funções podem solicitar credenciais de autenticação do Azure.

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 primeiro gravando-o em um arquivo JSON de configuração. Isso salva seus dados de nome de assinatura, recurso e workspace.

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

Carregue seu workspace lendo o arquivo de configuração.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Como alternativa, use o método de get() estático para carregar um workspace existente sem usar arquivos de configuração.

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.

Experimentar

do namespace :

A classe Experiment é outro recurso de nuvem fundamental que representa uma coleção de avaliações (execuções de modelo individuais). 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 existir.

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 no Workspace.

list_experiments = Experiment.list(ws)

Use a função get_runs para recuperar uma lista de objetos Run (avaliações) de Experiment. O código a seguir recupera as execuções e imprime cada ID de execução.

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

Há duas maneiras de executar uma avaliação de experimento. Se você estiver experimentando interativamente em um jupyter notebook, use a função start_logging. Se você estiver enviando um experimento de um ambiente python padrão, use a função submit. Ambas as funções retornam um objeto Run. A variável experiment representa um objeto Experiment nos exemplos de código a seguir.

Correr

do namespace :

Uma execução representa uma única avaliação de um experimento. 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 resultados e acessar artefatos gerados. 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. A funcionalidade inclui:

• Armazenando e recuperando métricas e dados.
• Usando marcas e a hierarquia filho para facilitar a pesquisa de execuções passadas.
• Registrando arquivos de modelo armazenados para implantação.
• Armazenando, modificando e recuperando propriedades de uma execução.

Crie um objeto Run enviando um objeto Experiment com um objeto de configuração de execução objeto. Use o parâmetro tags para anexar categorias e rótulos personalizados às suas execuções. Você pode encontrá-los e recuperá-los mais tarde de 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. Especifique o parâmetro tags a ser filtrado pela marca criada anteriormente.

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 da execução.

run_details = run.get_details()

A saída para essa função é um dicionário que inclui:

• Executar ID
• Estado
• Hora de início e término
• Destino de computação (local versus nuvem)
• Dependências e versões usadas na execução
• Dados específicos do treinamento (diferem dependendo do tipo de modelo)

Para obter mais exemplos de como configurar e monitorar execuções, consulte o de instruções.

Modelo

do namespace :

A classe Model é usada para trabalhar com representações em nuvem de modelos de machine learning. Os métodos ajudam você a transferir modelos entre ambientes de desenvolvimento locais e o objeto Workspace na nuvem.

Você pode usar o registro de modelo para armazenar e versão de seus modelos na nuvem do Azure, em seu workspace. Os modelos registrados são identificados por nome e versão. Cada vez que você registra um modelo com o mesmo nome de um existente, o Registro incrementa a versão. O Azure Machine Learning dá suporte a qualquer modelo que possa ser carregado por meio do Python 3, não apenas dos modelos do Azure Machine Learning.

O exemplo a seguir mostra como criar um modelo de classificação local simples com scikit-learn, registrar o modelo em Workspacee baixar o modelo da nuvem.

Crie um classificador simples, clf, para prever a variação do cliente com base em sua idade. Em seguida, despeje o modelo em um arquivo .pkl no mesmo diretório.

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 em seu workspace. Especifique o caminho do modelo local e o nome do modelo. Registrar o mesmo nome mais de uma vez criará uma nova versão.

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 em seu workspace, é fácil gerenciar, baixar e organizar seus modelos. Para recuperar um objeto modelo (por exemplo, em outro ambiente) de Workspace, use o construtor de classe e especifique o nome do modelo e quaisquer parâmetros opcionais. Em seguida, use a função download para baixar o modelo, incluindo a estrutura de pastas de nuvem.

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 do Workspace.

model.delete()

Depois de ter um modelo registrado, implantá-lo como um serviço Web é um processo simples. Primeiro, você criar e registrar uma imagem. Esta etapa configura o ambiente do Python e suas dependências, juntamente com um script para definir os formatos de solicitação e resposta do serviço Web. Depois de criar uma imagem, você criar 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. Em seguida, você anexa sua imagem.

ComputeTarget, RunConfiguration e ScriptRunConfig

do namespace :
do namespace :
do namespace :

A classe ComputeTarget é a classe pai abstrata para criar e gerenciar destinos de computação. Um destino de computação representa uma variedade de recursos em que você pode treinar seus modelos de machine learning. Um destino de computação pode ser um computador local ou um recurso de nuvem, como a Computação do Azure Machine Learning, o Azure HDInsight ou uma máquina virtual remota.

Use destinos de computação para aproveitar máquinas virtuais avançadas para treinamento de modelo e configure destinos de computação persistentes ou destinos temporários invocados por runtime. Para obter um guia abrangente sobre como configurar e gerenciar destinos de computação, consulte o de instruções.

O código a seguir mostra um exemplo simples de configuração de um destino de AmlCompute (classe filho de ComputeTarget). Esse destino cria um recurso de computação remota de runtime em seu objeto Workspace. O recurso é dimensionado automaticamente quando um trabalho é enviado. Ele é excluído automaticamente quando a execução é concluída.

Reutilize o modelo de variação de scikit-learn simples e compile-o em seu próprio arquivo, train.py, no diretório atual. No final do arquivo, crie um novo diretório chamado outputs. Esta etapa cria um diretório na nuvem (seu workspace) para armazenar seu modelo treinado que joblib.dump() serializado.

# 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 criando uma instância de um objeto RunConfiguration e definindo o tipo e o tamanho. Este exemplo usa o menor tamanho de recurso (1 núcleo de CPU, 3,5 GB de memória). A variável list_vms contém uma lista de máquinas virtuais com suporte e seus tamanhos.

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 Python do recurso de computação remota usando a classe CondaDependencies. O arquivo train.py está usando scikit-learn e numpy, que precisam ser instalados no ambiente. Você também pode especificar versões de dependências. Use o objeto dependencies para definir o ambiente em 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. Use a classe ScriptRunConfig para anexar a configuração de destino de computação e especificar o caminho/arquivo para o script de treinamento train.py. Envie o experimento especificando o parâmetro config da função submit(). Chame wait_for_completion na execução resultante para ver a saída de execução assíncrona à medida que o ambiente é inicializado e o modelo é treinado.

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 estará disponível em seu workspace.

Ambiente

do namespace :

Os ambientes do Azure Machine Learning especificam os pacotes do Python, as variáveis de ambiente e as configurações de software em torno de seus scripts de treinamento e pontuação. Além do Python, você também pode configurar o PySpark, o Docker e o R para ambientes. Internamente, os ambientes resultam em imagens do Docker usadas para executar os processos de treinamento e pontuação no destino de computação. Os ambientes são entidades gerenciadas e com controle de versão em seu workspace do Machine Learning que permitem fluxos de trabalho de aprendizado de máquina reproduzíveis, auditáveis e portáteis em uma variedade de destinos de computação e tipos de computação.

Você pode usar um objeto Environment para:

• Desenvolva seu script de treinamento.
• Reutilize o mesmo ambiente na Computação do Azure Machine Learning para treinamento de modelo em escala.
• Implante seu modelo com esse mesmo ambiente sem estar vinculado a um tipo de computação específico.

O código a seguir importa a classe Environment do SDK e instancia um objeto de ambiente.

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

Adicione pacotes a um ambiente usando arquivos conda, pip ou roda privada. Especifique cada dependência de pacote usando a classe CondaDependency para adicioná-la à PythonSectiondo ambiente.

O exemplo a seguir adiciona ao ambiente. Ele adiciona a versão 1.17.0 do numpy. Ele também adiciona o pacote pillow ao ambiente, myenv. O exemplo usa o método add_conda_package() e o método add_pip_package(), respectivamente.

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, destino de computaçãoe seu script Python de treinamento em uma configuração de execução. Essa configuração é um objeto wrapper usado para enviar execuções.

Quando você envia uma execução de treinamento, a criação de um novo ambiente pode levar vários minutos. A duração depende do tamanho das dependências necessárias. Os ambientes são armazenados em cache pelo serviço. Portanto, enquanto a definição de ambiente permanecer inalterada, você incorrerá no tempo de instalação completo apenas uma vez.

O exemplo a seguir mostra onde você usaria ScriptRunConfig como objeto wrapper.

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ê.

Consulte a seção Model deploy para usar ambientes para implantar um serviço Web.

Pipeline, PythonScriptStep

do namespace :
do namespace :

Um pipeline do Azure Machine Learning é um fluxo de trabalho automatizado de uma tarefa completa de machine learning. As subtarefas são encapsuladas como uma série de etapas dentro do pipeline. Um pipeline do Azure Machine Learning pode ser tão simples quanto uma etapa que chama um script Python. Os pipelines incluem funcionalidade para:

• Preparação de dados, incluindo importação, validação e limpeza, munging e transformação, normalização e preparo
• Configuração de treinamento, incluindo argumentos de parametrização, caminhos de arquivo e configurações de log/relatório
• Treinamento e validação de maneira eficiente e repetida, 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 progresso
• Implantação, incluindo controle de versão, dimensionamento, provisionamento e acesso
• Publicando um pipeline em um ponto de extremidade REST para executar novamente de qualquer biblioteca HTTP

Um PythonScriptStep é uma etapa básica e interna para executar um Script Python em um destino de computação. Ele usa um nome de script e outros parâmetros opcionais, como argumentos para o script, destino de computação, entradas e saídas. O código a seguir é um exemplo simples de um PythonScriptStep. Para obter um exemplo de um script de train.py, consulte o tutorial sub-seção.

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
)

Depois que pelo menos uma etapa tiver sido criada, as etapas poderão ser vinculadas e publicadas como um pipeline automatizado simples.

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.

Padrão para criar e usar pipelines

Um pipeline do Azure Machine Learning está associado a um workspace do Azure Machine Learning e uma etapa de pipeline está associada a um destino de computação disponível nesse workspace. Para obter mais informações, consulte este artigo sobre workspaces ou esta explicação de destinos de computação.

Um padrão comum para etapas de pipeline é:

1. Especificar workspace, computação e armazenamento
2. Configurar seus dados de entrada e saída usando
   1. de conjunto de dados que disponibiliza um armazenamento de dados existente do Azure
   2. pipelineDataset que encapsula dados tabulares tipados
   3. PipelineData que é usado para dados intermediários de arquivo ou diretório gravados por uma etapa e destinados a serem consumidos por outra
3. Definir uma ou mais etapas de pipeline
4. Criar uma instância de um pipeline usando seu workspace e etapas
5. Criar um experimento para o qual você envia o pipeline
6. Monitorar os resultados do experimento

este bloco de anotações é um bom exemplo desse padrão. trabalho

Para obter mais informações sobre os Pipelines do Azure Machine Learning e, em particular, como eles são diferentes de outros tipos de pipelines, consulte este artigo .

AutoMLConfig

do namespace :

Use a classe AutoMLConfig para configurar parâmetros para treinamento automatizado de machine learning. O aprendizado de máquina automatizado itera em várias combinações de algoritmos de aprendizado de máquina e configurações de hiperparâmetro. Em seguida, ele encontra o modelo de melhor ajuste com base na métrica de precisão escolhida. A configuração permite especificar:

• Tipo de tarefa (classificação, regressão, previsão)
• Número de iterações de algoritmo e tempo máximo por iteração
• Métrica de precisão para otimizar
• Algoritmos para lista de bloqueios/lista de permissões
• Número de validações cruzadas
• Destinos de computação
• Dados de treinamento

Para obter guias detalhados e exemplos de configuração de experimentos automatizados de machine learning, consulte o tutorial e de instruções.

O código a seguir ilustra a criação de um objeto de configuração de machine learning automatizado para um modelo de classificação e o uso quando você está enviando um experimento.

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.

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 conforme ele é concluído. Após a conclusão da execução, um objeto AutoMLRun (que estende a classe Run) é retornado. Obtenha o modelo de melhor ajuste usando a função get_output() para retornar um objeto Model.

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

Implantação de modelo

do namespace :
do namespace :

A classe InferenceConfig é para configurações que descrevem o ambiente necessário para hospedar o modelo e o serviço Web.

Webservice é a classe pai abstrata para criar e implantar serviços Web para seus modelos. Para obter um guia detalhado sobre como preparar para implantação de modelo e implantação de serviços Web, consulte este de instruções.

Você pode usar ambientes ao implantar seu modelo como um serviço Web. Os ambientes permitem um fluxo de trabalho reproduzível e conectado em que você pode implantar seu modelo usando as mesmas bibliotecas na computação de treinamento e na computação de inferência. Internamente, os ambientes são implementados como imagens do Docker. Você pode usar imagens fornecidas pela Microsoft ou usar suas próprias imagens personalizadas do Docker. Se você já estava usando a classe ContainerImage para sua implantação, consulte a classe DockerSection para realizar um fluxo de trabalho semelhante com ambientes.

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().

O exemplo a seguir pressupõe que você já concluiu uma execução de treinamento usando o ambiente, myenve deseja implantar esse modelo nas Instâncias de Contêiner do Azure.

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 em pequena escala e implantações rápidas. Para implantar seu modelo como um serviço Web em escala de produção, use o AKS (Serviço de Kubernetes do Azure). Para obter mais informações, consulte classe AksCompute.

Dataset

do namespace :
do namespace :
do namespace :

A classe Dataset é um recurso fundamental para explorar e gerenciar dados no Azure Machine Learning. Você pode explorar seus dados com estatísticas de resumo e salvar o conjunto de dados em seu workspace AML para obter recursos de controle de versão e reprodução. Os conjuntos de dados são facilmente consumidos por modelos durante o treinamento. Para obter exemplos de uso detalhados, consulte o guia de instruções .

• TabularDataset representa dados em um formato tabular criado analisando um arquivo ou uma lista de arquivos.
• FileDataset faz referência a arquivos únicos ou múltiplos em armazenamentos de dados ou de URLs públicas.

O exemplo a seguir mostra como criar um TabularDataset apontando para um único caminho em um armazenamento de dados.

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 várias URLs de arquivo.

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 etapas

Experimente estas próximas etapas para aprender a usar o SDK do Azure Machine Learning para Python:

• Siga o tutorial para aprender a criar, treinar e implantar um modelo no Python.

• Pesquise classes e módulos na documentação de referência neste site usando o sumário à esquerda.