Share via

Iniciar, monitorar e acompanhar o histórico de execução

  • Artigo

APLICA-SE A:SDK azureml do Python v1

APLICA-SE A:Extensão de ML da CLI do Azure v1

O SDK do Azure Machine Learning para Python v1 e A CLI de Machine Learning fornecem vários métodos para monitorar, organizar e acompanhar suas execuções para treinamento e experimentação. O histórico de execuções de ML é uma parte importante de um processo de desenvolvimento de ML explicativo e repetível.

Dica

Para obter informações sobre como usar o estúdio, confira Rastrear, monitorar e analisar execuções com o estúdio.

Se você estiver usando o SDK do Azure Machine Learning v2, confira os seguintes artigos:

Este artigo mostra como fazer as seguintes tarefas:

  • Monitorar o desempenho de execução.
  • Marcar e localizar execuções.
  • Executar a pesquisa em seu histórico de execuções.
  • Cancelar ou falhar execuções.
  • Criar execuções filhas.
  • Monitore o status de execução por notificação por e-mail.

Dica

Se você estiver procurando informações sobre como monitorar o serviço do Azure Machine Learning e os serviços do Azure associados, consulte como monitorar o Azure Machine Learning. Se você estiver procurando informações sobre modelos de monitoramento implantados como serviços web, consulte Coletar dados de modelo e Monitorar com o Application insights.

Pré-requisitos

Você precisará dos seguintes itens:

Monitorar o desempenho da execução

  • Inicie uma execução e o seu processo de registro em log

    APLICA-SE A:SDK azureml do Python v1

    1. Configure o seu experimento importando as classes Workspace, Experimento, Rune ScriptRunConfig do pacote azureml.core.

      import azureml.core
from azureml.core import Workspace, Experiment, Run
from azureml.core import ScriptRunConfig

ws = Workspace.from_config()
exp = Experiment(workspace=ws, name="explore-runs")

    2. Inicie uma execução e seu processo de registro em log com o start_logging() método.

      notebook_run = exp.start_logging()
notebook_run.log(name="message", value="Hello from run!")

  • Monitore o status das atualizações

    APLICA-SE A:SDK azureml do Python v1

    • Obtenha o status de uma execução com o get_status() método.

      print(notebook_run.get_status())

    • Para obter a ID de execução, o tempo de execução e outros detalhes sobre a ela, use o get_details() método.

      print(notebook_run.get_details())

    • Quando a sua execução for concluída com êxito, use o complete() método para marcá-la como concluída.

      notebook_run.complete()
print(notebook_run.get_status())

    • Se você usar o padrão de design do Python with...as, a execução se marcará automaticamente como concluída quando ela estiver fora do escopo. Você não precisa marcar manualmente a execução como concluída.

      with exp.start_logging() as notebook_run:
    notebook_run.log(name="message", value="Hello from run!")
    print(notebook_run.get_status())

print(notebook_run.get_status())

Marcar e localizar execuções

No Azure Machine Learning, você pode usar as propriedades e as marcações para ajudar a organizar e consultar suas execuções para obter informações importantes.

  • Adicionar propriedades e marcações

    APLICA-SE A:SDK azureml do Python v1

    Para adicionar metadados pesquisáveis as suas execuções, use o add_properties() método. Por exemplo, o código a seguir adiciona a "author" propriedade à execução:

    local_run.add_properties({"author":"azureml-user"})
print(local_run.get_properties())

    As propriedades são imutáveis e, portanto, criam um registro permanente para fins de auditoria. O exemplo de código a seguir resulta em um erro, porque já adicionamos "azureml-user" como o "author" valor da propriedade no código anterior:

    try:
    local_run.add_properties({"author":"different-user"})
except Exception as e:
    print(e)

    Ao contrário das propriedades, as marcações são mutáveis. Para adicionar informações de pesquisa e significativas para os consumidores de seu experimento, use o tag() método.

    local_run.tag("quality", "great run")
print(local_run.get_tags())

local_run.tag("quality", "fantastic run")
print(local_run.get_tags())

    Você também pode adicionar marcações de cadeia de caracteres simples. Quando essas marcações aparecem no dicionário de marcações como chaves, elas têm um valor de None.

    local_run.tag("worth another look")
print(local_run.get_tags())

  • Propriedades e marcações de consulta

    Você pode consultar execuções em um experimento para retornar uma lista de execuções que correspondem a propriedades e marcações específicas.

    APLICA-SE ASDK do Python azureml v1

    list(exp.get_runs(properties={"author":"azureml-user"},tags={"quality":"fantastic run"}))
list(exp.get_runs(properties={"author":"azureml-user"},tags="worth another look"))

Cancelar ou falhar execuções

Se você notar um erro ou se sua execução estiver demorando muito para ser concluída, você poderá cancelar a execução.

APLICA-SE A:SDK azureml do Python v1

Para cancelar uma execução usando o SDK, use o cancel() método:

src = ScriptRunConfig(source_directory='.', script='hello_with_delay.py')
local_run = exp.submit(src)
print(local_run.get_status())

local_run.cancel()
print(local_run.get_status())

Se a sua execução for concluída, mas contiver um erro (por exemplo, o script de treinamento incorreto foi usado), você poderá usar o fail() método para marcá-lo como com falha.

local_run = exp.submit(src)
local_run.fail()
print(local_run.get_status())

Criar execuções filhas

APLICA-SE A:SDK azureml do Python v1

Crie execuções filhas para agrupar execuções relacionadas, como para diferentes iterações de ajuste de hiperparâmetro.

Observação

As execuções filhas só podem ser criadas usando o SDK.

Este exemplo de código usa o hello_with_children.py script para criar um lote de cinco execuções filhas de dentro de uma execução enviada usando o child_run() método:

!more hello_with_children.py
src = ScriptRunConfig(source_directory='.', script='hello_with_children.py')

local_run = exp.submit(src)
local_run.wait_for_completion(show_output=True)
print(local_run.get_status())

with exp.start_logging() as parent_run:
    for c,count in enumerate(range(5)):
        with parent_run.child_run() as child:
            child.log(name="Hello from child run", value=c)

Observação

À medida que elas saem do escopo, as execuções filhas são automaticamente marcadas como concluídas.

Para criar várias execuções filhas com eficiência, use o create_children() método. Como cada criação resulta em uma chamada de rede, a criação de um lote de execuções é mais eficiente do que criá-las uma a uma.

Enviar execuções filhas

As execuções filhas também podem ser enviadas de uma execução pai. Isso permite que você crie hierarquias de execuções pai e filha. Não é possível criar uma execução filha sem pai: mesmo que a execução pai não faça nada, mas inicie execuções filhas, ainda é necessário criar a hierarquia. Os status de todas as execuções são independentes: um pai pode estar no "Completed" status bem-sucedido mesmo que uma ou mais execuções filhas tenham sido canceladas ou falhado.

Você pode desejar que as suas execuções filhas usem uma configuração de execução diferente da execução pai. Por exemplo, você pode usar uma configuração menos eficiente baseada em CPU para o pai, enquanto usa configurações baseadas em GPU para as filhas. Outro desejo comum é passar diferentes argumentos e dados para cada filha. Para personalizar uma execução filha, crie um ScriptRunConfig objeto para a execução da filha.

Importante

Para enviar uma execução filha de uma execução pai em uma computação remota, você precisa entrar no workspace no código de execução pai primeiro. Por padrão, o objeto de contexto de execução em uma execução remota não tem credenciais para enviar as execuções filhas. Use uma entidade de serviço ou credenciais de identidade gerenciada para entrar. Para obter mais informações sobre a autenticação, confira Configurar a autenticação.

O código abaixo:

  • Recupera um recurso de computação chamado "gpu-cluster" a partir do workspacews
  • Itera sobre valores de argumento diferentes a serem passados para os ScriptRunConfig objetos filhos
  • Cria e envia uma nova execução filha, usando o recurso de computação personalizado e o argumento
  • Bloqueia até que todas as execuções filhas sejam concluídas
# parent.py
# This script controls the launching of child scripts
from azureml.core import Run, ScriptRunConfig

compute_target = ws.compute_targets["gpu-cluster"]

run = Run.get_context()

child_args = ['Apple', 'Banana', 'Orange']
for arg in child_args: 
    run.log('Status', f'Launching {arg}')
    child_config = ScriptRunConfig(source_directory=".", script='child.py', arguments=['--fruit', arg], compute_target=compute_target)
    # Starts the run asynchronously
    run.submit_child(child_config)

# Experiment will "complete" successfully at this point. 
# Instead of returning immediately, block until child runs complete

for child in run.get_children():
    child.wait_for_completion()

Para criar várias execuções filhas com configurações, argumentos e entradas idênticas com eficiência, use o create_children() método. Como cada criação resulta em uma chamada de rede, a criação de um lote de execuções é mais eficiente do que criá-las uma a uma.

Em uma execução filha, você pode exibir a ID de execução pai:

## In child run script
child_run = Run.get_context()
child_run.parent.id

Consultar execuções filhas

Para consultar as execuções filhas de um pai específico, use o get_children() método. O recursive = True argumento permite consultar uma árvore aninhada de filhas e netas.

print(parent_run.get_children())

Log para a execução pai ou raiz

Você pode usar o Run.parent campo para acessar a execução que iniciou a execução filha atual. Um caso de uso comum para usar o Run.parent é combinar resultados de log em um único local. As execuções filhas são executadas de modo assíncrono e não há nenhuma garantia de ordenação ou de sincronização além da capacidade do pai de aguardar a conclusão das execuções filhas.

# in child (or even grandchild) run

def root_run(self : Run) -> Run :
    if self.parent is None : 
        return self
    return root_run(self.parent)

current_child_run = Run.get_context()
root_run(current_child_run).log("MyMetric", f"Data from child run {current_child_run.id}")

Monitorar o status de execução por notificação por e-mail

  1. No portal do Azure, na barra de navegação à esquerda, selecione a guia Monitor.

  2. Selecione Configurações de diagnóstico e, em seguida, selecione + Adicionar configuração de diagnóstico.

    Screenshot of diagnostic settings for email notification.

  3. Na configuração de diagnóstico,

    1. nos detalhes da categoria, selecione AmlRunStatusChangedEvent.
    2. Nos Detalhes de destino, selecione Enviar para o workspace do Log Analytics e especifique a Assinatura e o Workspace do Log Analytics.

    Observação

    O workspace do Log Analytics do Azure é um tipo diferente de recurso do Azure do que o workspace do Serviço do Azure Machine Learning. Se não houver nenhuma opção nessa lista, você poderá criar um Log Analytics no espaço de trabalho.

    Screenshot of configuring the email notification.

  4. Na guia Logs, adicione uma nova regra de alerta.

    Screeenshot of the new alert rule.

  5. Veja como criar, ver e gerenciar alertas de log usando o Azure Monitor.

Blocos de anotações de exemplo

Os seguintes notebooks demonstram os conceitos neste artigo:

Próximas etapas