Inicio, supervisión y seguimiento del historial de ejecución

El SDK de Azure Machine Learning para Python, la CLI de Machine Learning y Estudio de Azure Machine Learning proporcionan varios métodos para supervisar, organizar y seguir las ejecuciones de entrenamiento y experimentación. El historial de ejecución de ML es una parte importante de un proceso de desarrollo de ML que se pueda explicar y repetir.

En este artículo se muestra cómo realizar las tareas siguientes:

• Supervisión del rendimiento de la ejecución.
• Agregue el nombre para mostrar de la ejecución.
• Creación de una vista personalizada.
• Incorporación de la descripción de una ejecución.
• Etiquetado y búsqueda de ejecuciones.
• Ejecución de búsquedas en el historial de ejecución.
• Cancelación o ejecuciones erróneas.
• Creación de ejecuciones secundarias.
• Supervisión del estado de la ejecución mediante notificaciones por correo electrónico.

Prerrequisitos

Necesitará los siguientes elementos:

• Suscripción a Azure. Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar. Pruebe hoy mismo la versión gratuita o de pago de Azure Machine Learning.

• Un área de trabajo de Azure Machine Learning.

• El SDK de Azure Machine Learning para Python (versión 1.0.21 o posterior). Para instalar o actualizar a la versión más reciente del SDK, consulte Instalación o actualización del SDK.

  Para comprobar su versión del SDK de Azure Machine Learning, use el siguiente código:

  print(azureml.core.VERSION)
  

• La CLI de Azure y la extensión de la CLI para Azure Machine Learning.

Supervisión del rendimiento de la ejecución

• Inicio de una ejecución y su proceso de registro

  • Python
  • CLI de Azure
  • Estudio

  1. Para configurar el experimento, importe las clases Workspace, Experiment, Run y ScriptRunConfig del paquete 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 una ejecución y su proceso de registro con el método start_logging().

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

• Supervisión del estado de una ejecución

  • Python
  • CLI de Azure
  • Estudio

  • Obtenga el estado de una ejecución con el método get_status().

    print(notebook_run.get_status())
    

  • Para obtener el identificador de ejecución, la hora de ejecución y otros detalles sobre esta, use el método get_details().

    print(notebook_run.get_details())
    

  • Cuando la ejecución finalice correctamente, use el método complete() para marcarla como completada.

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

  • Si usa el modelo de diseño with...as de Python, la ejecución se marcará automáticamente como completada cuando esta quede fuera del ámbito. No tiene que marcar la ejecución como completada de forma manual.

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

Nombre para mostrar de la ejecución

El nombre para mostrar de la ejecución es un nombre opcional y personalizable que puede proporcionar para la ejecución. Para editar el nombre para mostrar de la ejecución:

1. Vaya a la lista de ejecuciones.

2. Seleccione la ejecución para editar el nombre para mostrar en la página de detalles de la ejecución.

3. Seleccione el botón Editar para el nombre para mostrar de la ejecución.

Vista personalizada

Para ver las ejecuciones en el estudio:

1. Vaya a la sección Experimentos.

2. Seleccione Todos los experimentos para ver todas las ejecuciones de un experimento o seleccione Todas las ejecuciones para ver todas las ejecuciones enviadas en el área de trabajo.

En la página Todas las ejecuciones, puede filtrar la lista de ejecuciones por etiquetas, experimentos y destino de proceso, entre otros criterios, para organizar mejor el ámbito del trabajo.

1. Para hacer personalizaciones en la página, seleccione ejecuciones para comparar, agregue gráficos o aplique filtros. Estos cambios se pueden guardar como una vista personalizada para que pueda volver fácilmente a su trabajo. Los usuarios con permisos en el área de trabajo pueden editar o ver la vista personalizada. Además, comparta la vista personalizada con los miembros del equipo para mejorar la colaboración seleccionando Compartir vista.

2. Para ver los registros de ejecución, seleccione una ejecución específica y, en la pestaña Resultados y registros, puede encontrar registros de diagnóstico y errores para la ejecución.

Descripción de la ejecución

Se puede agregar una descripción a una ejecución para proporcionar más contexto e información a la ejecución. También puede buscar en estas descripciones desde la lista de ejecuciones y agregar la descripción de la ejecución como una columna en la lista de ejecuciones.

Vaya a la página Detalles de ejecución de la ejecución y seleccione el icono de edición o de lápiz para agregar, editar o eliminar descripciones de la ejecución. Para conservar los cambios en la lista de ejecuciones, guarde los cambios en la vista personalizada existente o en una nueva vista personalizada. Se admite el formato Markdown para las descripciones de ejecución, lo que permite la inserción de imágenes y la vinculación en profundidad, como se muestra a continuación.

Etiquetado y búsqueda de ejecuciones

En Azure Machine Learning, puede usar etiquetas y propiedades para ayudar a organizar y consultar las ejecuciones a fin de obtener información importante.

• Adición de etiquetas y propiedades

  • Python
  • CLI de Azure
  • Estudio

  Para agregar metadatos de búsqueda a las ejecuciones, use el método add_properties(). Por ejemplo, el código siguiente agrega la propiedad "author" a la ejecución:

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

  Las propiedades son inmutables, por lo que crean un registro permanente con fines de auditoría. El siguiente ejemplo de código da como resultado un error porque ya hemos agregado "azureml-user" como el valor de propiedad "author" en el código anterior:

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

  A diferencia de las propiedades, las etiquetas son mutables. Para agregar información que permite realizar búsquedas y que es significativa para los consumidores del experimento, use el método tag().

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

  También puede agregar etiquetas de cadena simples. Cuando estas etiquetas aparecen en el diccionario de etiquetas como claves, tienen un valor de None.

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

• Consulta de etiquetas y propiedades

  Puede consultar las ejecuciones de un experimento para devolver una lista de ejecuciones que coinciden con etiquetas y propiedades específicas.

  • Python
  • CLI de Azure
  • Estudio

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

Cancelación o ejecuciones erróneas

Si detecta un error o si la ejecución tarda demasiado en finalizar, puede cancelarla.

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

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

az ml run cancel -r runid -w workspace_name -e experiment_name

Creación de ejecuciones secundarias

Cree ejecuciones secundarias para agrupar ejecuciones relacionadas (por ejemplo, para diferentes iteraciones de ajuste de hiperparámetros).

En este ejemplo de código se usa el script hello_with_children.py para crear un lote de cinco ejecuciones secundarias desde una ejecución enviada mediante el método child_run():

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

Para crear muchas ejecuciones secundarias de forma eficaz, use el método create_children(). Dado que cada creación da lugar a una llamada de red, la creación de un lote de ejecuciones es más eficaz que hacerlo una a una.

Envío de ejecuciones secundarias

Las ejecuciones secundarias también se pueden enviar desde una ejecución principal. Esto le permite crear jerarquías de ejecuciones primarias y secundarias. No se puede crear una ejecución secundaria sin primaria: aunque la ejecución primaria no haga más que iniciar ejecuciones secundarias, sigue siendo necesaria para crear la jerarquía. Los estados de todas las ejecuciones son independientes: una ejecución primaria puede tener el estado "Completed" correcto aunque una o varias ejecuciones secundarias se hayan cancelado o hayan dado error.

Es posible que desee que las ejecuciones secundarias utilicen una configuración de ejecución diferente de la ejecución primaria. Por ejemplo, puede utilizar una configuración menos potente basada en CPU para el elemento primario, mientras usa configuraciones basadas en GPU para los elementos secundarios. Otro deseo habitual es pasar a cada ejecución secundaria argumentos y datos distintos. Para personalizar una ejecución secundaria, cree un objeto de ScriptRunConfig para la ejecución secundaria.

El código siguiente:

• Recupera un recurso de proceso denominado "gpu-cluster" del área de trabajo ws
• Recorre en iteración los diferentes valores de los argumentos que se van a pasar a los objetos ScriptRunConfig secundarios
• Crea y envía una nueva ejecución secundaria mediante el recurso de proceso personalizado y el argumento
• Se bloquea hasta que se completan todas las ejecuciones secundarias

# 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 crear muchas ejecuciones secundarias con configuraciones, argumentos y entradas idénticas de forma eficaz, use el método create_children(). Dado que cada creación da lugar a una llamada de red, la creación de un lote de ejecuciones es más eficaz que hacerlo una a una.

Desde la ejecución secundaria, puede ver el identificador de la ejecución principal:

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

Consulta de ejecuciones secundarias

Para consultar las ejecuciones secundarias de un elemento primario específico, use el método get_children(). El argumento recursive = True permite consultar un árbol anidado de elementos secundarios y descendientes.

print(parent_run.get_children())

Registro en la ejecución primaria o raíz

Puede usar el campo Run.parent para acceder a la ejecución que inició la ejecución secundaria actual. Un caso de uso habitual de Run.parent es combinar resultados de registro en una única ubicación. Las ejecuciones secundarias se ejecutan de forma asincrónica y no hay ninguna garantía de ordenación o sincronización más allá de la capacidad del elemento primario de esperar a que se completen sus ejecuciones secundarias.

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

Supervisión del estado de la ejecución mediante notificaciones por correo electrónico

1. En la barra de navegación de la izquierda de Azure Portal, seleccione la pestaña Supervisar.

2. Seleccione Configuración de diagnóstico y, luego, seleccione + Agregar configuración de diagnóstico.

   

3. En la Configuración de diagnóstico,

   1. en Detalles de categoría, seleccione AmlRunStatusChangedEvent.
   2. En Detalles de categoría, seleccione Enviar a área de trabajo de Log Analytics y especifique la suscripción y el área de trabajo de Log Analytics.

   Nota

   El área de trabajo de Azure Log Analytics es un tipo de recurso de Azure distinto del área de trabajo de Azure Machine Learning Service. Si no hay opciones en esa lista, puede crear un área de trabajo de Log Analytics.

   

4. En la pestaña Registros, agregue una Nueva regla de alertas.

   

5. Consulte cómo crear y administrar las alertas de registro mediante Azure Monitor.

Cuadernos de ejemplo

Los siguientes cuadernos muestran los conceptos de este artículo:

• Para obtener más información sobre las API de registro, vea el cuaderno de API de registro.

• Para obtener más información sobre cómo administrar ejecuciones con el SDK de Azure Machine Learning, consulte el cuaderno de administración de ejecuciones.

Pasos siguientes

• Para obtener información sobre cómo registrar las métricas de sus experimentos, consulte Registrar métricas durante las ejecuciones de entrenamiento.
• Para aprender a supervisar los recursos y los registros desde Azure Machine Learning, consulte Supervisión de Azure Machine Learning.