As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Lista de regras integradas do Depurador
<a name="debugger-built-in-rules"></a>

Você pode usar as regras integradas do Depurador fornecidas pelo Amazon SageMaker Debugger para analisar métricas e tensores coletados durante o treinamento dos 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 integradas usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) ou as operações de API de baixo nível do SageMaker. 

Não há custo adicional para usar as regras integradas. Para obter mais informações sobre faturamento, consulte a página de [Definição de preços do Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).

**nota**  
O número máximo de regras integradas que você pode anexar a um trabalho de treinamento é 20. O SageMaker Debugger gerencia totalmente as regras integradas e analisa seu trabalho de treinamento de forma síncrona.

**Importante**  
Para usar os novos atributos do Debugger, você precisa atualizar o SageMaker Python SDK e a biblioteca de cliente do SMDebug. No kernel do iPython, no caderno Jupyter ou no ambiente do JupyterLab, execute o código a seguir para instalar as versões mais recentes das bibliotecas e reiniciar o kernel.  

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

## Regra do Depurador
<a name="debugger-built-in-rules-Rule"></a>

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


| Escopo de validade | Regras integradas | 
| --- | --- | 
| Relatório de treinamento para a tarefa de treinamento do XGBoost do SageMaker AI |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

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


| Escopo de validade | Regras integradas | 
| --- | --- | 
| Estruturas de aprendizado profundo (TensorFlow, MXNet e PyTorch) |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Estruturas de aprendizado profundo (TensorFlow, MXNet e PyTorch) e o algoritmo XGBoost  |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Aplicações de aprendizado profundo |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Algoritmo XGBoost |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

**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.
+ Para obter instruções completas e exemplos de uso das regras integradas do Debugger, consulte [Código de exemplo de regras integradas do Depurador](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Para obter instruções completas sobre como usar as regras integradas com as operações de API de baixo nível do SageMaker, consulte [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md).

## CreateXgboostReport
<a name="create-xgboost-report"></a>

A regra CreateXGBoostReport 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 regra CreateXGBoostReport coleta os seguintes tensores de saída por padrão: 
+ `hyperparameters`: Salva na primeira etapa
+ `metrics`: Economiza perdas e precisão a cada 5 etapas
+ `feature_importance`: Salva a cada 5 etapas
+ `predictions`: Salva a cada 5 etapas
+ `labels`: Salva a cada 5 etapas

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


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger.<br />**Obrigatório**<br />Valores válidos: string | 

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

## DeadRelu
<a name="dead-relu"></a>

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`.

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


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: `".*relu_output"` | 
| threshold\_inactivity | Define um nível de atividade abaixo do qual uma ReLU é considerada morta. Uma ReLU pode estar ativa no início de um teste e, depois, morrer lentamente durante o processo de treinamento. Se a ReLU estiver ativa abaixo do `threshold_inactivity`, ela será considerada morta.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `1.0` (em porcentagem) | 
| threshold\_layer | Retorna `True` se a porcentagem de ReLUs inativas em uma camada for maior que `threshold_layer`.<br />Retorna `False` se a porcentagem de ReLUs inativas em uma camada for menor que `threshold_layer`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `50.0` (em porcentagem) | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## ExplodingTensor
<a name="exploding-tensor"></a>

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 regra ExplodingTensor


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `None` | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: string <br />Valor padrão: `None` | 
| only\_nan |  `True` para monitorar os tensores `base_trial` apenas para valores `NaN` e não para infinito. <br />`False` para tratar ambos `NaN` e infinito como valores explosivos e para monitorar para ambos.<br />**Opcional**<br />Valor padrão: `False` | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## PoorWeightInitialization
<a name="poor-weight-initialization"></a>

 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 da regra de PoorWeightInitialization


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| activation\_inputs\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `".*relu_input"` | 
| threshold | Se a proporção entre variação mínima e máxima de pesos por camada exceder o `threshold` em uma etapa, a regra retornará `True`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `10.0` | 
| distribution\_range | Se a diferença mínima entre os 5º e 95º percentis da distribuição de gradientes for menor que o `distribution_range`, a regra retornará `True`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.001` | 
| patience | O número de passos a aguardar até que a perda não seja mais decrescente.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `5` | 
| steps | O número de etapas que essa regra analisa. Normalmente, você precisa verificar apenas as primeiras iterações.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `10` | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## SaturatedActivation
<a name="saturated-activation"></a>

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 da regra SaturatedActivation


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: Nenhum | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: string <br />Valor padrão: `".*tanh_input\|.*sigmoid_input".` | 
| threshold\_tanh\_min | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação tanh, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `-9.4999` | 
| threshold\_tanh\_max | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação tanh, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `9.4999` | 
| threshold\_sigmoid\_min | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação sigmoide, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `-23` | 
| threshold\_sigmoid\_max | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação sigmoide, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `16.99999` | 
| threshold\_inactivity | A porcentagem de inatividade abaixo da qual a camada de ativação é considerada saturada. A ativação pode estar ativa no início de um teste e, depois, lentamente tornar-se menos ativa durante o processo de treinamento.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `1.0` | 
| threshold\_layer | Retornará `True` se o número de ativações saturadas em uma camada for maior que a porcentagem de `threshold_layer`.<br />Retornará `False` se o número de ativações saturadas em uma camada for menor que a porcentagem de `threshold_layer`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valores padrão: `50.0` | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## VanishingGradient
<a name="vanishing-gradient"></a>

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 de parâmetros da regra de VanishingGradient


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| threshold | O valor no qual determina-se que o gradiente está desaparecendo.**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.0000001`. | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## WeightUpdateRatio
<a name="weight-update-ratio"></a>

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 da regra WeightUpdateRatio


| Nome do parâmetro, | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| num\_steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. <br />O número de etapas com as quais você deseja comparar as proporções de peso. Se você não transmitir nenhum valor, a regra será executada por padrão em relação à etapa atual e à etapa salva imediatamente antes. Se você substituir o padrão transmitindo um valor para esse parâmetro, a comparação será feita entre pesos na etapa `s` e em uma etapa `>= s - num_steps`.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `None` | 
| large\_threshold | O valor máximo que a proporção de atualizações em relação ao peso pode ter antes que a regra retorne `True`. <br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `10.0` | 
| small\_threshold | O valor mínimo que a proporção de atualizações com relação ao peso pode ter, abaixo do qual a regra retorna `True`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.00000001` | 
| epsilon | Uma pequena constante usada para garantir que o Debugger não divida por zero ao calcular as atualizações de proporção do peso.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.000000001` | 

```
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](use-debugger-built-in-rules.md).

**nota**  
Essa regra não está disponível para o algoritmo XGBoost.

## AllZero
<a name="all-zero"></a>

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

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) 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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra AllZero


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: `None` | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: `None` | 
| threshold | Especifica a porcentagem de valores no tensor que precisa ser zero para que essa regra seja invocada. <br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: 100 (em porcentagem) | 

```
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
<a name="class-imbalance"></a>

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:
+  Ela conta as ocorrências por classe. Se a proporção do número de amostras entre a menor e a maior classe for maior do que o `threshold_imbalance`, será lançado um erro.
+  Ela verifica a precisão de predição por classe. Se a reamostragem ou a ponderação não tiver sido aplicada corretamente, o modelo poderá atingir alta precisão para a classe com muitas amostras de treinamento, mas baixa precisão para as classes com poucas amostras de treinamento. Se uma fração de predições erradas de determinada classe estiver acima de `threshold_misprediction`, será lançado um erro.

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra ClassImbalance


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| threshold\_imbalance | O desequilíbrio aceitável entre o número de amostras da classe menor e da classe maior. Se esse valor do limite for excedido, será lançado um erro.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `10` | 
| threshold\_misprediction | Um limite da fração de predições incorretas permitidas para cada classe. Se esse limite for excedido, será lançado um erro. As classes sub-representadas têm maior risco de ultrapassar esse limite. <br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.7` | 
| samples | O número de rótulos que precisam ser processados antes de um desequilíbrio ser avaliado. A regra pode não ser acionada até que tenha visto amostras suficientes em várias etapas. Quanto mais classes o conjunto de dados tiver, maior será o número de `sample`. <br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `500` (supondo um conjunto de dados como MNIST com 10 classes) | 
| argmax | Se `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) será aplicado ao tensor da predição. Obrigatório quando você tem um vetor de probabilidades para cada classe. Ele é usado para determinar qual classe tem a maior probabilidade.<br />**Condicional**<br />Valores válidos: booleano<br />Valor padrão: `False` | 
| labels\_regex | O nome do tensor que contém os rótulos.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `".*labels"` | 
| predictions\_regex | O nome do tensor que contém as predições.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `".*predictions"` | 

```
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
<a name="loss-not-decreasing"></a>

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

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) 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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra LossNotDecreasing


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: `None` | 
| tensor\_regex | Uma lista de padrões regex que é usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: `None` | 
| use\_losses\_collection | Se definido como `True`, procura perdas na coleção chamada "losses" (perdas) quando a coleção está presente.<br />**Opcional**<br />Valores válidos: booleano<br />Valor padrão: `True` | 
| num\_steps | O número mínimo de etapas após as quais a regra verifica se a perda diminuiu. A avaliação da regra acontece a cada `num_steps`. A regra compara a perda dessa etapa com a perda de uma etapa que está pelo menos `num_steps` atrás da etapa atual. Por exemplo, suponha que a perda está sendo salva a cada três etapas, mas `num_steps` está definido como 10. Na etapa 21, a perda dessa etapa é comparada com a perda da etapa 9. A próxima etapa em que a perda é verificada é a etapa 33, porque dez etapas após a etapa 21 é a etapa 31 e, na etapa 31 e etapa 32, a perda não é salva. <br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `10` | 
| diff\_percent | A diferença percentual mínima pela qual a perda deve diminuir entre `num_steps`.<br />**Opcional**<br />Valores válidos: `0.0` < flutuante < `100`<br />Valor padrão: `0.1` (em porcentagem) | 
| increase\_threshold\_percent | A porcentagem do limite máximo em que a perda tem permissão para aumentar caso a perda esteja aumentando<br />**Opcional**<br />Valores válidos: `0` < flutuante < `100`<br />Valor padrão: `5` (em porcentagem) | 
| mode | O nome do modo do Debugger para consultar valores de tensor da verificação de regras. Se isso não for transmitido, a regra verificará em ordem por padrão para o `mode.EVAL`, depois `mode.TRAIN` e, então, `mode.GLOBAL`. <br />**Opcional**<br />Valores válidos: string (`EVAL`, `TRAIN` ou `GLOBAL`)<br />Valor padrão: `GLOBAL` | 

```
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
<a name="overfit"></a>

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

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).

**nota**  
Uma maneira padrão de evitar o sobreajuste é regularizar o modelo.

Descrições de parâmetros da regra de Overfit


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: Nenhum | 
| start\_step | A etapa a partir da qual começar a comparar a perda de validação e de treinamento.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `0` | 
| patience | O número de etapas para as quais o `ratio_threshold` tem permissão para exceder o valor definido antes que o modelo seja considerado sobreajuste.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `1` | 
| ratio\_threshold | A proporção máxima da diferença entre a perda média de validação e a perda média de treinamento com relação à perda média de treinamento. Se esse limite for excedido para um número `patience` de etapas, o modelo estará sendo sobreajustado e a regra retornará `True`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.1` | 

```
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
<a name="overtraining"></a>

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.

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).

**nota**  
O excesso de treinamento pode ser evitado pela interrupção precoce. Para obter informações sobre interrupção precoce, consulte [Interromper trabalhos de treinamento precocemente](automatic-model-tuning-early-stopping.md). Para obter um exemplo que mostra como usar o treinamento spot com o Debugger, consulte [Ativar o treinamento spot com o Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html). 

Descrições de parâmetros da regra Overtraining


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| patience\_train | O número de etapas a aguardar antes que se considere que a perda de treinamento não esteja mais melhorando.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `5` | 
| patience\_validation | O número de etapas a aguardar antes que se considere que a perda de validação não esteja mais melhorando.**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `10` | 
| delta | O limite mínimo de quanto o erro deve melhorar antes de ser considerado como um novo ideal.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.01` | 

```
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
<a name="similar-across-runs"></a>

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

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.

Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra SimilarAcrossRuns


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| other\_trials | Um nome de trabalho de treinamento concluído cujos tensores você deseja comparar com os tensores coletados do `base_trial` atual.<br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: Nenhum | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: Nenhum | 

```
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
<a name="stalled-training"></a>

A 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 regra StalledTrainingRule


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| threshold | Um limite que define por quanto tempo em segundos a regra espera pela saída de um tensor até acionar um problema de treinamento interrompido. O valor padrão é de 1800 segundos.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `1800` | 
| stop\_training\_on\_fire | Se definido como `True`, observa se o trabalho de treinamento básico gera tensores em “`threshold`” segundos.<br />**Opcional**<br />Valores válidos: booleano<br />Valor padrão: `False` | 
| training\_job\_name\_prefix | O prefixo do nome do trabalho de treinamento básico. Se `stop_training_on_fire` for verdadeiro, a regra procura trabalhos de treinamento do SageMaker com esse prefixo na mesma conta. Se for encontrada uma inatividade, a regra executa uma ação `StopTrainingJob`. Observe que, se houver vários trabalhos encontrados com o mesmo prefixo, a regra ignora o encerramento. É importante que o prefixo seja definido de forma exclusiva para cada trabalho de treinamento.<br />**Opcional**<br />Valores válidos: string | 

```
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
<a name="tensor-variance"></a>

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.

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) 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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra TensorVariance


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: Nenhum | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: Nenhum | 
| max\_threshold | O limite máximo da variância do tensor.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: Nenhum | 
| min\_threshold | O limite mínimo da variância do tensor.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: Nenhum | 

```
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
<a name="unchanged-tensor"></a>

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

Essa regra executa o método [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) para verificar se o tensor não está mudando.

Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) 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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra UnchangedTensor


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| collection\_names | A lista de nomes de coleção cujos tensores a regra inspeciona.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas<br />Valor padrão: Nenhum | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: Nenhum | 
| num\_steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. <br />Isso verifica os últimos `num_steps` que estão disponíveis. Eles não precisam ser consecutivos. Se `num_steps` for 2, na etapa s ela não necessariamente verifica s-1 e s. Se s-1 não estiver disponível, ela verifica a última etapa disponível com s. Nesse caso, ela verifica a última etapa disponível com a etapa atual.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `3` | 
| rtol | O parâmetro de tolerância relativa a ser transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. <br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `1e-05` | 
| atol | O parâmetro de tolerância absoluta a ser transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `1e-08` | 
| equal\_nan | Se os NaNs devem ser comparados como iguais. Se `True`, os NaNs na matriz de entrada a são considerados iguais aos NaNs na matriz de entrada b na matriz de saída. Este parâmetro é transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`.<br />**Opcional**<br />Valores válidos: booleano<br />Valor padrão: `False` | 

```
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
<a name="checkinput-mages"></a>

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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra CheckInputImages


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| threshold\_mean | Um limite que define por quanto a média dos dados de entrada pode ser diferente de 0.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.2` | 
| threshold\_samples | O número de imagens que precisam ser amostradas antes que um erro possa ser lançado. Se o valor for muito baixo, a estimativa da média do conjunto de dados será imprecisa.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `500` | 
| regex | O nome do tensor dos dados de entrada.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `".*hybridsequential0_input_0"` (o nome do tensor de entrada para modelos do Apache MXNet usando HybridSequential) | 
| channel | A posição do canal de cor na matriz de forma do tensor de entrada. <br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `1` (por exemplo, o MXNet espera dados de entrada na forma de (tamanho\_do\_lote, canal, altura, largura)) | 

```
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
<a name="nlp-sequence-ratio"></a>

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, é possível calcular a porcentagem de tokens de fim de sentença (EOS) de preenchimento na 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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra NLPSequenceRatio


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| tensor\_regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados.<br />**Opcional**<br />Valores válidos: lista de strings ou uma string separada por vírgulas <br />Valor padrão: `".*embedding0_input_0"` (supondo uma incorporação como a camada inicial da rede) | 
| token\_values | Uma string de uma lista dos valores numéricos dos tokens. Por exemplo, "3, 0".<br />**Opcional**<br />Valores válidos: string de valores numéricos separados por vírgulas<br />Valor padrão: `0` | 
| token\_thresholds\_percent | Uma string de uma lista de limites (em porcentagens) que correspondem a cada um dos `token_values`. Por exemplo, "50,0; 50,0".<br />**Opcional**<br />Valores válidos: string de flutuações separadas por vírgulas<br />Valor padrão: `"50"` | 

```
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
<a name="confusion"></a>

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:
+ Para elementos na diagonal: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Para elementos fora da diagonal: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`

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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra Confusion


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| category\_no | O número de categorias.<br />**Opcional**<br />Valores válidos: inteiro ≥2<br />Valor padrão: `"None"` | 
| labels | A coleção de tensores `labels` ou um vetor 1-d de rótulos verdadeiros. <br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `"labels"` | 
| predictions | A coleção de tensores `predictions` ou um vetor 1-d de rótulos estimados. <br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `"predictions"` | 
| labels\_collection | A regra inspeciona os tensores nesta coleção para `labels`.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `"labels"` | 
| predictions\_collection | A regra inspeciona os tensores nesta coleção para `predictions`.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `"predictions"` | 
| min\_diag | O limite mínimo da proporção de dados na diagonal.<br />**Opcional**<br />Valores válidos: `0`≤flutuante≤`1`<br />Valor padrão: `0.9` | 
| max\_off\_diag | O limite máximo da proporção de dados fora da diagonal.<br />**Opcional**<br />Valores válidos: `0`≤flutuante≤`1`<br />Valor padrão: `0.1` | 

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

**nota**  
Essa regra inferirá valores padrão para os parâmetros opcionais se seus valores não forem especificados.

## FeatureImportanceOverweight
<a name="feature_importance_overweight"></a>

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](use-debugger-built-in-rules.md).

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


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| threshold | Define o limite para a proporção da soma cumulativa dos `n` maiores atributos. O número `n` é definido pelo parâmetro `nfeatures`.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `0.8` | 
| nfeatures | O número dos maiores atributos.<br />**Opcional**<br />Valores válidos: inteiro<br />Valor padrão: `3` | 
| tensor\_regex | A expressão regular (regex) do tensor nomeia a regra a ser analisada.<br />**Opcional**<br />Valores válidos: string<br />Valor padrão: `".*feature_importance/weight"` | 

```
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
<a name="tree-depth"></a>

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](use-debugger-built-in-rules.md).

Descrições de parâmetros da regra TreeDepth


| Nome do parâmetro | Descrição | 
| --- | --- | 
| base\_trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. <br />**Obrigatório**<br />Valores válidos: string | 
| depth | A profundidade da árvore. A profundidade da árvore é obtida calculando o logaritmo base 2 do ID do maior nó.<br />**Opcional**<br />Valores válidos: Flutuante<br />Valor padrão: `4` | 

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