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
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
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 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\$1trial | 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. **Obrigatório** Valores válidos: string |
```
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`.
Descrições de parâmetros para a regra DeadRelu
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | 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. **Obrigatório** Valores válidos: string |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `".*relu_output"` |
| threshold\$1inactivity | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `1.0` (em porcentagem) |
| threshold\$1layer | Retorna `True` se a porcentagem de ReLUs inativas em uma camada for maior que `threshold_layer`. Retorna `False` se a porcentagem de ReLUs inativas em uma camada for menor que `threshold_layer`. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: string Valor padrão: `None` |
| tensor\$1regex | 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. **Opcional** Valores válidos: string Valor padrão: `None` |
| only\$1nan | `True` para monitorar os tensores `base_trial` apenas para valores `NaN` e não para infinito. `False` para tratar ambos `NaN` e infinito como valores explosivos e para monitorar para ambos. **Opcional** 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| activation\$1inputs\$1regex | 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. **Opcional** Valores válidos: string 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`. **Opcional** Valores válidos: Flutuante Valor padrão: `10.0` |
| distribution\$1range | 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`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.001` |
| patience | O número de passos a aguardar até que a perda não seja mais decrescente. **Opcional** Valores válidos: inteiro Valor padrão: `5` |
| steps | O número de etapas que essa regra analisa. Normalmente, você precisa verificar apenas as primeiras iterações. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | 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. **Opcional** Valores válidos: string Valor padrão: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `-9.4999` |
| threshold\$1tanh\$1max | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `9.4999` |
| threshold\$1sigmoid\$1min | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `-23` |
| threshold\$1sigmoid\$1max | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `16.99999` |
| threshold\$1inactivity | 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. **Opcional** Valores válidos: Flutuante Valores padrão: `1.0` |
| threshold\$1layer | Retornará `True` se o número de ativações saturadas em uma camada for maior que a porcentagem de `threshold_layer`. Retornará `False` se o número de ativações saturadas em uma camada for menor que a porcentagem de `threshold_layer`. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| threshold | O valor no qual determina-se que o gradiente está desaparecendo.**Opcional**Valores válidos: FlutuanteValor 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| num\$1steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. 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`. **Opcional** Valores válidos: inteiro Valor padrão: `None` |
| large\$1threshold | O valor máximo que a proporção de atualizações em relação ao peso pode ter antes que a regra retorne `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `10.0` |
| small\$1threshold | 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`. **Opcional** Valores válidos: Flutuante 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. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| threshold | Especifica a porcentagem de valores no tensor que precisa ser zero para que essa regra seja invocada. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| threshold\$1imbalance | 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. **Opcional** Valores válidos: Flutuante Valor padrão: `10` |
| threshold\$1misprediction | 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. **Opcional** Valores válidos: Flutuante 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`. **Opcional** Valores válidos: inteiro 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. **Condicional** Valores válidos: booleano Valor padrão: `False` |
| labels\$1regex | O nome do tensor que contém os rótulos. **Opcional** Valores válidos: string Valor padrão: `".*labels"` |
| predictions\$1regex | O nome do tensor que contém as predições. **Opcional** Valores válidos: string 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| use\$1losses\$1collection | Se definido como `True`, procura perdas na coleção chamada "losses" (perdas) quando a coleção está presente. **Opcional** Valores válidos: booleano Valor padrão: `True` |
| num\$1steps | 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. **Opcional** Valores válidos: inteiro Valor padrão: `10` |
| diff\$1percent | A diferença percentual mínima pela qual a perda deve diminuir entre `num_steps`. **Opcional** Valores válidos: `0.0` < flutuante < `100` Valor padrão: `0.1` (em porcentagem) |
| increase\$1threshold\$1percent | A porcentagem do limite máximo em que a perda tem permissão para aumentar caso a perda esteja aumentando **Opcional** Valores válidos: `0` < flutuante < `100` 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`. **Opcional** Valores válidos: string (`EVAL`, `TRAIN` ou `GLOBAL`) 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| start\$1step | A etapa a partir da qual começar a comparar a perda de validação e de treinamento. **Opcional** Valores válidos: inteiro 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. **Opcional** Valores válidos: inteiro Valor padrão: `1` |
| ratio\$1threshold | 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`. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| patience\$1train | O número de etapas a aguardar antes que se considere que a perda de treinamento não esteja mais melhorando. **Opcional** Valores válidos: inteiro Valor padrão: `5` |
| patience\$1validation | O número de etapas a aguardar antes que se considere que a perda de validação não esteja mais melhorando.**Opcional**Valores válidos: inteiroValor padrão: `10` |
| delta | O limite mínimo de quanto o erro deve melhorar antes de ser considerado como um novo ideal. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| other\$1trials | Um nome de trabalho de treinamento concluído cujos tensores você deseja comparar com os tensores coletados do `base_trial` atual. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
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\$1trial | 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. **Obrigatório** 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. **Opcional** Valores válidos: inteiro Valor padrão: `1800` |
| stop\$1training\$1on\$1fire | Se definido como `True`, observa se o trabalho de treinamento básico gera tensores em “`threshold`” segundos. **Opcional** Valores válidos: booleano Valor padrão: `False` |
| training\$1job\$1name\$1prefix | 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. **Opcional** 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": ""
},
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.
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| max\$1threshold | O limite máximo da variância do tensor. **Opcional** Valores válidos: Flutuante Valor padrão: Nenhum |
| min\$1threshold | O limite mínimo da variância do tensor. **Opcional** Valores válidos: Flutuante 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| num\$1steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. 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. **Opcional** Valores válidos: inteiro 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)`. **Opcional** Valores válidos: Flutuante 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)`. **Opcional** Valores válidos: Flutuante Valor padrão: `1e-08` |
| equal\$1nan | 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)`. **Opcional** Valores válidos: booleano 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| threshold\$1mean | Um limite que define por quanto a média dos dados de entrada pode ser diferente de 0. **Opcional** Valores válidos: Flutuante Valor padrão: `0.2` |
| threshold\$1samples | 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. **Opcional** Valores válidos: inteiro Valor padrão: `500` |
| regex | O nome do tensor dos dados de entrada. **Opcional** Valores válidos: string 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. **Opcional** Valores válidos: inteiro Valor padrão: `1` (por exemplo, o MXNet espera dados de entrada na forma de (tamanho\$1do\$1lote, 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| tensor\$1regex | 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. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `".*embedding0_input_0"` (supondo uma incorporação como a camada inicial da rede) |
| token\$1values | Uma string de uma lista dos valores numéricos dos tokens. Por exemplo, "3, 0". **Opcional** Valores válidos: string de valores numéricos separados por vírgulas Valor padrão: `0` |
| token\$1thresholds\$1percent | Uma string de uma lista de limites (em porcentagens) que correspondem a cada um dos `token_values`. Por exemplo, "50,0; 50,0". **Opcional** Valores válidos: string de flutuações separadas por vírgulas 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| category\$1no | O número de categorias. **Opcional** Valores válidos: inteiro ≥2 Valor padrão: `"None"` |
| labels | A coleção de tensores `labels` ou um vetor 1-d de rótulos verdadeiros. **Opcional** Valores válidos: string Valor padrão: `"labels"` |
| predictions | A coleção de tensores `predictions` ou um vetor 1-d de rótulos estimados. **Opcional** Valores válidos: string Valor padrão: `"predictions"` |
| labels\$1collection | A regra inspeciona os tensores nesta coleção para `labels`. **Opcional** Valores válidos: string Valor padrão: `"labels"` |
| predictions\$1collection | A regra inspeciona os tensores nesta coleção para `predictions`. **Opcional** Valores válidos: string Valor padrão: `"predictions"` |
| min\$1diag | O limite mínimo da proporção de dados na diagonal. **Opcional** Valores válidos: `0`≤flutuante≤`1` Valor padrão: `0.9` |
| max\$1off\$1diag | O limite máximo da proporção de dados fora da diagonal. **Opcional** Valores válidos: `0`≤flutuante≤`1` 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
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\$1trial | 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. **Obrigatório** 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`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.8` |
| nfeatures | O número dos maiores atributos. **Opcional** Valores válidos: inteiro Valor padrão: `3` |
| tensor\$1regex | A expressão regular (regex) do tensor nomeia a regra a ser analisada. **Opcional** Valores válidos: string 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
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\$1trial | 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. **Obrigatório** Valores válidos: string |
| depth | A profundidade da árvore. A profundidade da árvore é obtida calculando o logaritmo base 2 do ID do maior nó. **Opcional** Valores válidos: Flutuante 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"
}
)
]
)
]
```