Resolver problemas nos pipelines de aprendizagem automática

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

Neste artigo, aprende como diagnosticar erros que ocorrem ao executar um pipeline de machine learning no Azure Machine Learning SDK e no designer Azure Machine Learning.

Sugestões de resolução de problemas

A tabela seguinte apresenta problemas comuns durante o desenvolvimento de pipelines, com soluções possíveis.

Erros de autenticação

Se você executar uma operação de gerenciamento em um destino de computação a partir de um trabalho remoto, receberá um dos seguintes erros:

{"code":"Unauthorized","statusCode":401,"message":"Unauthorized","details":[{"code":"InvalidOrExpiredToken","message":"The request token was either invalid or expired. Please try again with a valid token."}]}

{"error":{"code":"AuthenticationFailed","message":"Authentication failed."}}

Por exemplo, recebe um erro se tentar criar ou anexar um destino de computação a um pipeline de ML que submete para ser executado remotamente.

Solução de problemas ParallelRunStep

O script para um ParallelRunStepdeve conter duas funções:

• init(): Use esta função para qualquer preparação dispendiosa ou comum para inferência posterior. Por exemplo, use-o para carregar o modelo em um objeto global. Esta função é chamada apenas uma vez no início do processo.
• run(mini_batch): A função é executada para cada mini_batch instância.
  • mini_batch: ParallelRunStep invoca o método run e passa uma lista ou pandas DataFrame como argumento ao método. Cada entrada em mini_batch é um caminho de ficheiro se a entrada for um FileDataset ou um pandas DataFrame se a entrada for um TabularDataset.
  • response: O run() método deve devolver um pandas DataFrame ou um array. Para append_rowoutput_action, estes elementos devolvidos são anexados ao ficheiro de saída comum. Para summary_only, o conteúdo dos elementos é ignorado. Para todas as ações de saída, cada elemento de saída retornado indica uma execução bem-sucedida do elemento de entrada no minilote de entrada. Certifique-se de que sejam incluídos dados suficientes no resultado da execução para mapear a entrada ao resultado de execução. A saída de execução é escrita no ficheiro de saída e não é garantido que esteja em ordem; deve usar uma chave na saída para associá-la à entrada.

%%writefile digit_identification.py
# Snippets from a sample script.
# Refer to the accompanying digit_identification.py
# (https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/machine-learning-pipelines/parallel-run)
# for the implementation script.

import os
import numpy as np
import tensorflow as tf
from PIL import Image
from azureml.core import Model


def init():
    global g_tf_sess

    # Pull down the model from the workspace
    model_path = Model.get_model_path("mnist")

    # Construct a graph to execute
    tf.reset_default_graph()
    saver = tf.train.import_meta_graph(os.path.join(model_path, 'mnist-tf.model.meta'))
    g_tf_sess = tf.Session()
    saver.restore(g_tf_sess, os.path.join(model_path, 'mnist-tf.model'))


def run(mini_batch):
    print(f'run method start: {__file__}, run({mini_batch})')
    resultList = []
    in_tensor = g_tf_sess.graph.get_tensor_by_name("network/X:0")
    output = g_tf_sess.graph.get_tensor_by_name("network/output/MatMul:0")

    for image in mini_batch:
        # Prepare each image
        data = Image.open(image)
        np_im = np.array(data).reshape((1, 784))
        # Perform inference
        inference_result = output.eval(feed_dict={in_tensor: np_im}, session=g_tf_sess)
        # Find the best probability, and add it to the result list
        best_result = np.argmax(inference_result)
        resultList.append("{}: {}".format(os.path.basename(image), best_result))

    return resultList

Se você tiver outro arquivo ou pasta no mesmo diretório do script de inferência, poderá fazer referência a ele localizando o diretório de trabalho atual.

script_dir = os.path.realpath(os.path.join(__file__, '..',))
file_path = os.path.join(script_dir, "<file_name>")

Parâmetros para ParallelRunConfig

ParallelRunConfig é a configuração principal para uma ParallelRunStep instância dentro do pipeline Azure Machine Learning. Use-o para encapsular o seu script e configurar os parâmetros necessários, incluindo todas as seguintes entradas:

• entry_script: Um script de utilizador como um caminho de ficheiro local que corre em paralelo em múltiplos nós. Se source_directory estiver presente, use um caminho relativo. Caso contrário, use qualquer caminho acessível na máquina.
• mini_batch_size: O tamanho do mini-batch passado para uma chamada única run(). (opcional; o valor padrão é 10 ficheiros para FileDataset e 1MB para TabularDataset.)
  • Para FileDataset, é o número de arquivos com um valor mínimo de 1. Você pode combinar vários arquivos em um minilote.
  • Para TabularDataset, é o tamanho dos dados. Os valores de exemplo são 1024, 1024KB, 10MBe 1GB. O valor recomendado é 1MB. O mini-lote de TabularDataset nunca ultrapassa os limites dos ficheiros. Por exemplo, se você tiver .csv arquivos com vários tamanhos, o menor arquivo é de 100 KB e o maior é de 10 MB. Se definir mini_batch_size = 1MB, os arquivos com tamanho menor que 1 MB serão tratados como um mini-lote. Os ficheiros com um tamanho superior a 1 MB são divididos em vários mini-lotes.
• error_threshold: O número de falhas de registo para TabularDataset e falhas de ficheiro para FileDataset que o processo ignora. Se a contagem de erros para toda a entrada ultrapassar esse valor, o trabalho será abortado. O limiar de erro aplica-se a toda a entrada e não a mini-lotes individuais enviados para o run() método. O intervalo é [-1, int.max]. O -1 valor indica ignorar todas as falhas durante o processamento.
• output_action: Um dos seguintes valores indica como a saída é organizada:
  • summary_only: O script de usuário armazena a saída. ParallelRunStep usa a saída apenas para o cálculo do limite de erro.
  • append_row: Para todas as entradas, apenas um arquivo é criado na pasta de saída para acrescentar todas as saídas separadas por linha.
• append_row_file_name: Para personalizar o nome do ficheiro de saída para append_rowoutput_action (opcional; valor padrão é parallel_run_step.txt).
• source_directory: Caminhos para pastas que contêm todos os arquivos a serem executados no destino de computação (opcional).
• compute_target: Somente AmlCompute é suportado.
• node_count: O número de nós de computação a usar para executar o script de utilizador.
• process_count_per_node: O número de processos por nó. Defina este valor para o número de GPU ou CPU que está disponível em um nó (opcional; o valor por defeito é 1).
• environment: A definição do ambiente Python. Você pode configurá-lo para usar um ambiente Python existente ou para configurar um ambiente temporário. A definição também é responsável por definir as dependências de aplicativo necessárias (opcional).
• logging_level: Verbosidade de log. Os valores no aumento da verbosidade são: WARNING, INFO, e DEBUG. (opcional; o valor padrão é INFO)
• run_invocation_timeout: O run() tempo limite de invocação do método em segundos. (opcional; o valor padrão é 60)
• run_max_try: Contagem máxima de tentativas de run() para um minilote. A run() falha se uma exceção for lançada, ou se não devolver nada quando run_invocation_timeout é atingida (opcional; o valor padrão é 3).

Pode especificar mini_batch_size, node_count, process_count_per_node, logging_level, run_invocation_timeout, e run_max_try como PipelineParameter valores. Quando reenvia uma execução de pipeline, pode afinar estes valores de parâmetros. Neste exemplo, usa-se PipelineParameter para mini_batch_size e process_count_per_node, e altera-se esses valores quando se reenvia uma execução mais tarde.

Parâmetros para criar o ParallelRunStep

Crie o ParallelRunStep usando o script, configuração do ambiente e parâmetros. Especifique o destino de computação que você já anexou ao seu espaço de trabalho como o destino de execução para seu script de inferência. Use ParallelRunStep para criar a etapa de pipeline de inferência em lote, que aceita todos os seguintes parâmetros:

• name: O nome da etapa. O nome deve ser único, de 3 a 32 caracteres, e corresponder à regex ^[a-z]([-a-z0-9]*[a-z0-9])?$.
• parallel_run_config: Um ParallelRunConfig objeto, conforme definido anteriormente.
• inputs: Um ou mais conjuntos de dados Azure Machine Learning de tipo único para particionar para processamento paralelo.
• side_inputs: Um ou mais dados de referência ou conjuntos de dados usados como entradas secundárias sem necessidade de ser particionados.
• output: Um OutputFileDatasetConfig objeto que corresponde ao diretório de saída.
• arguments: Uma lista de argumentos passados para o script de usuário. Use unknown_args para os recuperar no seu script de entrada (opcional).
• allow_reuse: Se o passo deve reutilizar resultados anteriores quando executado com as mesmas definições e entradas. Se definir este parâmetro para False, o pipeline gera uma nova execução para este passo durante a execução do pipeline. (opcional; o valor padrão é True.)

from azureml.pipeline.steps import ParallelRunStep

parallelrun_step = ParallelRunStep(
    name="predict-digits-mnist",
    parallel_run_config=parallel_run_config,
    inputs=[input_mnist_ds_consumption],
    output=output_dir,
    allow_reuse=True
)

Técnicas de depuração

Existem três técnicas principais para depurar pipelines:

• Depure etapas individuais do pipeline no seu computador local.
• Use o registo e o Application Insights para isolar e diagnosticar a origem do problema.
• Anexe um depurador remoto a um pipeline em execução no Azure.

Depurar scripts localmente

Uma das falhas mais comuns em um pipeline é que o script de domínio não é executado como pretendido ou contém erros de tempo de execução no contexto de computação remota que são difíceis de depurar.

As pipelines em si não podem ser executadas localmente. Mas executar os scripts isoladamente no seu computador local permite-lhe depurar mais rapidamente porque não precisa esperar pelo processo de configuração do ambiente computacional. Algum trabalho de desenvolvimento é necessário para fazer isso:

• Se os dados estiverem em um armazenamento de dados na nuvem, você precisará baixar os dados e disponibilizá-los para o script. Usar uma pequena amostra de seus dados é uma boa maneira de reduzir o tempo de execução e obter rapidamente feedback sobre o comportamento do script
• Se você estiver tentando simular uma etapa de pipeline intermediária, talvez seja necessário criar manualmente os tipos de objeto que o script específico está esperando da etapa anterior
• Você precisa definir seu próprio ambiente e replicar as dependências definidas em seu ambiente de computação remota

Depois de ter uma configuração de script para ser executada em seu ambiente local, é mais fácil fazer tarefas de depuração como:

• Anexando uma configuração de depuração personalizada
• Pausando a execução e inspecionando o estado do objeto
• Detetando erros lógicos ou de tipo que não serão expostos até ao momento de execução

Configurar, gravar e revisar logs de pipeline

Testar scripts localmente é uma ótima maneira de depurar os principais fragmentos de código e a lógica complexa antes de começar a criar um pipeline. Em algum momento, você precisa depurar scripts durante a própria execução do pipeline, especialmente ao diagnosticar o comportamento que ocorre durante a interação entre as etapas do pipeline. Use instruções liberais print() nos seus scripts de passo para que possa ver o estado do objeto e os valores esperados durante a execução remota, semelhante a quando depura código JavaScript.

Opções e comportamento de registos

A tabela seguinte fornece informações sobre diversas opções de depuração para pipelines. Não é uma lista exaustiva, pois existem outras opções além apenas das do Azure Machine Learning e Python mostradas aqui.

Exemplo de opções de registo

import logging

from azureml.core.run import Run

run = Run.get_context()

# Azure Machine Learning Scalar value logging
run.log("scalar_value", 0.95)

# Python print statement
print("I am a python print statement, I will be sent to the driver logs.")

# Initialize Python logger
logger = logging.getLogger(__name__)
logger.setLevel(args.log_level)

# Plain Python logging statements
logger.debug("I am a plain debug statement, I will be sent to the driver logs.")
logger.info("I am a plain info statement, I will be sent to the driver logs.")

handler = AzureLogHandler(connection_string='<connection string>')
logger.addHandler(handler)

Designer do Azure Machine Learning

Para pipelines que crias no designer, podes encontrar o ficheiro 70_driver_log na página de autoria ou na página de detalhes de execução do pipeline.

Habilite o registro em log para pontos de extremidade em tempo real

Para diagnosticar e depurar endpoints em tempo real no designer, use o SDK para ativar o registo do Application Insights. Ao utilizar registos, pode resolver e depurar problemas de implementação e utilização do modelo. Para obter mais informações, consulte Registo para modelos implantados.

Obter logs da página de criação

Quando se submete uma execução de pipeline e se permanece na página de edição, é possível encontrar os arquivos de log gerados para cada componente à medida que este termina de ser executado.

1. Selecione um componente que conclua a execução na área de autoria.

2. No painel direito do componente, vá para o separador Saídas + logs.

3. Expanda o painel direito e selecione o ficheiro70_driver_log.txt para o visualizar no navegador. Você também pode baixar registos localmente.

   

Obter logs de execuções de pipeline

Também pode encontrar os arquivos de log para execuções específicas na página de detalhes da execução do pipeline. Pode encontrar esta página na secção Pipelines ou Experiências do estúdio.

1. Selecione uma execução de pipeline criada no designer.

   

2. Selecione um componente no painel de visualização.

3. No painel direito do componente, vá para o separador Saídas + logs.

4. Expanda o painel direito para ver o ficheiro std_log.txt no navegador ou selecione o ficheiro para transferir os logs localmente.

Depuração interativa com o Visual Studio Code

Em alguns casos, talvez seja necessário depurar interativamente o código Python usado no pipeline de ML. Ao utilizar o Visual Studio Code (VS Code) e o debugpy, pode anexar ao código tal como é executado no ambiente de treino. Para mais informações, consulte o guia de depuração interativa no VS Code.

HyperdriveStep e AutoMLStep falham com isolamento de rede

Depois de usar o HyperdriveStep e o AutoMLStep, ao tentar registar o modelo, pode receber um erro.

• Você está usando o SDK do Azure Machine Learning v1.

• Seu espaço de trabalho do Azure Machine Learning está configurado para isolamento de rede (VNet).

• O seu pipeline tenta registar o modelo gerado pelo passo anterior. Por exemplo, no exemplo seguinte, o parâmetro inputs é o saved_model de um HyperdriveStep.

  register_model_step = PythonScriptStep(script_name='register_model.py',
                                     name="register_model_step01",
                                     inputs=[saved_model],
                                     compute_target=cpu_cluster,
                                     arguments=["--saved-model", saved_model],
                                     allow_reuse=True,
                                     runconfig=rcfg)
  

Solução

Para contornar esse erro, use a classe Run para obter o modelo criado a partir do HyperdriveStep ou AutoMLStep. O seguinte script de exemplo obtém o modelo de saída de um HyperdriveStep:

%%writefile $script_folder/model_download9.py
import argparse
from azureml.core import Run
from azureml.pipeline.core import PipelineRun
from azureml.core.experiment import Experiment
from azureml.train.hyperdrive import HyperDriveRun
from azureml.pipeline.steps import HyperDriveStepRun

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--hd_step_name', 
        type=str, dest='hd_step_name', 
        help='The name of the step that runs AutoML training within this pipeline')
        
        
    
    args = parser.parse_args()
    
    current_run = Run.get_context()

    pipeline_run = PipelineRun(current_run.experiment, current_run.experiment.name)

    hd_step_run = HyperDriveStepRun((pipeline_run.find_step_run(args.hd_step_name))[0])
    hd_best_run = hd_step_run.get_best_run_by_primary_metric()

    print(hd_best_run)
    hd_best_run.download_file("outputs/model/saved_model.pb", "saved_model.pb")
    
    
    print("Successfully downloaded model") 

Pode usar o ficheiro de um PythonScriptStep:

from azureml.pipeline.steps import PythonScriptStep
conda_dep = CondaDependencies()
conda_dep.add_pip_package("azureml-sdk")
conda_dep.add_pip_package("azureml-pipeline")

rcfg = RunConfiguration(conda_dependencies=conda_dep)

model_download_step = PythonScriptStep(
    name="Download Model 9",
    script_name="model_download9.py", 
    arguments=["--hd_step_name", hd_step_name],
    compute_target=compute_target,
    source_directory=script_folder,
    allow_reuse=False,
    runconfig=rcfg
)

Próximos passos

• Para obter um tutorial completo usando ParallelRunStep, consulte o Tutorial: Criar um pipeline do Azure Machine Learning para pontuação em lote.

• Para obter um exemplo completo mostrando o aprendizado de máquina automatizado em pipelines de ML, consulte Usar ML automatizado em um pipeline do Azure Machine Learning em Python.

• Consulte a referência do SDK para obter ajuda com o pacote azureml-pipelines-core e o pacote azureml-pipelines-steps .

• Consulte a lista de exceções do designer e códigos de erro.