Lista de reglas integradas del depurador

Puede usar las reglas integradas del Debugger, proporcionadas por Amazon SageMaker Debugger, para analizar las métricas y los tensores recopilados durante el entrenamiento de sus modelos. A continuación, se enumeran las reglas del depurador e incluye información y un ejemplo sobre cómo configurar e implementar cada regla integrada.

Las reglas integradas del depurador monitorizan diversas condiciones comunes que son fundamentales para el éxito de un trabajo de entrenamiento. Puede invocar las reglas integradas mediante Amazon SageMaker Python SDK o las SageMaker API operaciones de bajo nivel.

El uso de reglas integradas no conlleva ningún coste adicional. Para obtener más información sobre la facturación, consulta la página de SageMaker precios de Amazon.

import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)

Regla del depurador

Las siguientes reglas son las reglas integradas del depurador que pueden llamarse mediante el classmethod Rule.sagemaker.

Depurador: reglas integradas para generar informes de entrenamiento

Reglas integradas en el depurador para depurar los datos de entrenamiento del modelo (tensores de salida)

Para usar las reglas integradas con los valores de los parámetros predeterminados, utilice el siguiente formato de configuración:

from sagemaker.debugger import Rule, ProfilerRule, rule_configs

rules = [
    Rule.sagemaker(rule_configs.built_in_rule_name_1()),
    Rule.sagemaker(rule_configs.built_in_rule_name_2()),
    ...
    Rule.sagemaker(rule_configs.built_in_rule_name_n())
]

Para usar las reglas integradas con la personalización de los valores de los parámetros, utilice el siguiente formato de configuración:

from sagemaker.debugger import Rule, ProfilerRule, rule_configs

rules = [
    Rule.sagemaker(
        base_config=rule_configs.built_in_rule_name(),
        rule_parameters={
                "key": "value"
        }
        collections_to_save=[ 
            CollectionConfig(
                name="tensor_collection_name", 
                parameters={
                    "key": "value"
                } 
            )
        ]
    )
]

Para encontrar las claves disponibles del parámetro rule_parameters, consulte las tablas de descripción de los parámetros.

Se proporcionan ejemplos de códigos de configuración de reglas para cada regla integrada a continuación de las tablas de descripción de parámetros.

CreateXgboostReport

La CreateXgboostReport regla recopila los tensores de salida de un trabajo de XGBoost entrenamiento y genera automáticamente un informe de entrenamiento completo. Puede descargar un informe completo de creación de perfiles mientras se esté realizando un trabajo de entrenamiento o una vez finalizado el trabajo de entrenamiento, y comprobar el progreso del entrenamiento o el resultado final de la misma. La CreateXgboostReport regla recopila los siguientes tensores de salida de forma predeterminada:

Descripciones de los parámetros de la regla CreateXgboostReport

rules=[
    Rule.sagemaker(
        rule_configs.create_xgboost_report()
    )  
]

DeadRelu

Esta regla detecta cuando el porcentaje de funciones de activación de unidad lineal rectificada (ReLU) en una prueba se considera muerto porque su actividad de activación ha caído por debajo de un determinado umbral. Si el porcentaje de R inactivo eLUs en una capa es mayor que el threshold_layer valor de R inactivoeLUs, la regla vuelveTrue.

Descripciones de los parámetros de la DeadRelu regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.dead_relu(),
        rule_parameters={
                "tensor_regex": ".*relu_output|.*ReLU_output",
                "threshold_inactivity": "1.0",
                "threshold_layer": "50.0"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_relu_collection", 
                parameters={
                    "include_regex: ".*relu_output|.*ReLU_output",
                    "save_interval": "500"
                } 
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

ExplodingTensor

Esta regla detecta si los tensores emitidos durante el entrenamiento tienen valores no finitos, infinitos o NaN (no un número). Si se detecta un valor no finito, la regla devuelve True.

Descripciones de los parámetros de la regla ExplodingTensor

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.exploding_tensor(),
        rule_parameters={
                "tensor_regex": ".*gradient",
                "only_nan": "False"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="gradients", 
                parameters={
                    "save_interval": "500"
                }
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

PoorWeightInitialization

Esta regla detecta si los parámetros del modelo se han inicializado mal.

Una buena inicialización rompe la simetría de los pesos y gradientes en una red neuronal y mantiene variaciones de activación proporcionales a través de las capas. De lo contrario, la red neuronal no aprende eficazmente. Inicializadores como Xavier pretenden mantener la varianza constante a través de las activaciones, lo cual es especialmente relevante para entrenar redes neuronales muy profundas. Una inicialización demasiado pequeña puede dar lugar a la desaparición de gradientes. Una inicialización demasiado grande puede dar lugar a la explosión de gradientes. Esta regla comprueba la variación de las entradas de activación a través de las capas, la distribución de gradientes y la convergencia de pérdidas para los pasos iniciales para determinar si una red neuronal se ha inicializado mal.

Descripciones de los parámetros de la regla PoorWeightInitialization

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.poor_weight_initialization(),
        rule_parameters={
                "activation_inputs_regex": ".*relu_input|.*ReLU_input",
                "threshold": "10.0",
                "distribution_range": "0.001",
                "patience": "5",
                "steps": "10"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_relu_collection", 
                parameters={
                    "include_regex": ".*relu_input|.*ReLU_input",
                    "save_interval": "500"
                } 
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

SaturatedActivation

Esta regla detecta si las capas de activación tanh y sigmoide se están saturando. Una capa de activación se satura cuando la entrada de la capa está cerca del máximo o mínimo de la función de activación. El mínimo y máximo de las funciones de activación tanh y sigmoide se definen por sus respectivos valores min_threshold y max_thresholds. Si la actividad de un nodo cae por debajo del porcentaje threshold_inactivity, se considera saturado. Si más de un porcentaje threshold_layer de los nodos están saturados, la regla devuelve True.

Descripciones de los parámetros de la regla SaturatedActivation

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.saturated_activation(),
        rule_parameters={
                "tensor_regex": ".*tanh_input|.*sigmoid_input",
                "threshold_tanh_min": "-9.4999",
                "threshold_tanh_max": "9.4999",
                "threshold_sigmoid_min": "-23",
                "threshold_sigmoid_max": "16.99999",
                "threshold_inactivity": "1.0",
                "threshold_layer": "50.0"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_activations_collection",
                parameters={
                    "include_regex": ".*tanh_input|.*sigmoid_input"
                    "save_interval": "500"
                } 
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

VanishingGradient

Esta regla detecta si los gradientes de una prueba se vuelven extremadamente pequeños o caen a una magnitud cero. Si la media de los valores absolutos de los gradientes cae por debajo de un threshold especificado, la regla devuelve True.

Descripciones de los parámetros de la regla VanishingGradient

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.vanishing_gradient(),
        rule_parameters={
                "threshold": "0.0000001"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="gradients", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

WeightUpdateRatio

Esta regla hace un seguimiento de la proporción de actualizaciones a ponderaciones durante el entrenamiento y detecta si esa proporción es demasiado grande o demasiado pequeña. Si la proporción de actualizaciones a ponderaciones es mayor que large_threshold value o si esta proporción es menor que small_threshold, la regla devuelve True.

Las condiciones para el entrenamiento son mejores cuando las actualizaciones son proporcionales a los gradientes. Las actualizaciones excesivamente grandes pueden alejar las ponderaciones de los valores óptimos y las actualizaciones muy pequeñas dan lugar a una convergencia muy lenta. Esta regla requiere que haya pesos disponibles para dos pasos de entrenamiento y train.save_interval debe establecerse en num_steps.

Descripciones de los parámetros de la regla WeightUpdateRatio

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.weight_update_ratio(),
        rule_parameters={
                "num_steps": "100",
                "large_threshold": "10.0",
                "small_threshold": "0.00000001",
                "epsilon": "0.000000001"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="weights", 
                parameters={
                    "train.save_interval": "100"
                } 
            )
        ]
    )
]

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

AllZero

Esta regla detecta si todos o un porcentaje especificado de los valores del tensor son cero.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo. Debe especificar el parámetro collection_names o tensor_regex. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la AllZero regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.all_zero(),
        rule_parameters={
                "tensor_regex": ".*",
                "threshold": "100"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="all", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

ClassImbalance

Esta regla mide los desequilibrios de muestreo entre clases y devuelve errores si el desequilibrio supera un umbral o si se producen demasiados errores para clases subrepresentadas como resultado del desequilibrio.

Los modelos de clasificación requieren clases bien equilibradas en el conjunto de datos de entrenamiento o una ponderación/muestreo adecuada de las clases durante el entrenamiento. La regla realiza las siguientes comprobaciones:

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la ClassImbalance regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.class_imbalance(),
        rule_parameters={
                "threshold_imbalance": "10",
                "threshold_misprediction": "0.7",
                "samples": "500",
                "argmax": "False",
                "labels_regex": ".*labels",
                "predictions_regex": ".*predictions"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_output_collection",
                parameters={
                    "include_regex": ".*labels|.*predictions",
                    "save_interval": "500"
                } 
            )
        ]
    )
]

LossNotDecreasing

Esta regla detecta cuando la pérdida no está disminuyendo de valor a un ritmo suficiente. Estas pérdidas deben ser escalares.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo. Debe especificar el parámetro collection_names o tensor_regex. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la LossNotDecreasing regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.loss_not_decreasing(),
        rule_parameters={
                "tensor_regex": ".*",
                "use_losses_collection": "True",
                "num_steps": "10",
                "diff_percent": "0.1",
                "increase_threshold_percent": "5",
                "mode": "GLOBAL"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

Overfit

Esta regla detecta si el modelo está sobreajustado a los datos de entrenamiento comparando la validación y las pérdidas de entrenamiento.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de parámetros para la regla Overfit

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.overfit(),
        rule_parameters={
                "tensor_regex": ".*",
                "start_step": "0",
                "patience": "1",
                "ratio_threshold": "0.1"
        },
        collections_to_save=[
            CollectionConfig(
                name="losses", 
                parameters={
                    "train.save_interval": "100",
                    "eval.save_interval": "10"
                } 
            )
        ]
    )
]

Overtraining

Esta regla detecta si un modelo se está sobreentrenando. Tras varias iteraciones de entrenamiento en un modelo que se comporta bien (disminuyen tanto las pérdidas de entrenamiento como las de validación), el modelo se acerca al mínimo de la función de pérdida y ya no mejora. Si el modelo sigue entrenándose, puede ocurrir que la pérdida de validación comience a aumentar, ya que el modelo empezará a sobreajustarse. Esta regla establece umbrales y condiciones para determinar si el modelo no mejora y evita problemas de sobreajuste debidos al sobreentrenamiento.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de parámetros para la regla Overtraining

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.overtraining(),
        rule_parameters={
                "patience_train": "5",
                "patience_validation": "10",
                "delta": "0.01"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

SimilarAcrossRuns

Esta regla compara los tensores recopilados de una prueba base con los tensores de otra prueba.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la SimilarAcrossRuns regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.similar_across_runs(),
        rule_parameters={
                "other_trials": "<specify-another-job-name>",
                "collection_names": "losses",
                "tensor_regex": ".*"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

StalledTrainingRule

StalledTrainingRule detecta si no se ha realizado ningún progreso en el trabajo de formación y detiene el trabajo de formación si se activa la regla. Esta regla requiere que los tensores se guarden periódicamente en un intervalo de tiempo definido por su parámetro threshold. Esta regla sigue monitoreando la presencia de nuevos tensores y, si no se ha emitido ningún tensor nuevo para el intervalo umbral, se activa la regla.

Descripciones de los parámetros de la StalledTrainingRule regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.stalled_training_rule(),
        rule_parameters={
                "threshold": "1800",
                "stop_training_on_fire": "True",
                "training_job_name_prefix": "<specify-training-base-job-name>"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

TensorVariance

Esta regla detecta si tiene tensores con variaciones muy altas o bajas. Variaciones muy altas o bajas en un tensor podrían dar lugar a la saturación neuronal, lo que reduce la capacidad de aprendizaje de la red neuronal. Una variación muy alta en los tensores también puede dar lugar finalmente a la explosión de tensores. Utilice esta regla para detectar estos problemas con antelación.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo. Debe especificar el parámetro collection_names o tensor_regex. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la TensorVariance regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.tensor_variance(),
        rule_parameters={
                "collection_names": "weights",
                "max_threshold": "10",
                "min_threshold": "0.00001",
        },
        collections_to_save=[ 
            CollectionConfig(
                name="weights", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

UnchangedTensor

Esta regla detecta si un tensor ya no cambia en los pasos.

Esta regla ejecuta el método numpy.allclose para comprobar si el tensor no está cambiando.

Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo compatibles (TensorFlowMXNet, y PyTorch) o al XGBoost algoritmo. Debe especificar el parámetro collection_names o tensor_regex. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la UnchangedTensor regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.unchanged_tensor(),
        rule_parameters={
                "collection_names": "losses",
                "tensor_regex": "",
                "num_steps": "3",
                "rtol": "1e-05",
                "atol": "1e-08",
                "equal_nan": "False"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

CheckInputImages

Esta regla comprueba si las imágenes de entrada se han normalizado correctamente. Específicamente, detecta si la media de los datos de muestra difiere de cero en más de un valor umbral. Muchos modelos de visión artificial requieren que los datos de entrada tengan una media cero y varianza unitaria.

Esta regla es aplicable a aplicaciones de aprendizaje profundo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la regla CheckInputImages

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.check_input_images(),
        rule_parameters={
                "threshold_mean": "0.2",
                "threshold_samples": "500",
                "regex": ".*hybridsequential0_input_0",
                "channel": "1"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_inputs_collection", 
                parameters={
                    "include_regex": ".*hybridsequential0_input_0",
                    "save_interval": "500"
                } 
            )
        ]
    )
]

NLPSequenceRatio

Esta regla calcula la proporción de tokens específicos dado el resto de la secuencia de entrada que es útil para optimizar el rendimiento. Por ejemplo, puede calcular el porcentaje de fichas de padding end-of-sentence (EOS) en la secuencia de entrada. Si el número de EOS fichas es demasiado alto, debes utilizar una estrategia de agrupamiento alternativa. También puede calcular el porcentaje de tokens desconocidos en su secuencia de entrada. Si el número de palabras desconocidas es demasiado alto, podría utilizarse un vocabulario alternativo.

Esta regla es aplicable a aplicaciones de aprendizaje profundo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la regla NLPSequenceRatio

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.nlp_sequence_ratio(),
        rule_parameters={
                "tensor_regex": ".*embedding0_input_0",
                "token_values": "0",
                "token_thresholds_percent": "50"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="custom_inputs_collection", 
                parameters={
                    "include_regex": ".*embedding0_input_0"
                } 
            )
        ]
    )
]

Confusion

Esta regla evalúa lo buena que es una matriz de confusión para un problema de clasificación.

Crea una matriz de tamaño category_no*category_no y la rellena con datos procedentes de pares (labels, predictions). Para cada par (labels, predictions), el recuento confusion[labels][predictions] se incrementa en 1. Cuando la matriz está completamente llena, la proporción de los valores de los datos en diagonal y fuera de diagonal se evalúa de la siguiente manera:

Esta regla se puede aplicar al XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de parámetros para la regla Confusion

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.confusion(),
        rule_parameters={
                "category_no": "10",
                "labels": "labels",
                "predictions": "predictions",
                "labels_collection": "labels",
                "predictions_collection": "predictions",
                "min_diag": "0.9",
                "max_off_diag": "0.1"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="labels",
                parameters={
                    "save_interval": "500"
                } 
            ),
            CollectionConfig(
                name="predictions",
                parameters={
                    "include_regex": "500"
                } 
            )
        ]
    )
]

FeatureImportanceOverweight

Esta regla acumula las ponderaciones de los valores n de mayor importancia de las características por paso y se asegura de que no superen el umbral. Por ejemplo, puede establecer el umbral para que las tres características principales no retengan más del 80 por ciento de los pesos totales del modelo.

Esta regla solo es válida para el XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la FeatureImportanceOverweight regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.feature_importance_overweight(),
        rule_parameters={
                "threshold": "0.8",
                "nfeatures": "3",
                "tensor_regex": ".*feature_importance/weight"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="feature_importance", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]

TreeDepth

Esta regla mide la profundidad de los árboles de un XGBoost modelo. XGBoostrechaza las divisiones si no mejoran las pérdidas. Esto regulariza el entrenamiento. Como resultado, es posible que el árbol no crezca con tanta profundidad como se define en parámetro depth.

Esta regla solo es válida para el XGBoost algoritmo.

Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte Cómo configurar las reglas integradas del Debugger.

Descripciones de los parámetros de la TreeDepth regla

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.tree_depth(),
        rule_parameters={
                "depth": "4"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="tree", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]