Lista de regras integradas do Debugger

Use as regras integradas do Debugger fornecidas pelo Amazon SageMaker Debugger e analise métricas e tensores coletados durante o treinamento de seus modelos. 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 Debugger

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

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.

CreateXgboostRelatório

A CreateXgboostReport regra coleta tensores de saída de um trabalho de treinamento do XGBoost 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:

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 o percentual de ReLUs inativas em uma camada for maior que o valor threshold_layer de ReLUs inativas, a regra retornará True.

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.

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.

PoorWeightInicialização

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.

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.

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.

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.

WeightUpdateRazão

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.

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 PyTorch e) ou ao algoritmo XGBoost. É 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.

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 previsõ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 PyTorch e) ou ao algoritmo XGBoost.

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

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

LossNotDiminuindo

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 PyTorch e) ou ao algoritmo XGBoost. É 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.

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 PyTorch e) ou ao algoritmo XGBoost.

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

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 PyTorch e) ou ao algoritmo XGBoost.

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

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

SimilarAcrossCorre

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 PyTorch e) ou ao algoritmo XGBoost.

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

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

StalledTrainingRegra

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.

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 aprendizagem 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 PyTorch e) ou ao algoritmo XGBoost. É 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.

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 PyTorch e) ou ao algoritmo XGBoost. É 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.

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

CheckInputImagens

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 aplicativos de aprendizagem profunda.

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

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

PNL SequenceRatio

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 aplicativos de aprendizagem profunda.

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

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 algoritmo XGBoost.

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

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

FeatureImportanceSobrepeso

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 apenas para o algoritmo XGBoost.

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

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 modelo do XGBoost. O XGBoost rejeita divisões se elas não melhoram 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 apenas para o algoritmo XGBoost.

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

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