Lista de regras integradas do Depurador

Você pode usar as regras integradas do Debugger, fornecidas pelo Amazon SageMaker Debugger, para analisar métricas e tensores coletados durante o treinamento de seus modelos. A seguir estão listadas as regras do depurador, incluindo informações e um exemplo de como configurar e implantar cada regra incorporada.

Essas regras integradas do Debugger monitoram várias condições comuns que são críticas para o sucesso de um trabalho de treinamento. Você pode chamar as regras incorporadas usando o SDK do Amazon SageMaker Python ou as operações de API de baixo nível SageMaker .

Não há custo adicional para usar as regras integradas. Para obter mais informações sobre faturamento, consulte a página de SageMaker preços da Amazon.

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

Regra do Depurador

As regras a seguir são as regras integradas do Debugger que podem ser chamadas usando o método de classe Rule.sagemaker.

Regras integradas do Debugger para a geração de relatórios de treinamento

Regras integradas do Debugger para a depuração de dados de treinamento de modelo (tensores de saída)

Para usar as regras integradas com valores de parâmetros padrão, use o seguinte formato de configuração:

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 as regras integradas com valores de parâmetros personalizados, use o seguinte formato de configuração:

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 as chaves disponíveis para o parâmetro rule_parameters, consulte as tabelas de descrição de parâmetros.

Exemplos de códigos de configuração de regras são fornecidos para cada regra integrada abaixo das tabelas de descrição de parâmetros.

CreateXgboostReport

A CreateXgboostReport regra coleta tensores de saída de um trabalho de XGBoost treinamento e gera automaticamente um relatório de treinamento abrangente. Você pode baixar um relatório abrangente de criação de perfis enquanto um trabalho de treinamento é executado ou após a conclusão do trabalho de treinamento e verificar o progresso do treinamento ou o resultado final do trabalho de treinamento. A CreateXgboostReport regra coleta os seguintes tensores de saída por padrão:

Descrições de parâmetros para a CreateXgboostReport regra

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

DeadRelu

Essa regra detecta quando a porcentagem de funções de ativação de unidade linear retificada (ReLU) em um teste são consideradas inativas porque sua atividade de ativação caiu abaixo de um limite. Se a porcentagem de Re inativo LUs em uma camada for maior que o threshold_layer valor de Re inativoLUs, a regra retornará. True

Descrições de parâmetros para a DeadRelu regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

ExplodingTensor

Essa regra detecta se os tensores emitidos durante o treinamento têm valores não finitos, infinitos ou NaN (que não é um número). Se um valor não finito for detectado, a regra retornará True.

Descrições de parâmetros para a ExplodingTensor regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

PoorWeightInitialization

Essa regra detecta se os parâmetros do modelo foram inicializados incorretamente.

Uma inicialização correta quebra a simetria dos pesos e dos gradientes em uma rede neural e mantém variações de ativação proporcionais nas camadas. Caso contrário, a rede neural não aprende de maneira eficaz. Inicializadores como Xavier visam manter a variação constante em todas as ativações, o que é especialmente relevante para o treinamento de redes neurais muito profundas. Uma inicialização muito pequena pode levar ao desaparecimento de gradientes. Uma inicialização muito grande pode levar à explosão de gradientes. Essa regra verifica a variação das entradas de ativação nas camadas, a distribuição de gradientes e a convergência de perda para as etapas iniciais a fim de determinar se uma rede neural foi inicializada incorretamente.

Descrições de parâmetros para a PoorWeightInitialization regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

SaturatedActivation

Essa regra detecta se as camadas de ativação de tanh (tangente hiperbólica) e sigmoide estão ficando saturadas. Uma camada de ativação fica saturada quando a entrada da camada está próxima do máximo ou do mínimo da função de ativação. O mínimo e máximo das funções de ativação tanh e sigmoide são definidos pelos seus respectivos valores min_threshold e max_thresholds. Se a atividade de um nó cair abaixo da porcentagem de threshold_inactivity, ele será considerada saturado. Se mais de um percentual de threshold_layer dos nós estiverem saturados, a regra retornará True.

Descrições de parâmetros para a SaturatedActivation regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

VanishingGradient

Essa regra detecta se os gradientes em um teste se tornam extremamente pequenos ou caem para uma magnitude zero. Se a média dos valores absolutos dos gradientes cair abaixo de um threshold especificado, a regra retornará True.

Descrições dos parâmetros da VanishingGradient regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

WeightUpdateRatio

Essa regra mantém o controle da proporção de atualizações com relação a pesos durante o treinamento e detecta se essa proporção fica muito grande ou muito pequena. Se a proporção de atualizações com relação a pesos for maior do que o large_threshold value ou se essa proporção for menor que small_threshold, a regra retornará True.

As condições de treinamento são melhores quando as atualizações são proporcionais aos gradientes. As atualizações excessivamente grandes podem afastar os pesos dos valores ideais, e as atualizações muito pequenas resultam em uma convergência muito lenta. Essa regra requer que os pesos estejam disponíveis para duas etapas consecutivas, e train.save_interval precisa ser definido como igual a num_steps.

Descrições de parâmetros para a WeightUpdateRatio regra

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 obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

AllZero

Essa regra detecta se todos ou uma porcentagem especificada dos valores dos tensores são zero.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo. É necessário especificar o parâmetro collection_names ou tensor_regex. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições dos parâmetros da AllZero regra

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

Essa regra mede os desequilíbrios de amostragem entre classes e lança erros se o desequilíbrio exceder um limite ou se ocorrerem muitas predições erradas para classes sub-representadas como resultado do desequilíbrio.

Os modelos de classificação exigem classes bem equilibradas no conjunto de dados de treinamento ou uma ponderação/amostragem adequada das classes durante o treinamento. A regra executa as seguintes verificações:

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a ClassImbalance regra

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

Essa regra detecta quando a perda não está diminuindo em valor a uma taxa adequada. Essas perdas devem ser escalares.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo. É necessário especificar o parâmetro collection_names ou tensor_regex. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a LossNotDecreasing regra

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

Essa regra detecta se o modelo está sendo sobreajustado aos dados de treinamento comparando as perdas de validação e treinamento.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros da regra de 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

Essa regra detecta se um modelo está sendo treinado em excesso. Depois de várias iterações de treinamento em um modelo bem-comportado (diminuição da perda de treinamento e validação), o modelo se aproxima de um mínimo da função de perda e não melhora mais. Se o modelo continuar treinando, pode acontecer que a perda de validação comece a aumentar, porque o modelo começa a apresentar sobreajuste. Essa regra define limites e condições para determinar se o modelo não está melhorando e evita problemas de sobreajuste devido ao excesso de treinamento.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros da regra 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

Essa regra compara tensores coletados de um teste base com tensores de outro teste.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a SimilarAcrossRuns regra

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 se não há progresso no trabalho de treinamento e interrompe o trabalho de treinamento se a regra for acionada. Essa regra exige que os tensores sejam salvos periodicamente em um intervalo de tempo definido por seu parâmetro threshold. Essa regra continua monitorando novos tensores e, se nenhum novo tensor for emitido, a regra de intervalo de limite será acionada.

Descrições de parâmetros para a StalledTrainingRule regra

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

Essa regra detecta se você tem tensores com variâncias muito altas ou muito baixas. Variâncias muito altas ou muito baixas em um tensor podem levar à saturação de neurônios, o que reduz a capacidade de aprendizado da rede neural. A variância muito alta nos tensores também pode acabar resultando em tensores explosivos. Use essa regra para detectar esses problemas antecipadamente.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo. É necessário especificar o parâmetro collection_names ou tensor_regex. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a TensorVariance regra

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

Essa regra detecta se um tensor não está mais mudando ao longo das etapas.

Essa regra executa o método numpy.allclose para verificar se o tensor não está mudando.

Essa regra pode ser aplicada a uma das estruturas de aprendizado profundo suportadas (TensorFlow, MXNet, e PyTorch) ou ao XGBoost algoritmo. É necessário especificar o parâmetro collection_names ou tensor_regex. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a UnchangedTensor regra

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

Essa regra verifica se as imagens de entrada foram normalizadas corretamente. Especificamente, ela detecta se a média dos dados de amostra difere de zero em mais de um valor limite. Muitos modelos de visão computacional exigem que os dados de entrada tenham uma média zero e variação de unidade.

Esta regra é aplicável a aplicações de aprendizado profundo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a CheckInputImages regra

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

NLPSequenceProporção

Essa regra calcula a proporção de tokens específicos, dado o resto da sequência de entrada que é útil para otimizar o desempenho. Por exemplo, você pode calcular a porcentagem de tokens de preenchimento end-of-sentence (EOS) em sua sequência de entrada. Se o número de tokens de EOS for muito alto, deverá ser executada uma estratégia de armazenamento bucketing alternativa. Também é possível calcular a porcentagem de tokens desconhecidos na sequência de entrada. Se o número de palavras desconhecidas for muito alto, poderá ser usado um vocabulário alternativo.

Esta regra é aplicável a aplicações de aprendizado profundo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a regra NLPSequence de proporção

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

Essa regra avalia a qualidade de uma matriz de confusão para um problema de classificação.

Ela cria uma matriz de tamanho category_no*category_no e a preenche com dados de pares (labels, predictions). Para cada par (labels, predictions), a contagem em confusion[labels][predictions] é incrementada em 1. Quando a matriz é totalmente preenchida, a proporção de dados de valores na diagonal e de valores fora da diagonal são avaliados da seguinte maneira:

Essa regra pode ser aplicada ao XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros da regra 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

Essa regra acumula os pesos dos n maiores valores de importância do atributo por etapa e garante que eles não excedam o limite. Por exemplo, você pode definir o limite para que os três principais atributos não suportem mais de 80% dos pesos totais do modelo.

Essa regra é válida somente para o XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a FeatureImportanceOverweight regra

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

Essa regra mede a profundidade das árvores em um XGBoost modelo. XGBoost rejeita divisões se elas não melhorarem a perda. Isso regulariza o treinamento. Como resultado, a árvore pode não crescer tão profundamente como definido no parâmetro depth.

Essa regra é válida somente para o XGBoost algoritmo.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte Configurar regras integradas do Depurador.

Descrições de parâmetros para a TreeDepth regra

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