Iniciar, monitorizar e rastrear o histórico

O Azure Machine Learning SDK para Python, Machine Learning CLIe o Azure Machine Learning studio fornecem vários métodos para monitorizar, organizar e acompanhar as suas corridas para treino e experimentação. O seu histórico de execução de ML é uma parte importante de um processo de desenvolvimento de ML ressípare e repetível.

Este artigo mostra como fazer as seguintes tarefas:

  • Monitorize o desempenho da execução.
  • Crie uma vista personalizada.
  • Adicione o nome do visor de execução.
  • Adicione uma descrição de execução.
  • Marque e encontre corridas.
  • Procure o seu histórico de execução.
  • Cancelar ou falhar corre.
  • Criar corridas de crianças.
  • Monitorize o estado de execução por notificação de e-mail.

Dica

Se procura informações sobre a monitorização do serviço de Aprendizagem automática Azure e dos serviços associados da Azure, consulte Como monitorizar a Azure Machine Learning. Se estiver à procura de informações sobre modelos de monitorização implementados como serviços web ou módulos IoT Edge, consulte recolher dados do modelo e monitorar com insights de aplicações.

Pré-requisitos

Vai precisar dos seguintes itens:

Monitor de execução

  • Inicie uma corrida e o seu processo de registo

    1. Desconfie da sua experiência importando as classes Workspace, Experiment, Rune ScriptRunConfig a partir 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 corrida e o seu processo de registo com o start_logging() método.

      notebook_run = exp.start_logging()
      notebook_run.log(name="message", value="Hello from run!")
      
  • Monitorizar o estado de uma corrida

    • Obtenha o estado de uma corrida com o get_status() método.

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

      print(notebook_run.get_details())
      
    • Quando a sua execução terminar com sucesso, utilize o complete() método para o marcar como concluído.

      notebook_run.complete()
      print(notebook_run.get_status())
      
    • Se utilizar o padrão de design da with...as Python, a execução marcar-se-á automaticamente como concluída quando a execução estiver fora de alcance. Não é preciso marcar manualmente a execução como concluído.

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

Vista personalizada

Para ver as suas corridas no estúdio:

  1. Navegue para o separador Experimentos.

  2. Selecione todas as experiências para visualizar todas as corridas numa experiência ou selecione Todas as corre para ver todas as correções submetidas no Espaço de Trabalho.

Na página 'All runs', pode filtrar a lista de execuções por tags, experiências, metas de computação e muito mais para organizar e estender melhor o seu trabalho.

  1. Faça personalizações na página selecionando runs para comparar, adicionar gráficos ou aplicar filtros. Estas alterações podem ser guardadas como uma Vista Personalizada para que possa facilmente voltar ao seu trabalho. Os utilizadores com permissões de espaço de trabalho podem editar ou ver a vista personalizada. Além disso, partilhe a visão personalizada com os membros da equipa para uma colaboração reforçada selecionando a vista Share.

  2. Para visualizar os registos de execução, selecione uma execução específica e no separador Saídas + registos, pode encontrar registos de diagnóstico e erro para a sua execução.

Screenshot: criar uma vista personalizada

Executar nome de exibição

Um nome de exibição de run é uma propriedade opcional, não única, fácil de usar que pode ser adicionada a uma corrida para ajudar a anotar corridas e fornecer informações mais significativas para a execução.

Para editar o nome do visor de execução, navegue na página 'Detalhes de execução' e selecione o ícone Editar ao lado da execução. Por predefinição, o nome do visor de execução está definido para o ID de execução. O ID de execução é o identificador único para a execução e pode ser adicionado como uma coluna na vista da lista de execuções.

Screenshot: adicione um nome de exibição

A imagem a seguir mostra o nome de exibição de execução editado.

Screenshot: nome do ecrã na lista de execuções

Executar descrição

Uma descrição de execução pode ser adicionada a uma corrida para fornecer mais contexto e informações para a execução. Também pode pesquisar nestas descrições a partir da lista de execuções e adicionar a descrição da execução como uma coluna na lista de execuções.

Navegue na página 'Detalhes de execução' para a sua execução e selecione o ícone de edição ou lápis para adicionar, editar ou apagar descrições para a sua execução. Para persistir nas alterações à lista de execuções, guarde as alterações na sua Visualização Personalizada existente ou numa nova Vista Personalizada. O formato markdown é suportado para descrições de execução, que permite que as imagens sejam incorporadas e ligações profundas como mostrado abaixo.

Screenshot: criar uma descrição de execução

Etiquetar e encontrar corridas

No Azure Machine Learning, pode utilizar propriedades e tags para ajudar a organizar e consultar as suas corridas para obter informações importantes.

  • Adicionar propriedades e etiquetas

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

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

    As propriedades são imutáveis, por isso criam um registo permanente para fins de auditoria. O exemplo de código a seguir resulta num erro, pois já adicionámos "azureml-user" como "author" valor patrimonial no código anterior:

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

    Ao contrário das propriedades, as etiquetas são mutáveis. Para adicionar informações pes pes que pesjáveis e significativas para os consumidores da sua experiência, utilize 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())
    

    Também pode adicionar etiquetas de corda simples. Quando estas etiquetas aparecem no dicionário de etiquetas como teclas, têm um valor de None .

    local_run.tag("worth another look")
    print(local_run.get_tags())
    
  • Propriedades e tags de consulta

    Você pode consultar corre dentro de uma experiência para devolver uma lista de runs que correspondem a propriedades e etiquetas específicas.

    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 corre

Se notar um erro ou se a sua corrida estiver a demorar muito tempo a terminar, pode cancelar a corrida.

Para cancelar uma execução utilizando o SDK, utilize 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 terminar, mas contiver um erro (por exemplo, o script de treino incorreto foi utilizado), pode utilizar o fail() método para o marcar como falhado.

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

Criar corridas de crianças

Criar corridas infantis para agrupar corridas relacionadas, tais como para diferentes iterações de afinação de hiperparímetros.

Nota

As corridas para crianças só podem ser criadas utilizando o SDK.

Este exemplo de código utiliza o hello_with_children.py script para criar um lote de cinco crianças executadas a partir de uma execução submetida utilizando 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)

Nota

À medida que se afastam do alcance, as corridas para crianças são automaticamente marcadas como concluídas.

Para criar muitas crianças funciona de forma eficiente, use o create_children() método. Como cada criação resulta numa chamada de rede, criar um lote de runs é mais eficiente do que criá-las uma a uma.

Submeter corridas de crianças

As corridas para crianças também podem ser submetidas a partir de uma corrida de pais. Isto permite-lhe criar hierarquias de pais e filhos. Não se pode criar uma criança sem pais: mesmo que a corrida dos pais não faça nada a não ser lançar corridas de crianças, ainda é necessário criar a hierarquia. Os estatutos de todas as corridas são independentes: um progenitor pode estar no "Completed" estado de sucesso, mesmo que uma ou mais crianças sejam canceladas ou falhadas.

Pode desejar que o seu filho corra para utilizar uma configuração de execução diferente da execução dos pais. Por exemplo, pode utilizar uma configuração menos potente e baseada em CPU para o progenitor, enquanto utiliza configurações baseadas em GPU para os seus filhos. Outro desejo comum é passar a cada criança diferentes argumentos e dados. Para personalizar uma corrida de crianças, crie um ScriptRunConfig objeto para a corrida da criança.

Importante

Para submeter uma criança a partir de uma corrida de pais num cálculo remoto, você deve iniciar sôm no espaço de trabalho no código de execução dos pais primeiro. Por predefinição, o objeto de contexto de execução num percurso remoto não tem credenciais para submeter execuções de crianças. Utilize um principal serviço ou credenciais de identidade geridas para iniciar sinsus. Para obter mais informações sobre a autenticação, consulte configurar a autenticação.

O código abaixo:

  • Recupera um recurso computacional nomeado "gpu-cluster" do espaço de trabalho ws
  • Iterates sobre diferentes valores de argumento a serem passados para os objetos das ScriptRunConfig crianças
  • Cria e submete uma nova corrida infantil, usando o recurso e argumento de computação personalizado
  • Bloqueia até que toda a criança fique completa
# 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 muitas corridas de crianças com configurações, argumentos e entradas idênticas de forma eficiente, utilize o create_children() método. Como cada criação resulta numa chamada de rede, criar um lote de runs é mais eficiente do que criá-las uma a uma.

Dentro de uma corrida de crianças, você pode ver o iD do pai executar:

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

A consulta da criança corre

Para consultar a criança de um progenitor específico, utilize o get_children() método. O recursive = True argumento permite-lhe consultar uma árvore aninhada de filhos e netos.

print(parent_run.get_children())

Faça login para pai ou raiz

Pode utilizar o Run.parent campo para aceder à corrida que lançou a atual corrida infantil. Uma caixa de utilização comum para a utilização Run.parent é combinar os resultados do registo num único local. As corridas infantis executam assíncronia e não há garantia de encomendar ou sincronizar para além da capacidade do progenitor de esperar que o seu filho esteja completo.

# 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}")

Monitorize o estado de execução por notificação de e-mail

  1. No portal Azure,na barra de navegação esquerda, selecione o separador Monitor.

  2. Selecione definições de diagnóstico e, em seguida, selecione + Adicione a definição de diagnóstico.

    Screenshot das definições de diagnóstico para notificação de e-mail

  3. Na Definição de Diagnóstico,

    1. nos detalhes da categoria , selecione o AmlRunStatusChangedEvent.
    2. Nos detalhes do Destino , selecione o espaço de trabalho Enviar para Registar Analytics e especificar o espaço de trabalho subscrição e log analytics.

    Nota

    O Espaço de Trabalho Azure Log Analytics é um tipo diferente de Recurso Azure do que o espaço de trabalho do serviço de aprendizagem automática Azure. Se não houver opções nessa lista, pode criar um espaço de trabalho log analytics.

    Onde guardar a notificação de e-mail

  4. No separador 'Registos', adicione uma nova regra de alerta.

    Nova regra de alerta

  5. Veja como criar e gerir alertas de registo utilizando o Azure Monitor.

Blocos de notas de exemplo

Os seguintes cadernos demonstram os conceitos deste artigo:

Passos seguintes