本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# Debugger 内置规则列表
<a name="debugger-built-in-rules"></a>

您可以使用 Amazon SageMaker Debugger 提供的 Debugger 内置规则，分析在训练模型时收集的指标和张量。下面列出了 Debugger 规则，包括如何配置和部署每个内置规则的信息和示例。

Debugger 内置规则监控对成功运行训练作业至关重要的各种常见条件。您可以使用 [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) 或者是低级别的 SageMaker API 操作调用内置规则。

使用内置规则不会产生额外费用。有关计费的更多信息，请参阅 [Amazon SageMaker 定价](https://www.amazonaws.cn/sagemaker/pricing/)页面。

**注意**  
在一个训练作业上可以附加的内置规则的最大数量为 20。SageMaker Debugger 完全管理内置规则，并同步分析您的训练作业。

**重要**  
要使用新的 Debugger 功能，您需要升级 SageMaker Python SDK 和 SMDebug 客户端库。在您的 iPython 内核、Jupyter 笔记本或 JupyterLab 环境中，运行以下代码以安装最新版本的库并重新启动内核。  

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

## Debugger 规则
<a name="debugger-built-in-rules-Rule"></a>

以下规则是可使用 `Rule.sagemaker` 类方法调用的 Debugger 内置规则。

用于生成训练报告的 Debugger 内置规则


| 有效性范围 | 内置规则 | 
| --- | --- | 
| SageMaker AI XGboost 训练作业的训练报告 |  [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

用于调试模型训练数据（输出张量）的 Debugger 内置规则


| 有效性范围 | 内置规则 | 
| --- | --- | 
| 深度学习框架（TensorFlow、MXNet 和 PyTorch） |  [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| 深度学习框架（TensorFlow、MXNet 和 PyTorch）和 XGBoost 算法  |  [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| 深度学习应用程序 |  [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| XGBoost 算法 |  [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

**使用内置规则及默认参数值** – 使用以下配置格式：

```
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())
]
```

**使用内置规则及自定义参数值** – 使用以下配置格式：

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

要查找 `rule_parameters` 参数的可用键，请参阅参数描述表。

针对每个内置规则，参数描述表下方提供了示例规则配置代码。
+ 有关使用 Debugger 内置规则的完整说明和示例，请参阅 [Debugger 内置规则示例代码](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules)。
+ 有关在低级 SageMaker API 操作中使用内置规则的完整说明，请参阅[使用 SageMaker API 配置调试器](debugger-createtrainingjob-api.md)。

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

CreateXgboostReport 规则从 XGBoost 训练作业收集输出张量，并自动生成综合训练报告。您可以在训练作业运行期间或训练作业完成后，下载综合分析报告，以查看训练的进度或训练作业的最终结果。默认情况下，CreateXgboostReport 规则收集以下输出张量：
+ `hyperparameters` – 在第一个步骤保存
+ `metrics` – 每 5 个步骤保存损失和准确性
+ `feature_importance` – 每 5 个步骤保存一次
+ `predictions` – 每 5 个步骤保存一次
+ `labels` – 每 5 个步骤保存一次

CreateXgboostReport 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial | 基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 

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

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

此规则检测试验中的修正线性单元 (ReLU) 激活函数的百分比是否因它们的激活活动已降至阈值以下而被视为死亡。如果层中非活跃 ReLU 的百分比大于非活跃 ReLU 的 `threshold_layer` 值，则该规则会返回 `True`。

DeadRelu 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：`".*relu_output"`  | 
| threshold\$1inactivity |  定义一个活动级别，低于该级别的 ReLU 将被视为死亡。ReLU 可能在试验开始时处于活动状态，然后在训练过程中慢慢死亡。如果 ReLU 处于活动状态并低于 `threshold_inactivity`，则将其视为死亡。 **可选** 有效值：浮点值 默认值：`1.0`（百分比）  | 
| threshold\$1layer |  如果层中非活跃 ReLU 百分比大于 `threshold_layer`，则返回 `True`。 如果层中非活跃 ReLU 百分比小于 `threshold_layer`，则返回 `False`。 **可选** 有效值：浮点值 默认值：`50.0`（百分比）  | 

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

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

此规则检测训练期间发射的张量是否具有非有限值，即无限值或 NaN（不是数字）。如果检测到非有限值，则该规则返回 `True`。

ExplodingTensor 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串 默认值：`None`  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串  默认值：`None`  | 
| only\$1nan |   如果为 `True`，则仅监视 `base_trial` 张量是否为 `NaN` 值，而不监视无穷大。 如果为 `False`，则将 `NaN` 和无穷大都视为爆炸值并监视两者。 **可选** 默认值：`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"
                }
            )
        ]
    )
]
```

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

 此规则检测模型参数是否初始化不当。

良好的初始化会破坏神经网络中权重和梯度的对称性，并在各层之间保持相应的激活方差。否则，神经网络无法有效地学习。诸如 Xavier 之类的初始化程序旨在使激活之间的方差保持恒定，这对于训练非常深的神经网络尤其重要。初始化太小可能会导致梯度消失。初始化过大可能会导致梯度爆炸。此规则检查各层激活输入的方差、梯度分布以及初始步骤的损失收敛性，确定神经网络是否初始化不当。

PoorWeightInitialization 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| activation\$1inputs\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串 默认值：`".*relu_input"`  | 
| threshold |  如果每个层的权重的最小方差和最大方差之间的比率超过某个步骤中的 `threshold`，则该规则返回 `True`。 **可选** 有效值：浮点值 默认值：`10.0`  | 
| distribution\$1range |  如果梯度分布的第 5 百分位数和第 95 百分位数之间的最小差值小于 `distribution_range`，则该规则返回 `True`。 **可选** 有效值：浮点值 默认值：`0.001`  | 
| patience |  等到损失被认为不再减少的步骤数。 **可选** 有效值：整数 默认值：`5`  | 
| steps |  此规则分析的步骤数。您通常只需要检查前几次迭代。 **可选** 有效值：浮点值 默认值：`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"
                } 
            )
        ]
    )
]
```

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

此规则检测 tanh 和 sigmoid 激活层是否正在变得饱和。当层的输入接近激活函数的最大或最小值时，激活层将饱和。tanh 和 sigmoid 激活函数的最小和最大值由它们各自的 `min_threshold` 和 `max_thresholds` 值定义。如果节点的活动降到 `threshold_inactivity` 百分比以下，则将其视为饱和。如果超过 `threshold_layer` 百分比的节点处于饱和状态，则该规则返回 `True`。

SaturatedActivation 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：无  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串  默认值：`".*tanh_input\|.*sigmoid_input".`  | 
| threshold\$1tanh\$1min |  定义 tanh 激活函数输入极值的最小和最大阈值，定义为：`(min_threshold, max_threshold)`。默认值是根据梯度消失阈值 0.0000001 确定的。 **可选** 有效值：浮点值 默认值：`-9.4999`  | 
| threshold\$1tanh\$1max |  定义 tanh 激活函数输入极值的最小和最大阈值，定义为：`(min_threshold, max_threshold)`。默认值是根据梯度消失阈值 0.0000001 确定的。 **可选** 有效值：浮点值 默认值：`9.4999`  | 
| threshold\$1sigmoid\$1min |  定义 sigmoid 激活函数输入极值的最小和最大阈值，定义为：`(min_threshold, max_threshold)`。默认值是根据梯度消失阈值 0.0000001 确定的。 **可选** 有效值：浮点值 默认值：`-23`  | 
| threshold\$1sigmoid\$1max |  定义 sigmoid 激活函数输入极值的最小和最大阈值，定义为：`(min_threshold, max_threshold)`。默认值是根据梯度消失阈值 0.0000001 确定的。 **可选** 有效值：浮点值 默认值：`16.99999`  | 
| threshold\$1inactivity |  不活动百分比，低于该百分比的激活层被视为饱和。激活可能在试验开始时处于活动状态，然后在训练过程中逐渐变得不那么活跃。 **可选** 有效值：浮点值 默认值：`1.0`  | 
| threshold\$1layer |  如果层中的饱和激活数大于 `threshold_layer` 百分比，则返回 `True`。 如果层中的饱和激活数小于 `threshold_layer` 百分比，则返回 `False`。 **可选** 有效值：浮点值 默认值：`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"
                } 
            )
        ]
    )
]
```

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

该规则检测试验中的梯度是否变得非常小或降至零幅度。如果梯度绝对值的平均值低于指定的 `threshold`，则该规则返回 `True`。

VanishingGradient 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| threshold | 确定梯度消失的值。**可选**有效值：浮点值默认值：`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"
                } 
            )
        ]
    )
]
```

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

此规则跟踪训练期间更新与权重的比率，并检测该比率是过大还是过小。如果更新与权重的比率大于 `large_threshold value` 或者此比率小于 `small_threshold`，则该规则返回 `True`。

当更新与梯度相当时，训练条件是最佳的。过大的更新会使权重远离最佳值，而过小的更新会导致收敛速度非常慢。此规则要求权重可用于两个训练步骤，因此 `train.save_interval` 需要设置为 `num_steps`。

WeightUpdateRatio 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| num\$1steps |  该规则检查以确定张量是否已更改的步骤数。 要比较权重比率的步骤数。如果未传递任何值，则默认情况下，将针对当前步骤和紧接的上一个保存步骤运行该规则。如果您通过传递此参数的值来覆盖默认值，则会在步骤 `s` 和步骤 `>= s - num_steps` 的权重之间进行比较。 **可选** 有效值：整数 默认值：`None`  | 
| large\$1threshold |  要执行加权的更新比率可以取的最大值，超过该值时规则将返回 `True`。 **可选** 有效值：浮点值 默认值：`10.0`  | 
| small\$1threshold |  要执行加权的更新比率可以取的最小值，低于该值时规则将返回 `True`。 **可选** 有效值：浮点值 默认值：`0.00000001`  | 
| epsilon |  一个小常量，用于确保 Debugger 在计算加权的更新比率时不会被零除。 **可选** 有效值：浮点值 默认值：`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"
                } 
            )
        ]
    )
]
```

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
此规则对 XGBoost 算法不可用。

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

此规则检测张量中的全部值还是指定百分比的值为零。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。必须指定 `collection_names` 或 `tensor_regex` 参数。如果指定了这两个参数，则规则将检查两个集合内张量的并集。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

AllZero 的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：`None`  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：`None`  | 
| threshold |  指定张量中必须为零才能调用此规则的值的百分比。 **可选** 有效值：浮点值 默认值：100（百分比）  | 

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

此规则用于衡量分类之间的采样不平衡，如果不平衡状况超过阈值，或者由于不平衡而导致代表性不足的分类发生太多错误预测，则会引发错误。

分类模型需要训练数据集内的分类保持良好平衡，或者在训练期间对分类执行适当的加权/取样。该规则执行以下检查：
+  它计算每个分类的发生次数。如果最小分类和最大分类之间的样本数比率大于 `threshold_imbalance`，则会引发错误。
+  它检查每个分类的预测精度。如果未正确应用重采样或加权，则模型对于具有许多训练样本的分类来说可以达到较高的精度，但对于训练样本少的分类来说，精度较低。如果某个分类的错误预测比例大于 `threshold_misprediction`，则会引发错误。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

ClassImbalance 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| threshold\$1imbalance |  最小分类和最大分类中样本数之间可接受的不平衡。超过此阈值会引发错误。 **可选** 有效值：浮点值 默认值：`10`  | 
| threshold\$1misprediction |  对每个分类允许的错误预测部分的限制。超过此阈值会引发错误。代表性不足的分类最有可能超过此阈值。 **可选** 有效值：浮点值 默认值：`0.7`  | 
| samples |  在评估不平衡之前必须处理的标签数。在多个步骤中看到足够的样本之前，可能不会触发该规则。数据集包含的分类越多，此 `sample` 数值应越大。 **可选** 有效值：整数 默认值：`500`（假设像 MNIST 这样的数据集有 10 个类）  | 
| argmax |  如果为 `True`，则 [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) 应用于预测张量。当您对每个分类都有概率向量时，此项是必需的。它用于确定哪个分类具有最高概率。 **条件** 有效值：布尔值 默认值：`False`  | 
| labels\$1regex |  包含标签的张量的名称。 **可选** 有效值：字符串 默认值：`".*labels"`  | 
| predictions\$1regex |  包含预测的张量的名称。 **可选** 有效值：字符串 默认值：`".*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>

此规则检测值损失是否以适当的速度减少。这些损失必须是标量。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。必须指定 `collection_names` 或 `tensor_regex` 参数。如果指定了这两个参数，则规则将检查两个集合内张量的并集。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

LossNotDecreasing 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：`None`  | 
| tensor\$1regex |  一个正则表达式模式列表，用于将此比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：`None`  | 
| use\$1losses\$1collection |  如果设置为 `True`，则当名为“losses”的集合存在时，查找该集合中的损失。 **可选** 有效值：布尔值 默认值：`True`  | 
| num\$1steps |  该规则检查损失是否已减少的最小步骤数。规则评估每 `num_steps` 个步骤发生一次。该规则将此步骤的损失与至少比当前步骤落后 `num_steps` 的步骤的损失进行比较。例如，假设每三个步骤保存一次损失，但 `num_steps` 设置为 10。在步骤 21 中，将步骤 21 的损失与步骤 9 的损失进行比较。检查损失的下一个步骤是步骤 33，因为步骤 21 之后的第十个步骤是步骤 31，并且在步骤 31 和步骤 32 中不保存损失。 **可选** 有效值：整数 默认值：`10`  | 
| diff\$1percent |  在 `num_steps` 个步骤之间，损失应减少的最小百分比差异。 **可选** 有效值：`0.0` < 浮点值 < `100` 默认值：`0.1`（百分比）  | 
| increase\$1threshold\$1percent |  在损失一直在增加的情况下，允许损失增加的最大阈值百分比 **可选** 有效值：`0` < 浮点值 < `100` 默认值：`5`（百分比）  | 
| mode |  用于查询张量值以进行规则检查的 Debugger 模式的名称。如果未传递该参数，规则默认按顺序进行检查，先检查 `mode.EVAL`，然后检查 `mode.TRAIN`，最后检查 `mode.GLOBAL`。 **可选** 有效值：字符串（`EVAL`、`TRAIN` 或 `GLOBAL`） 默认值：`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>

此规则通过比较验证和训练损失来检测模型是否与训练数据过度拟合。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
防止过度拟合的标准方法是对模型进行规范化。

Overfit 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：无  | 
| start\$1step |  开始比较验证和训练损失的步骤。 **可选** 有效值：整数 默认值：`0`  | 
| patience |  在模型被视为过度拟合之前允许 `ratio_threshold` 超过设置的值的步数。 **可选** 有效值：整数 默认值：`1`  | 
| ratio\$1threshold |  平均验证损失和平均训练损失之间的差异与平均训练损失的最大比率。如果 `patience` 个步骤超过此阈值，则表示模型过度拟合，并且规则返回 `True`。 **可选** 有效值：浮点值 默认值：`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>

此规则检测模型是否过度训练。在对行为良好的模型进行了多次训练迭代（训练和验证损失均减少）之后，模型接近损失函数的最低限度，并且不再改善。如果模型继续训练，则可能会发生验证损失开始增加的情况，因为模型开始过度拟合。此规则设置阈值和条件，以确定模型是否没有改进，并防止由于过度训练导致的过度拟合问题。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

**注意**  
可以通过提前停止来避免过度训练。有关提前停止的信息，请参阅[提前停止训练作业](automatic-model-tuning-early-stopping.md)。有关演示如何对 Debugger 使用竞价型实例训练的示例，请参阅[对 Amazon SageMaker Debugger 启用竞价型实例训练](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html)。

Overtraining 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| patience\$1train |  在认为训练损失不再有改进之前等待的步骤数。 **可选** 有效值：整数 默认值：`5`  | 
| patience\$1validation | 在认为验证损失不再有改进之前等待的步骤数。**可选**有效值：整数默认值：`10` | 
| delta |  误差被视为新的最佳值之前应改进的误差程度的最小阈值。 **可选** 有效值：浮点值 默认值：`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>

此规则将从基本试验中收集的张量与从另一试验中收集的张量进行比较。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

SimilarAcrossRuns 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| other\$1trials |  已完成的训练作业名称，您需要将其张量与从当前 `base_trial` 收集的张量进行比较。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：无  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：无  | 

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

StalledTrainingRule 检测训练作业是否没有进展，如果规则触发，则停止训练作业。此规则要求按照其 `threshold` 参数定义的时间间隔定期保存张量。此规则会继续监控新张量，如果没有发出新的张量，将触发阈值间隔规则。

StalledTrainingRule 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| threshold |  定义规则等待张量输出时间长度（以秒为单位）的阈值，超过该值后会触发停滞训练问题。默认值为 1800 秒。 **可选** 有效值：整数 默认值：`1800`  | 
| stop\$1training\$1on\$1fire |  如果设置为 `True`，则监视基础训练作业是否在“`threshold`”秒内输出张量。 **可选** 有效值：布尔值 默认值：`False`  | 
| training\$1job\$1name\$1prefix |  基础训练作业名称的前缀。如果 `stop_training_on_fire` 为 true，则该规则将在相同账户中搜索带有此前缀的 SageMaker 训练作业。如果发现不活动状态，则规则执行 `StopTrainingJob` 操作。请注意，如果找到多个具有相同前缀的作业，则规则将跳过终止。因此务必要为每个训练作业设置唯一的前缀。 **可选** 有效值：字符串  | 

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

该规则检测您是否具有方差非常高或非常低的张量。张量中的非常高或非常低的方差可能会导致神经元饱和，从而降低神经网络的学习能力。张量非常高的方差最终还会产生张量爆炸问题。使用此规则可以提前检测出此类问题。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。必须指定 `collection_names` 或 `tensor_regex` 参数。如果指定了这两个参数，则规则将检查两个集合内张量的并集。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

TensorVariance 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：无  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：无  | 
| max\$1threshold |  张量方差上限的阈值。 **可选** 有效值：浮点值 默认值：无  | 
| min\$1threshold |  张量方差下限的阈值。 **可选** 有效值：浮点值 默认值：无  | 

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

此规则检测张量是否不再随步骤而发生更改。

此规则运行 [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) 方法来检查张量是否未发生更改。

此规则可应用于受支持的深度学习框架（TensorFlow、MXNet 和 PyTorch）之一，也可以应用于 XGBoost 算法。必须指定 `collection_names` 或 `tensor_regex` 参数。如果指定了这两个参数，则规则将检查两个集合内张量的并集。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

UnchangedTensor 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| collection\$1names |  该规则检查其张量的集合名称列表。 **可选** 有效值：字符串列表或逗号分隔的字符串 默认值：无  | 
| tensor\$1regex |  正则表达式模式列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：无  | 
| num\$1steps |  该规则检查以确定张量是否已更改的步骤数。 规则将检查可用的最后 `num_steps` 个步骤。步骤不必是连续的。如果 `num_steps` 是 2，则在第 s 个步骤处，规则不一定检查第 s-1 个步骤和第 s 个步骤。如果第 s-1 个步骤不可用，规则会检查最后一个可用步骤以及第 s 个步骤。在这种情况下，规则会检查最后一个可用步骤及当前步骤。 **可选** 有效值：整数 默认值：`3`  | 
| rtol |  要传递给 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法的相对容差参数。 **可选** 有效值：浮点值 默认值：`1e-05`  | 
| atol |  要传递给 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法的绝对容差参数。 **可选** 有效值：浮点值 默认值：`1e-08`  | 
| equal\$1nan |  比较 NaN 时是否视为相等。如果为 `True`，则在输出数组中将输入数组 a 中的 NaN 视为等于输入数组 b 中的 NaN。此参数传递给 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法。 **可选** 有效值：布尔值 默认值：`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>

此规则检查输入图像是否已正确归一化。具体而言，规则会检测样本数据的平均值与零之间的差异是否超过阈值。许多计算机视觉模型要求输入数据的平均值和单位方差为零。

此规则适用于深度学习应用程序。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

CheckInputImages 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| threshold\$1mean |  一个阈值，该阈值定义输入数据的平均值可以与 0 相差多少。 **可选** 有效值：浮点值 默认值：`0.2`  | 
| threshold\$1samples |  在引发错误之前必须采样的图像数量。如果值过低，则对数据集平均值的估计将不准确。 **可选** 有效值：整数 默认值：`500`  | 
| regex |  输入数据张量的名称。 **可选** 有效值：字符串 默认值：`".*hybridsequential0_input_0"`（使用 HybridSequential 的 Apache MXNet 模型的输入张量的名称）  | 
| channel |  颜色通道在输入张量形状数组中的位置。 **可选** 有效值：整数 默认值：`1`（例如，MXNet 需要输入数据采用以下形式：(batch\$1size, channel, height, width)  | 

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

给定其余输入序列（对于优化性能很有用）的情况下，此规则将计算特定令牌的比率。例如，您可以计算输入序列中填充句尾 (EOS) 令牌的百分比。如果 EOS 令牌数量过高，则应执行替代分桶策略。您还可以计算输入序列中未知令牌的百分比。如果未知单词的数量过高，可以使用替代词汇表。

此规则适用于深度学习应用程序。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

NLPSequenceRatio 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| tensor\$1regex |  正则表达式规律列表，用于将该比较限制为特定的标量值张量。该规则仅检查与列表中指定的正则表达式规律匹配的张量。如果未传递任何规律，则该规则默认情况下比较试验中收集的所有张量。只能匹配标量值张量。 **可选** 有效值：字符串列表或逗号分隔的字符串  默认值：`".*embedding0_input_0"`（假设作为网络的初始层嵌入）  | 
| token\$1values |  一个由令牌数值列表构成的字符串。例如，"3, 0"。 **可选** 有效值：以逗号分隔的数值字符串 默认值：`0`  | 
| token\$1thresholds\$1percent |  一个字符串，由与 `token_values` 的每个令牌对应的阈值（以百分比为单位）列表构成。例如，"50.0, 50.0"。 **可选** 有效值：以逗号分隔的浮点值字符串 默认值：`"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>

此规则评估分类问题的混淆矩阵的优点。

它创建一个大小为 `category_no*category_no` 的矩阵，并使用来自 (`labels`, `predictions`) 对的数据填充该矩阵。对于每个 (`labels`, `predictions`) 对，`confusion[labels][predictions]` 中的计数增加 1。当完全填充矩阵后，按以下所示计算数据对角线值和非对角线值的比率：
+ 对于对角线上的元素：`confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ 对于非对角线上的元素：`confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`

此规则可应用于 XGBoost 算法。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

Confusion 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| category\$1no |  类别的数量。 **可选** 有效值：≥2 的整数 默认值：`"None"`  | 
| labels |  `labels` 张量集合或真实标签的一维矢量。 **可选** 有效值：字符串 默认值：`"labels"`  | 
| predictions |  `predictions` 张量集合或估算标签的一维矢量。 **可选** 有效值：字符串 默认值：`"predictions"`  | 
| labels\$1collection |  该规则针对 `labels` 检查此集合中的张量。 **可选** 有效值：字符串 默认值：`"labels"`  | 
| predictions\$1collection |  该规则针对 `predictions` 检查此集合中的张量。 **可选** 有效值：字符串 默认值：`"predictions"`  | 
| min\$1diag |  对角线上数据比率的最小值。 **可选** 有效值：`0` ≤ 浮点值 ≤ `1` 默认值：`0.9`  | 
| max\$1off\$1diag |  对角线以外的数据比率的最大值。 **可选** 有效值：`0` ≤ 浮点值 ≤ `1` 默认值：`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"
                } 
            )
        ]
    )
]
```

**注意**  
如果未指定可选参数的值，则此规则会推断采用默认值。

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

此规则累积每个步骤的 n 个最大特征重要性值的权重，并确保它们不会超过阈值。例如，您可以将前 3 个特征的阈值设置为不超过模型总权重的 80%。

此规则仅对 XGBoost 算法有效。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

FeatureImportanceOverweight 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| threshold |  定义 `n` 个最大特征的累积和占比的阈值。数字 `n` 由 `nfeatures` 参数定义。 **可选** 有效值：浮点值 默认值：`0.8`  | 
| nfeatures |  最大特征的数量。 **可选** 有效值：整数 默认值：`3`  | 
| tensor\$1regex |  规则要分析的张量名称的正则表达式 (regex)。 **可选** 有效值：字符串 默认值：`".*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>

此规则测量 XGBoost 模型中树的深度。如果拆分不能改进损失，则 XGBoost 会拒绝拆分。这会将训练规范化。因此，树的深度可能不会达到 `depth` 参数定义的深度。

此规则仅对 XGBoost 算法有效。

有关如何配置和部署内置规则的示例，请参阅[如何配置 Debugger 内置规则](use-debugger-built-in-rules.md)。

TreeDepth 规则的参数描述


| 参数名称 | 描述 | 
| --- | --- | 
| base\$1trial |  基本试验训练作业名称。Amazon SageMaker Debugger 会自动将此参数设置为当前的训练作业。 **必填** 有效值：字符串  | 
| depth |  树的深度。通过计算最大节点 ID 的以 2 为底的对数，可以获得树的深度。 **可选** 有效值：浮点值 默认值：`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"
                } 
            )
        ]
    )
]
```