Modelos de comboio (criar empregos) com o 2.0 CLI (pré-visualização)

A extensão Azure 2.0 CLI para Machine Learning (pré-visualização) permite-lhe acelerar o processo de treino do modelo enquanto escala e sai no cálculo Azure, com o ciclo de vida do modelo rastreado e auditável.

Treinar um modelo de aprendizagem automática é tipicamente um processo iterativo. A ferramenta moderna torna mais fácil do que nunca formar modelos maiores com mais dados mais rapidamente. Processos manuais anteriormente tediosos como a sintonização de hiperparímetros e até mesmo a seleção de algoritmos são muitas vezes automatizados. Com o Azure Machine Learning CLI pode acompanhar os seus trabalhos (e modelos) num espaço de trabalho com varreduras de hiperparametr, escala em computação Azure de alto desempenho e dimensionamento utilizando treino distribuído.

Dica

Para um ambiente de desenvolvimento completo, utilize o Código do Estúdio Visual e a extensão Azure Machine Learning para gerir os recursos de Aprendizagem automática Azure e modelos de aprendizagem de máquinasde comboio.

Importante

Esta funcionalidade encontra-se atualmente em visualização pública. Esta versão de pré-visualização é disponibiliza sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Pré-requisitos

Introdução de postos de trabalho

Para o Azure Machine Learning CLI, os empregos são da autoria em formato YAML. Um trabalho agregado:

  • O que correr
  • Como executá-lo
  • Onde executá-lo

O trabalho "Olá Mundo" tem os três:

command: python -c "print('hello world')"
environment:
  docker:
    image: docker.io/python
compute:
  target: local

Este é apenas um trabalho de exemplo que não produz nada além de uma linha no ficheiro de registo. Normalmente pretende gerar artefactos adicionais, como binários de modelos e metadados que acompanham, além dos registos gerados pelo sistema.

A Azure Machine Learning captura automaticamente os seguintes artefactos:

  • Os ./outputs ./logs diretórios e diretórios recebem tratamento especial pela Azure Machine Learning. Se escrever algum ficheiro a estes diretórios durante o seu trabalho, estes ficheiros serão enviados para o histórico de execução do trabalho para que ainda possa aceder a eles assim que o trabalho estiver concluído. A ./outputs pasta é carregada no final do trabalho, enquanto os ficheiros escritos são ./logs carregados em tempo real. Utilize este último caso pretenda transmitir registos durante o trabalho, tais como registos TensorBoard.
  • A Azure Machine Learning integra-se com a funcionalidade de rastreio da MLflow. Você pode usar mlflow.autolog() para várias estruturas ml comuns para registar parâmetros de modelo, métricas de desempenho, artefactos de modelo, e até gráficos de importância. Também pode usar os mlflow.log_*() métodos para registar explicitamente parâmetros, métricas e artefactos. Todas as métricas e artefactos registados pela MLflow serão guardados na história do trabalho.

Muitas vezes, um trabalho envolve executar algum código fonte que é editado e controlado localmente. Pode especificar um diretório de código fonte para incluir no trabalho, a partir do qual o comando será executado.

Por exemplo, veja o diretório do jobs/train/lightgbm/iris projeto no repositório de exemplos:

.
├── environment.yml
├── job-sweep.yml
├── job.yml
└── src
    └── main.py

Este diretório contém dois ficheiros de trabalho, um ficheiro ambiente conda e uma subdiretório de código fonte src . Embora este exemplo tenha apenas um único ficheiro em src , todo o subdiretório é recursivamente carregado e disponível para uso no trabalho.

O trabalho de comando básico é configurado através do job.yml seguinte:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >
  python main.py 
  --iris-csv {inputs.iris}
inputs:
  iris:
    data:
      path: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
    mode: mount
environment:
  docker:
    image: mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04
  conda_file: file:environment.yml
compute:
  target: azureml:cpu-cluster
experiment_name: lightgbm-iris-example
description: Train a LightGBM model on the Iris dataset.

Este trabalho pode ser criado e executado az ml job create através do --file/-f parâmetro. No entanto, o trabalho visa um cálculo nomeado cpu-cluster que ainda não existe. Para gerir o trabalho localmente primeiro, você pode sobrepor-se ao alvo de computação --set com:

az ml job create -f jobs/train/lightgbm/iris/job.yml --set compute.target=local --web --stream

Enquanto executa este trabalho localmente é mais lento do que correr python main.py em um ambiente python local com os pacotes necessários, o acima permite:

  • Salve a história da execução no estúdio Azure Machine Learning
  • Reproduzir a execução em alvos de computação remota (escalar, escalar, varrer hiperparímetros)
  • Detalhes de submissão de corrida de pista, incluindo o repositório de código fonte git e comprometer
  • Rastreio de métricas de modelo, metadados e artefactos
  • Evite a instalação e gestão de pacotes no seu ambiente local

Importante

O Docker tem de ser instalado e a funcionar localmente. Python precisa ser instalado no ambiente do trabalho. Para as corridas locais que inputs utilizam, o pacote Python azureml-dataprep precisa de ser instalado no ambiente do trabalho.

Dica

Isto levará alguns minutos para puxar a imagem base Docker e criar o ambiente conda em cima dela. Utilize imagens pré-construídas do Docker para evitar o tempo de construção da imagem.

Criar cálculo

Pode criar um cluster de cálculo Azure Machine Learning a partir da linha de comando. Por exemplo, os seguintes comandos criarão um cluster nomeado cpu-cluster e um gpu-cluster nomeado.

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 10 
az ml compute create -n gpu-cluster --type amlcompute --min-instances 0 --max-instances 4 --size Standard_NC12

Note que não é cobrado por computação neste momento e permanecerá em 0 nós até que cpu-cluster um trabalho seja gpu-cluster submetido. Saiba mais sobre como planear e gerir o custo para a AmlCompute.

Use az ml compute create -h para mais detalhes sobre opções de criar computação.

Trabalho básico de treino python

Com cpu-cluster a criação pode executar o trabalho de formação básica, que produz um modelo e acompanhante de metadados. Vamos rever o trabalho ficheiro YAML em detalhe:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >
  python main.py 
  --iris-csv {inputs.iris}
inputs:
  iris:
    data:
      path: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
    mode: mount
environment:
  docker:
    image: mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04
  conda_file: file:environment.yml
compute:
  target: azureml:cpu-cluster
experiment_name: lightgbm-iris-example
description: Train a LightGBM model on the Iris dataset.
Chave Descrição
$schema [Opcional] O esquema yaml. Pode ver o esquema no exemplo acima num browser para ver todas as opções disponíveis para um ficheiro YAML de trabalho de comando. Se utilizar a extensão do Código VS de Aprendizagem de Máquinas Azure para autor do ficheiro YAML, incluindo esta $schema propriedade no topo do seu ficheiro permite-lhe invocar esquemas e conclusões de recursos.
code.local_path [Opcional] O caminho local para o diretório de origem, relativo ao ficheiro YAML, a ser carregado e usado com o trabalho. Considere usar src no mesmo diretório que o(s) ficheiro de trabalho para obter consistência.
command O comando para executar. A > convenção permite a autoria de comandos multiline legíveis dobrando novas linhas para espaços. Os argumentos da linha de comando podem ser explicitamente escritos no comando ou inferidos de outras secções, especificamente inputs search_space ou, utilizando a notação de aparelhos encaracolados.
inputs [Opcional] Um dicionário das ligações de dados de entrada, onde a chave é um nome que especifica para a ligação de entrada. O valor para cada elemento é a ligação de entrada, que consiste data em mode campos e campos. data pode ser 1) uma referência a um ativo de dados Azure Machine Learning existente, utilizando o azureml: prefixo (por exemplo, azureml:iris-url:1 para apontar para a versão 1 de um ativo de dados denominado "iris-url") ou 2) uma definição inline dos dados. Use data.path para especificar uma localização em nuvem. Utilize data.local_path para especificar dados do sistema de ficheiros local que serão enviados para a datastore predefinido. mode indica como pretende que os dados são disponibilizados no computação para o trabalho. "montagem" e "download" são as duas opções suportadas.

Uma entrada pode ser referida no comando pelo seu nome, tal como {inputs.my_input_name} . O Azure Machine Learning resolverá então essa notação parametrizada no comando para a localização desses dados no alvo do cálculo durante o tempo de funcionamento. Por exemplo, se os dados estiverem configurados para serem montados, {inputs.my_input_name} resolver-se-ão até ao ponto de montagem.
environment O ambiente para executar o comando no alvo do cálculo com. Pode definir o ambiente em linha especificando a imagem do Docker para usar ou o Dockerfile para a construção da imagem. Você também pode se referir a um ambiente de versão existente no espaço de trabalho, ou um dos ambientes curados de Azure ML, usando o azureml: prefixo. Por exemplo, azureml:AzureML-TensorFlow2.4-Cuda11-OpenMpi4.1.0-py36:1 referia-se à versão 1 de um ambiente curado para TensorFlow com suporte gpu.

A python deve ser instalada no ambiente utilizado para o treino. Corra apt-get update -y && apt-get install python3 -y no seu Dockerfile para instalar, se necessário.
compute.target O destino de computação. Especifique local para execução local, ou use o azureml: prefixo para referenciar um recurso de computação existente no seu espaço de trabalho. Por exemplo, azureml:cpu-cluster apontaria para um alvo computacional chamado "cpu-cluster".
experiment_name [Opcional] Marca o trabalho para uma melhor organização no estúdio Azure Machine Learning. O registo de cada trabalho será organizado no âmbito da experiência correspondente no separador "Experiment" do estúdio. Se omitido, será o nome do diretório de trabalho onde o trabalho foi criado.
name [Opcional] O nome do trabalho, que deve ser único em todos os trabalhos num espaço de trabalho. A menos que um nome seja especificado no ficheiro YAML através do name campo ou da linha de comando via , um --name/-n GUID/UUID é gerado automaticamente e utilizado para o nome. O nome do trabalho corresponde ao Run ID no estúdio UI do registo de execução do trabalho.

A criação deste trabalho envia quaisquer ativos locais especificados, como o diretório de código fonte, valida o ficheiro YAML e submete a execução. Se necessário, o ambiente é construído, então o cálculo é dimensionado e configurado para executar o trabalho.

Para executar o trabalho de formação lightgbm/íris:

az ml job create -f jobs/train/lightgbm/iris/job.yml --web

Uma vez concluído o trabalho, pode descarregar as saídas:

az ml job download -n $run_id --outputs

Importante

$run_idSubstitua-o pelo ID de execução, que pode ser encontrado na saída da consola ou na página de detalhes de execução do estúdio.

Isto irá descarregar os registos e quaisquer artefactos capturados localmente num diretório chamado $run_id . Para este exemplo, o subdiretório do modelo MLflow-logged será descarregado.

Varrer hiperparmetros

O Azure Machine Learning também permite afinar mais eficientemente os hiperparmetros para os seus modelos de aprendizagem automática. Pode configurar um trabalho de afinação de hiperparímetros, chamado de trabalho de varredura, e submetê-lo através do CLI.

Pode modificar o job.yml in para varrer os job-sweep.yml hiperparímetros:

$schema: https://azuremlschemas.azureedge.net/latest/sweepJob.schema.json
type: sweep_job
algorithm: random
trial:
  code: 
    local_path: src 
  command: >
    python main.py 
    --iris-csv {inputs.iris}
    --learning-rate {search_space.learning_rate}
    --boosting {search_space.boosting}
  inputs:
    iris:
      data:
        path: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
      mode: mount
  environment:
    docker:
      image: mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04
    conda_file: file:environment.yml
  compute:
    target: azureml:cpu-cluster
search_space:
  learning_rate:
    type: uniform
    min_value: 0.01
    max_value: 0.9
  boosting:
    type: choice
    values: ["gbdt", "dart"]
objective:
  primary_metric: test-multi_logloss
  goal: minimize
max_total_trials: 20
max_concurrent_trials: 10
timeout_minutes: 120
experiment_name: lightgbm-iris-sweep-example
description: Run a hyperparameter sweep job for LightGBM on Iris dataset.
Chave Descrição
$schema [Opcional] O esquema YAML, que mudou e agora aponta para o esquema de trabalho de varrimento.
type Do tipo de trabalho.
algorithm O algoritmo de amostragem - "aleatório" é muitas vezes uma boa escolha. Consulte o esquema para a enumeração de opções.
trial A configuração do trabalho de comando para cada ensaio a ser executado. O comando foi trial.command modificado a partir do exemplo anterior para utilizar a {search_space.<hyperparameter_name>} notação para fazer referência aos hiperparmetros definidos no search_space . A Azure Machine Learning resolverá então cada notação parametrizada ao valor do hiperparímetro correspondente que gera para cada ensaio.
search_space Um dicionário dos hiperparímetros para varrer. A chave é um nome para o hiperparímetro, por search_space.learning_rate exemplo, . Note que o nome não tem de corresponder ao argumento do próprio guião de treino, só tem de corresponder à referência do espaço de busca na notação de aparelhos encaracolados no comando, por {search_space.learning_rate} exemplo. O valor é a distribuição do hiperparímetro. Consulte o esquema para a enumeração de opções.
objective.primary_metric A métrica de otimização, que deve corresponder ao nome de uma métrica registada a partir do código de treino. objective.goal especifica a direção ("minimizar"/"maximizar"). Consulte o esquema para a enumeração completa das opções.
max_total_trials O número máximo de provas individuais a decorrer.
max_concurrent_trials [Opcional] O número máximo de ensaios a executar simultaneamente no seu cluster de computação.
timeout_minutes [Opcional] O número máximo de minutos para executar o trabalho de varredura para.
experiment_name [Opcional] A experiência para rastrear o trabalho de varredura sob. Se omitido, ficará em incumprimento do nome do diretório de trabalho quando o trabalho for criado.

Crie emprego e abra no estúdio:

az ml job create -f jobs/train/lightgbm/iris/job-sweep.yml --web

Dica

Varreduras de hiperparímetro podem ser usadas com trabalhos de comando distribuídos.

Preparação distribuída

Pode especificar a distributed secção num trabalho de comando. A Azure ML suporta formação distribuída para quadros compatíveis com PyTorch, Tensorflow e MPI. O PyTorch e o TensorFlow permitem formação distribuída nativa para os respetivos quadros, tais como tf.distributed.Strategy APIs para TensorFlow.

Certifique-se de definir o compute.instance_count , que não é 1 , para o número desejado de nós para o trabalho.

PyTorch

Um ficheiro YAML exemplo para formação PyTorch distribuída no conjunto de dados CIFAR-10:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >
  python train.py 
  --epochs 1
  --data-dir {inputs.cifar}
inputs:
  cifar:
    data:
      local_path: data
    mode: mount
environment: azureml:AzureML-pytorch-1.7-ubuntu18.04-py37-cuda11-gpu:1
compute:
  target: azureml:gpu-cluster
  instance_count: 2
distribution:
  type: pytorch 
  process_count: 4
experiment_name: pytorch-cifar-distributed-example
description: Train a basic convolutional neural network (CNN) with PyTorch on the CIFAR-10 dataset, distributed via PyTorch.

Note que isto se refere aos dados locais, que não estão presentes no repositório de exemplos clonados. Primeiro, você precisa descarregar, extrair e realojar o conjunto de dados CIFAR-10 localmente, colocando-o na localização adequada no diretório do projeto:

wget "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
tar -xvzf cifar-10-python.tar.gz
rm cifar-10-python.tar.gz
mkdir jobs/train/pytorch/cifar-distributed/data
mv cifar-10-batches-py jobs/train/pytorch/cifar-distributed/data

Crie o trabalho e abra no estúdio:

az ml job create -f jobs/train/pytorch/cifar-distributed/job.yml --web

TensorFlow

Um ficheiro YAML de exemplo para a formação de TensorFlow distribuído no conjunto de dados MNIST:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code:
  local_path: src
command: >
  python train.py 
  --epochs 1
  --model-dir outputs/keras-model
environment: azureml:AzureML-tensorflow-2.4-ubuntu18.04-py37-cuda11-gpu:1
compute:
  target: azureml:gpu-cluster
  instance_count: 2
distribution:
  type: tensorflow
  worker_count: 2
experiment_name: tensorflow-mnist-distributed-example
description: Train a basic neural network with TensorFlow on the MNIST dataset, distributed via TensorFlow.

Crie o trabalho e abra no estúdio:

az ml job create -f jobs/train/tensorflow/mnist-distributed/job.yml --web

MPI

Azure ML suporta o lançamento de um trabalho de MPI em vários nós e vários processos por nó. Lança o trabalho mpirun via. Se o seu código de formação utilizar o quadro Horovod para formação distribuída, por exemplo, pode aproveitar este tipo de trabalho para treinar em Azure ML.

Para lançar uma função de MPI, especifique mpi como o tipo e o número de processos por nó a lançar ( ) na process_count_per_instance distribution secção. Se este campo não for especificado, o Azure ML irá por defeito ao lançamento de um processo por nó.

Uma especificação de YAML exemplo, que executa um trabalho tensorFlow em MNIST usando Horovod:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code:
  local_path: src
command: >
  python train.py
  --epochs 1
environment: azureml:AzureML-tensorflow-2.4-ubuntu18.04-py37-cuda11-gpu:1
compute:
  target: azureml:gpu-cluster
  instance_count: 2
distribution:
  type: mpi
  process_count_per_instance: 2
experiment_name: tensorflow-mnist-distributed-horovod-example
description: Train a basic neural network with TensorFlow on the MNIST dataset, distributed via Horovod.

Crie o trabalho e abra no estúdio:

az ml job create -f jobs/train/tensorflow/mnist-distributed-horovod/job.yml --web

Passos seguintes