Registro y visualización de métricas y archivos de registro v1

Artículo
05/23/2023

SE APLICA A:Azure ML del SDK de Python v1

Registre información en tiempo real mediante el paquete de registro de Python predeterminado y la funcionalidad específica del SDK de Python de Azure Machine Learning. Puede anotar registros de forma local y enviarlos al área de trabajo en el portal.

Los registros pueden ayudarle a diagnosticar errores y advertencias, o a realizar un seguimiento de las métricas de rendimiento, como los parámetros y el rendimiento del modelo. En este artículo, aprenderá a habilitar el registro en los siguientes escenarios:

Métricas de ejecución de registros
Sesiones de aprendizaje interactivo
Envío de trabajos de entrenamiento mediante ScriptRunConfig
Configuración nativa de logging de Python
Registro desde otros orígenes

Sugerencia

En este artículo se muestra cómo supervisar el proceso de entrenamiento del modelo. Si está interesado en la supervisión del uso de los recursos y eventos desde Azure Machine Learning, como las cuotas o las ejecuciones de entrenamiento o implementaciones de modelos completadas, puede consultar Supervisión de Azure Machine Learning.

Tipos de datos

Puede registrar varios tipos de datos, como valores escalares, listas, tablas, imágenes, directorios, etc. Para más información y ver ejemplos de código de Python para diferentes tipos de datos, consulte la página de referencia de la clase Run.

Registro de métricas de ejecución

Use los métodos siguientes en las API de registro para influir en las visualizaciones de las métricas. Tenga en cuenta los límites de servicio para estas métricas registradas.

Valor registrado	Ejemplo de código	Formato en el portal
Registrar una matriz de valores numéricos	`run.log_list(name='Fibonacci', value=[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89])`	Gráfico de líneas de una sola variable
Registrar un único valor numérico con el mismo nombre de métrica usado repetidamente (como desde dentro de un bucle)	`for i in tqdm(range(-10, 10)): run.log(name='Sigmoid', value=1 / (1 + np.exp(-i))) angle = i / 2.0`	Gráfico de líneas de una sola variable
Registrar una fila con dos columnas numéricas repetidamente	`run.log_row(name='Cosine Wave', angle=angle, cos=np.cos(angle)) sines['angle'].append(angle) sines['sine'].append(np.sin(angle))`	Gráfico de líneas de dos variables
Registrar tabla con dos columnas numéricas	`run.log_table(name='Sine Wave', value=sines)`	Gráfico de líneas de dos variables
Registro de imagen	`run.log_image(name='food', path='./breadpudding.jpg', plot=None, description='desert')`	Use este método para registrar un archivo de imagen o un trazado de matplotlib en la ejecución. Estas imágenes serán visibles y comparables en el registro de ejecución.

Registro con MLflow

Se recomienda registrar los modelos, las métricas y los artefactos con MLflow, ya que es de código abierto y admite el modo local para la portabilidad en la nube. La tabla siguiente y los ejemplos de código muestran cómo usar MLflow para registrar métricas y artefactos de las ejecuciones de entrenamiento. Más información sobre los métodos de registro y los patrones de diseño de MLflow.

Asegúrese de instalar los paquetes pip mlflow y azureml-mlflow en el área de trabajo.

pip install mlflow
pip install azureml-mlflow

Establezca el identificador URI de seguimiento de MLflow para que apunte al back-end de Azure Machine Learning para asegurarse de que las métricas y los artefactos se registren en el área de trabajo.

from azureml.core import Workspace
import mlflow
from mlflow.tracking import MlflowClient

ws = Workspace.from_config()
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

mlflow.create_experiment("mlflow-experiment")
mlflow.set_experiment("mlflow-experiment")
mlflow_run = mlflow.start_run()

Valor registrado	Ejemplo de código	Notas
Registrar un valor numérico (int o float)	`mlflow.log_metric('my_metric', 1)`
Registrar un valor booleano	`mlflow.log_metric('my_metric', 0)`	0 = True, 1 = False
Registrar una cadena	`mlflow.log_text('foo', 'my_string')`	Registrado como un artefacto
Registrar métricas de numpy u objetos de imagen de PIL	`mlflow.log_image(img, 'figure.png')`
Registrar trazado de matlotlib o archivo de imagen	`mlflow.log_figure(fig, "figure.png")`

Visualización de métricas de ejecución mediante el SDK

Puede ver las métricas de un modelo entrenado con run.get_metrics().

from azureml.core import Run
run = Run.get_context()
run.log('metric-name', metric_value)

metrics = run.get_metrics()
# metrics is of type Dict[str, List[float]] mapping metric names
# to a list of the values for that metric in the given run.

metrics.get('metric-name')
# list of metrics in the order they were recorded

También puede acceder a la información de ejecución con MLflow mediante las propiedades de información y datos del objeto de ejecución. Consulte la documentación del objeto MLflow.entities.Run para más información.

Una vez completada la ejecución, puede recuperarlo mediante MlFlowClient().

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
finished_mlflow_run = MlflowClient().get_run(mlflow_run.info.run_id)

Puede ver las métricas, los parámetros y las etiquetas de la ejecución en el campo de datos del objeto de ejecución.

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

Nota

El diccionario de métricas de mlflow.entities.Run.data.metrics solo devuelve el valor registrado más recientemente para un nombre de métrica determinado. Por ejemplo, si registra por orden 1, 2, 3 y 4 en una métrica llamada sample_metric, solo hay un 4 en el diccionario de métricas para sample_metric.

Para obtener todas las métricas registradas para un nombre de métrica determinado, puede usarMlFlowClient.get_metric_history().

Visualización de las métricas de ejecución en la interfaz de usuario del Estudio

Puede examinar los registros de ejecución completados, incluidas las métricas registradas, en Azure Machine Learning Studio.

Vaya a la sección Experimentos. Para ver todas las ejecuciones en el área de trabajo de todos los experimentos, seleccione la pestaña Todas las ejecuciones. Puede explorar en profundidad las ejecuciones de Experimentos concretos si aplica el filtro de experimentos en la barra de menús de la parte superior.

Para obtener la vista de experimentos individuales, seleccione la pestaña Todos los experimentos. En el panel de ejecución del experimento, puede ver las métricas y los registros del seguimiento de cada ejecución.

También puede editar la tabla de la lista de ejecución para seleccionar varias ejecuciones y mostrar el último valor registrado, el mínimo o el máximo para las ejecuciones. Personalice los gráficos para comparar los valores de las métricas registradas y los agregados en varias ejecuciones. Puede trazar varias métricas sobre el eje Y del gráfico y personalizar el eje X para trazar las métricas registradas.

Visualización y descarga de los archivos de registro de una ejecución

Los archivos de registro son un recurso esencial para depurar las cargas de trabajo de Azure Machine Learning. Después de enviar un trabajo de entrenamiento, explore en profundidad hasta una ejecución específica para ver sus registros y salidas:

Vaya a la sección Experimentos.
Seleccione el identificador de la ejecución para ver una ejecución específica.
Seleccione Resultados y registros en la parte superior de la página.
Seleccione Descargar todo para descargar todos los registros en una carpeta comprimida.
También puede descargar archivos de registro individuales eligiendo el archivo de registro y seleccionando Descargar.

Captura de pantalla de la sección de resultados y registros de una ejecución.

Carpeta user_logs

Esta carpeta contiene información sobre los registros generados por el usuario. Esta carpeta está abierta de forma predeterminada y el registro std_log.txt está seleccionado. El archivo std_log.txt es donde se muestran los registros del código (por ejemplo, instrucciones print). Este archivo contiene el registro stdout y los registros stderr del script de control y el script de entrenamiento, uno por proceso. En la mayoría de los casos, supervisará los registros aquí.

Carpeta system_logs

Esta carpeta contiene los registros que se generan en Azure Machine Learning y está cerrada de manera predeterminada. Los registros generados por el sistema se agrupan en diferentes carpetas, según el estado del trabajo del runtime.

Otras carpetas

Para el entrenamiento de trabajos en clústeres con varios procesos, los registros están presentes para cada IP de nodo. La estructura de cada nodo es igual que la de los trabajos de un solo nodo. Hay una carpeta de registros adicional para los registros de ejecución general, stderr y stdout.

Azure Machine Learning registra información de varios orígenes durante el entrenamiento, como AutoML o el contenedor de Docker que ejecuta el trabajo de entrenamiento. Muchos de estos registros no están documentados. Si encuentra problemas y se pone en contacto con el Soporte técnico de Microsoft, es posible que puedan usar estos registros durante la resolución de problemas.

Sesión de registro interactivo

Las sesiones de registro interactivo se utilizan normalmente en entornos de cuaderno. El método Experiment.start_logging() comienza con una sesión de registro interactivo. Todas las métricas que se registran durante la sesión se agregan al registro de ejecución del experimento. El método run.complete() finaliza las sesiones y marca la ejecución como completada.

Registros de ScriptRun

En esta sección, aprenderá a agregar código de registro dentro de las ejecuciones creadas cuando se configuraron con ScriptRunConfig. Puede usar la clase ScriptRunConfig para encapsular los scripts y entornos y permitir así ejecuciones repetibles. También puede usar esta opción para mostrar un widget visual de instancias de Jupyter Notebook para la supervisión.

En este ejemplo se realiza un barrido de parámetros sobre valores alfa y se capturan los resultados mediante el método run.log().

Cree un script de entrenamiento que incluya la lógica de registro train.py.

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

from sklearn.datasets import load_diabetes
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from azureml.core.run import Run
import os
import numpy as np
import mylib
# sklearn.externals.joblib is removed in 0.23
try:
    from sklearn.externals import joblib
except ImportError:
    import joblib

os.makedirs('./outputs', exist_ok=True)

X, y = load_diabetes(return_X_y=True)

run = Run.get_context()

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.2,
                                                    random_state=0)
data = {"train": {"X": X_train, "y": y_train},
        "test": {"X": X_test, "y": y_test}}

# list of numbers from 0.0 to 1.0 with a 0.05 interval
alphas = mylib.get_alphas()

for alpha in alphas:
    # Use Ridge algorithm to create a regression model
    reg = Ridge(alpha=alpha)
    reg.fit(data["train"]["X"], data["train"]["y"])

    preds = reg.predict(data["test"]["X"])
    mse = mean_squared_error(preds, data["test"]["y"])
    run.log('alpha', alpha)
    run.log('mse', mse)

    model_file_name = 'ridge_{0:.2f}.pkl'.format(alpha)
    # save model in the outputs folder so it automatically get uploaded
    with open(model_file_name, "wb") as file:
        joblib.dump(value=reg, filename=os.path.join('./outputs/',
                                                     model_file_name))

    print('alpha is {0:.2f}, and mse is {1:0.2f}'.format(alpha, mse))

Envíe el script train.py para ejecutarlo en un entorno administrado por el usuario. La carpeta de scripts completa se envía para el entrenamiento.
```
from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='./scripts', script='train.py', environment=user_managed_env)
```
```
run = exp.submit(src)
```
El parámetro show_output activa el registro detallado, que le permite ver los detalles del proceso de entrenamiento, así como información sobre los recursos remotos o los destinos de proceso. Use el código siguiente para activar el registro detallado al enviar el experimento.
```
run = exp.submit(src, show_output=True)
```
También puede usar el mismo parámetro en la función wait_for_completion de la ejecución resultante.
```
run.wait_for_completion(show_output=True)
```

Registro nativo de Python

Algunos registros del SDK pueden contener un error que le insta a establecer el nivel de registro en DEBUG. Para establecer el nivel de registro, agregue el código siguiente al script.

import logging
logging.basicConfig(level=logging.DEBUG)

Otros orígenes de registro

Azure Machine Learning también puede registrar información de otros orígenes durante el entrenamiento, como las ejecuciones de aprendizaje automático automatizado o los contenedores de Docker que ejecutan los trabajos. Estos registros no se documentan, pero si encuentra problemas y se pone en contacto con el soporte técnico de Microsoft, es posible que puedan usar estos registros como ayuda para resolverlos.

Para información sobre el registro de métricas en el diseñador de Azure Machine Learning, consulte Registro de las métricas en el diseñador.

Cuadernos de ejemplo

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

Siga las instrucciones del artículo Exploración de Azure Machine Learning con cuadernos de Jupyter para aprender a ejecutar cuadernos.

Pasos siguientes

Consulte estos artículos para aprender a usar Machine Learning:

Vea un ejemplo de cómo registrar el mejor modelo e implementarlo en el tutorial, Entrenar un modelo de clasificación de imágenes con Azure Machine Learning.