Treine modelos scikit-learn em escala com Azure Machine Learning (SDK v1)

APLICA-SE A: Azure Machine Learning SDK v1 para Python

Neste artigo, aprenda como executar os seus scripts de treino scikit-learn com o Azure Machine Learning.

Os scripts de exemplo neste artigo são usados para classificar imagens de flores de íris para criar um modelo de aprendizado de máquina baseado no conjunto de dados de íris do scikit-learn.

Quer esteja a treinar um modelo de machine learning do scikit-learn desde o início ou a trazer um modelo existente para a cloud, pode usar o Azure Machine Learning para escalar trabalhos de treino de código aberto usando recursos elásticos de computação em nuvem. Pode construir, implementar, versionar e monitorizar modelos de produção com o Azure Machine Learning.

Pré-requisitos

Pode executar este código numa instância de computação do Azure Machine Learning, ou no seu próprio Jupyter Notebook:

• Azure Machine Learning instância de computação

  • Complete o Quickstart: Comece com Azure Machine Learning para criar uma instância de computação. Cada instância de computação inclui um servidor de notebooks dedicado pré-instalado com o SDK e o repositório de exemplo de notebooks.
  • Selecione o separador de cadernos no Azure Machine Learning studio. Na pasta de treinamento de exemplos, localize um bloco de anotações concluído e expandido navegando até este diretório: how-to-use-azureml > ml-frameworks > scikit-learn > train-hyperparameter-tune-deploy-with-sklearn folder.
  • Você pode usar o código pré-preenchido na pasta de treinamento de exemplo para concluir este tutorial.

• Crie um servidor Jupyter Notebook e execute o código nas secções seguintes.

  • Instalar o SDK Azure Machine Learning (>= 1.13.0).
  • Crie um arquivo de configuração do espaço de trabalho.

Configurar a experiência

Esta secção prepara a experiência de treino carregando os pacotes Python necessários, inicializando um espaço de trabalho, definindo o ambiente de treino e preparando o script de treino.

Inicializar um espaço de trabalho

O Azure Machine Learning workspace é o recurso de topo do serviço. Ele fornece um local centralizado para trabalhar com todos os artefatos que você cria. No Python SDK, pode aceder aos artefactos do espaço de trabalho criando um objeto workspace.

Crie um objeto de espaço de trabalho a partir do config.json arquivo criado na seção de pré-requisitos.

from azureml.core import Workspace

ws = Workspace.from_config()

Preparar scripts

Neste tutorial, o script training train_iris.py já é fornecido para si. Na prática, deves conseguir pegar em qualquer script de treino personalizado tal como está e executá-lo com o Azure Machine Learning sem teres de modificar o teu código.

Defina seu ambiente

Para definir o Ambiente do Azure Machine Learning que encapsula as dependências do seu script de treino, pode definir um ambiente personalizado ou usar um ambiente curado do Azure Machine Learning.

Utilize um ambiente controlado

Opcionalmente, Azure Machine Learning fornece ambientes pré-construídos, curados caso não queiras definir o teu próprio ambiente.

Se você quiser usar um ambiente com curadoria, você pode executar o seguinte comando:

from azureml.core import Environment

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

Criar um ambiente personalizado

Você também pode criar seu próprio ambiente personalizado. Defina suas dependências de conda em um arquivo YAML; Neste exemplo, o arquivo é chamado conda_dependencies.yml.

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

Crie um ambiente Azure Machine Learning a partir desta especificação do ambiente Conda. O ambiente será empacotado em um contêiner do Docker em tempo de execução.

from azureml.core import Environment

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

Para mais informações sobre a criação e utilização de ambientes, veja Criar e usar ambientes de software em Azure Machine Learning.

Configurar e enviar sua execução de treinamento

Criar uma configuração de execução de script

Crie um objeto ScriptRunConfig para especificar os detalhes de configuração do seu trabalho de treinamento, incluindo o script de treinamento, o ambiente a ser usado e o destino de computação a ser executado. Quaisquer argumentos para o seu script de treinamento, se especificados no parâmetro arguments, serão passados através da linha de comandos.

O código a seguir configurará um objeto ScriptRunConfig para enviar seu trabalho para execução em sua máquina local.

from azureml.core import ScriptRunConfig

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

Se, em vez disso, desejar executar seu trabalho em um cluster remoto, você pode especificar o destino de computação desejado para o compute_target parâmetro de ScriptRunConfig.

from azureml.core import ScriptRunConfig

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

Envie a sua corrida

from azureml.core import Experiment

run = Experiment(ws,'Tutorial-TrainIRIS').submit(src)
run.wait_for_completion(show_output=True)

O que acontece durante a execução da execução

À medida que o processo é realizado, ele passa pelas seguintes etapas:

• Preparação: Uma imagem docker é criada de acordo com o ambiente definido. A imagem é carregada no registro de contêiner do espaço de trabalho e armazenada em cache para execuções posteriores. Os logs também são transmitidos para o histórico de execução e podem ser visualizados para monitorar o progresso. Se, em vez disso, um ambiente com curadoria for especificado, a imagem armazenada em cache que dá suporte àquele ambiente com curadoria será usada.

• Dimensionamento: o cluster tenta aumentar a escala se o cluster de IA em lote exigir mais nós para executar a execução do que os atualmente disponíveis.

• Em execução: Todos os scripts na pasta de script são carregados para o destino de computação, os armazenamentos de dados são montados ou copiados e o script é executado. As saídas do stdout e da pasta ./logs são transmitidas para o histórico de execução e podem ser usadas para monitorar a execução.

• Pós-processamento: A pasta ./outputs da execução é copiada para o histórico da execução.

Guardar e registar o modelo

Depois de treinar o modelo, você pode salvá-lo e registrá-lo em seu espaço de trabalho. O registro de modelo permite armazenar e fazer a versão de seus modelos em seu espaço de trabalho para simplificar o gerenciamento e a implantação de modelos.

Adicione o seguinte código ao seu script de treinamento, train_iris.py, para salvar o modelo.

import joblib

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

Registre o modelo em seu espaço de trabalho com o código a seguir. Ao especificar os parâmetros model_framework, model_framework_version, e resource_configuration, a implantação do modelo sem código fica disponível. A implantação de modelo sem código permite que você implante diretamente seu modelo como um serviço Web a partir do modelo registrado, e o ResourceConfiguration objeto define o recurso de computação para o serviço Web.

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

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

Implementação

O modelo que acabou de registar pode ser implementado exatamente da mesma forma que qualquer outro modelo registado no Azure Machine Learning. O tutorial de implantação contém uma seção sobre como registrar modelos, mas você pode pular diretamente para a criação de um destino de computação para implantação, uma vez que já tem um modelo registrado.

(Pré-visualização) Implantação de modelo sem código

Em vez da rota de implantação tradicional, você também pode usar o recurso de implantação sem código (visualização) para scikit-learn. A implantação de modelo sem código é suportada para todos os tipos de modelo scikit-learn integrados. Ao registrar seu modelo como mostrado acima com o model_framework, model_framework_versione resource_configuration parâmetros, você pode simplesmente usar a deploy() função estática para implantar seu modelo.

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

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

O guia prático completo guia prático cobre a implementação em Azure Machine Learning com mais profundidade.

Próximos passos

Neste artigo, você treinou e registrou um modelo scikit-learn e aprendeu sobre as opções de implantação. Consulte estes outros artigos para saber mais sobre Azure Machine Learning.

• Acompanhe as métricas de execução durante o treinamento
• Ajustar hiperparâmetros