本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 偵錯工具內建規則清單
<a name="debugger-built-in-rules"></a>

您可以使用 Amazon SageMaker Debugger 提供的偵錯工具內建規則，來分析訓練模型時收集的指標和張量。以下列出偵錯工具規則，包括如何設定和部署每個內建規則的資訊和範例。

偵錯工具內建規則監控對成功的訓練任務至關重要的各種常見條件。您可以使用 [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) 或低階 SageMaker API 作業來呼叫內建規則。

使用內建規則無需額外付費。如需帳單的更多相關資訊，請參閱 [Amazon SageMaker 定價](https://aws.amazon.com/sagemaker/pricing/)頁面。

**注意**  
您可以連接到訓練任務的內建規則數量上限為 20。SageMaker 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)
```

## 偵錯工具規則
<a name="debugger-built-in-rules-Rule"></a>

下列規則是可使用 `Rule.sagemaker` 類別方法呼叫的 Debugger 內建規則。

適用於產生訓練報告的偵錯工具內建規則


| 有效性範圍 | 內建規則 | 
| --- | --- | 
| SageMaker AI XGBoost 訓練任務的訓練報告 |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

適用於偵錯模型訓練資料 (輸出張量) 的偵錯工具內建規則


| 有效性範圍 | 內建規則 | 
| --- | --- | 
| 深度學習架構 (TensorFlow、MXNet 和 PyTorch) |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| 深度學習框架 (TensorFlow、MXNet 和 PyTorch) 及 XGBoost 演算法  |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| 深度學習應用程式 |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| XGBoost 演算法 |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/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-built-in-rules-example.md#debugger-deploy-built-in-rules)。
+ 如需關於將內建規則與低階 SageMaker API 作業搭配使用的完整指示，請參閱[使用 SageMaker API 設定 Debugger](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\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 

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

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

此規則偵測試驗中一定百分比的修正線性單元 (ReLU) 啟動函式，因為其啟動活動低於臨界值，而視為失效。如果某層的非作用中 ReLU 百分比大於非作用中 ReLU 的 `threshold_layer` 值，此規則會傳回 `True`。

DeadRelu 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：`".*relu_output"` | 
| threshold\_inactivity | 定義將 ReLU 視為失效的最低活動等級。ReLU 可能在試驗開始時很活躍，然後在訓練過程中慢慢失效。如果 ReLU 活躍程度低於 `threshold_inactivity`，則視為失效。<br />**選用**<br />有效值：浮點數<br />預設值：`1.0` (以百分比表示) | 
| threshold\_layer | 如果某層的非作用中 ReLU 百分比大於 `threshold_layer`，則傳回 `True`。<br />如果某層的非作用中 ReLU 百分比小於 `threshold_layer`，則傳回 `False`。<br />**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
此規則不適用於 XGBoost 演算法。

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

此規則偵測訓練期間發出的張量是否具有非限定值，即無限或 NaN (不是數字)。如果偵測到非限定值，此規則會傳回 `True`。

ExplodingTensor 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串<br />預設值：`None` | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串 <br />預設值：`None` | 
| only\_nan |  `True` 僅監控 `base_trial` 張量的 `NaN` 值，不監控無窮大。<br />`False` 將 `NaN` 和無窮大視為爆炸值，並監控兩者。<br />**選用**<br />預設值：`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}}"
                }
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
此規則不適用於 XGBoost 演算法。

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

 此規則偵測您的模型參數初始化是否不佳。

良好的初始化會打破神經網路中的權重和梯度的對稱性，並保持各層之間相稱的啟動變異。否則，神經網路無法有效地學習。像 Xavier 這樣的初始器旨在保持啟動之間的變異固定，這對於訓練非常深的神經網路尤其重要。初始化過小可能導致梯度消失。初始化過大可能導致梯度爆炸。此規則檢查各層之間啟動輸入的變異、梯度分佈，以及初始步驟的損失收斂，以判斷神經網路的初始化是否不佳。

PoorWeightInitialization 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| activation\_inputs\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串<br />預設值：`".*relu_input"` | 
| threshold | 如果每層的權重最小與最大變異之間的比率超過一個步驟的 `threshold`，此規則會傳回 `True`。<br />**選用**<br />有效值：浮點數<br />預設值：`10.0` | 
| distribution\_range | 如果梯度分佈的第 5 個和第 95 個百分位數之間的最小差異小於 `distribution_range`，此規則會傳回 `True`。<br />**選用**<br />有效值：浮點數<br />預設值：`0.001` | 
| patience | 直到認為損失不再減少為止所需等待的步驟數。<br />**選用**<br />有效值：整數<br />預設值：`5` | 
| steps | 此規則分析的步驟數。您通常只需要檢查最初幾次反覆運算。<br />**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
此規則不適用於 XGBoost 演算法。

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

此規則偵測雙曲正切和 S 形啟動層是否變得飽和。當某層的輸入接近啟動函式的最大值或最小值時，啟動層即飽和。雙曲正切和 S 形啟動函式的最小值和最大值由各自的 `min_threshold` 和 `max_thresholds` 值定義。如果節點的活動低於 `threshold_inactivity` 百分比，則視為飽和。如果超過 `threshold_layer` 百分比的節點飽和，此規則會傳回 `True`。

SaturatedActivation 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：NONE | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串 <br />預設值：`".*tanh_input\|.*sigmoid_input".` | 
| threshold\_tanh\_min | 最小與最大臨界值，定義雙曲正切啟動函式的輸入極端值，定義如下：`(min_threshold, max_threshold)`。預設值是根據 0.0000001 的梯度消失臨界值決定。<br />**選用**<br />有效值：浮點數<br />預設值：`-9.4999` | 
| threshold\_tanh\_max | 最小與最大臨界值，定義雙曲正切啟動函式的輸入極端值，定義如下：`(min_threshold, max_threshold)`。預設值是根據 0.0000001 的梯度消失臨界值決定。<br />**選用**<br />有效值：浮點數<br />預設值：`9.4999` | 
| threshold\_sigmoid\_min | 最小與最大臨界值，定義 S 形啟動函式的輸入極端值，定義如下：`(min_threshold, max_threshold)`。預設值是根據 0.0000001 的梯度消失臨界值決定。<br />**選用**<br />有效值：浮點數<br />預設值：`-23` | 
| threshold\_sigmoid\_max | 最小與最大臨界值，定義 S 形啟動函式的輸入極端值，定義如下：`(min_threshold, max_threshold)`。預設值是根據 0.0000001 的梯度消失臨界值決定。<br />**選用**<br />有效值：浮點數<br />預設值：`16.99999` | 
| threshold\_inactivity | 將啟動層視為飽和的無活動最低百分比。啟動可能在試驗開始時很活躍，然後在訓練過程中慢慢變得不活躍。<br />**選用**<br />有效值：浮點數<br />預設值：`1.0` | 
| threshold\_layer | 如果某層的飽和啟動數大於 `threshold_layer` 百分比，則傳回 `True`。<br />如果某層的飽和啟動數小於 `threshold_layer` 百分比，則傳回 `False`。<br />**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
此規則不適用於 XGBoost 演算法。

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

此規則偵測試驗中的梯度是否變得非常小，或降到零量級。如果梯度的絕對值平均數低於指定的 `threshold`，此規則會傳回 `True`。

VanishingGradient 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| threshold | 認定梯度消失於此值。**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](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\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| num\_steps | 由規則檢查判斷張量是否已變更的步驟數。<br />您想要比較權重比例的步驟數。如果您未傳遞任何值，依預設會對目前步驟和緊接在前儲存的步驟執行此規則。如果您藉由傳遞此參數的值來覆寫預設值，則會在步驟 `s` 和步驟 `>= s - num_steps` 的權重之間進行比較。<br />**選用**<br />有效值：整數<br />預設值：`None` | 
| large\_threshold | 權重更新比例可達到的最大值，在此之前，規則會傳回 `True`。<br />**選用**<br />有效值：浮點數<br />預設值：`10.0` | 
| small\_threshold | 權重更新比例可達到的最小值，低於此值，規則會傳回 `True`。<br />**選用**<br />有效值：浮點數<br />預設值：`0.00000001` | 
| epsilon | 小常數，用於確保運算權重更新比例時，偵錯工具不會除以零。<br />**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
此規則不適用於 XGBoost 演算法。

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

此規則偵測張量值的全部或已指定百分比是否為零。

此規則可以套用至其中一個支援的深度學習框架 (TensorFlow、MXNet 和 PyTorch) 或 XGBoost 演算法。您必須指定 `collection_names` 或 `tensor_regex` 參數。如果兩個參數都指定，此規則會檢查兩組的張量聯集。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

AllZero 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：`None` | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：`None` | 
| threshold | 指定張量中必須為零的值百分比，才能調用此規則。<br />**選用**<br />有效值：浮點數<br />預設值：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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

ClassImbalance 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| threshold\_imbalance | 在最小類別和最大類別的樣本數之間可接受的不平衡。超過此臨界值會擲回錯誤。<br />**選用**<br />有效值：浮點數<br />預設值：`10` | 
| threshold\_misprediction | 每個類別允許的預測失誤比例的限制。超過此臨界值會擲回錯誤。不具代表性的類別最有可能越過此臨界值。<br />**選用**<br />有效值：浮點數<br />預設值：`0.7` | 
| samples | 評估不平衡之前必須處理的標籤數目。此規則直到在數個步驟中看到足夠的樣本才會觸發。資料集包含的類別越多，這個 `sample` 數字就越大。<br />**選用**<br />有效值：整數<br />預設值：`500` (假設像 MNIST 這樣的資料集有 10 個類別) | 
| argmax | 如果 `True`，[np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) 會套用至預測張量。當每個類別有機率向量時，則為必要。用來決定哪個類別有最高機率。<br />**有條件**<br />有效值：布林值<br />預設值：`False` | 
| labels\_regex | 包含標籤的張量名稱。<br />**選用**<br />有效值：字串<br />預設值：`".*labels"` | 
| predictions\_regex | 包含預測的張量名稱。<br />**選用**<br />有效值：字串<br />預設值：`".*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` 參數。如果兩個參數都指定，此規則會檢查兩組的張量聯集。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

LossNotDecreasing 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：`None` | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：`None` | 
| use\_losses\_collection | 如果設為 `True`，則會在名為 "losses" 的集合中尋找損失 (如果此集合存在)。<br />**選用**<br />有效值：布林值<br />預設值：`True` | 
| num\_steps | 此規則檢查損失是否已減少之前所需經過的最少步驟數。規則評估每 `num_steps` 進行一次。此規則在此步驟和落後目前步驟至少 `num_steps` 的步驟上比較損失。例如，假設每三個步驟儲存一次損失，但 `num_steps` 設為 10。在步驟 21，步驟 21 的損失與步驟 9 的損失進行比較。下一個檢查損失的步驟是步驟 33，因為步驟 21 之後再十個步驟就是步驟 31，但步驟 31 和步驟 32 不會儲存損失。<br />**選用**<br />有效值：整數<br />預設值：`10` | 
| diff\_percent | 在 `num_steps` 之間損失應該減少的最小百分比差異。<br />**選用**<br />有效值：`0.0` < 浮點數 < `100`。<br />預設值：`0.1` (以百分比表示) | 
| increase\_threshold\_percent | 在損失增加的情況下，允許增加損失的閾值百分比上限<br />**選用**<br />有效值：`0` < 浮點數 < `100`。<br />預設值：`5` (以百分比表示) | 
| mode | 規則檢查時用於查詢張量值的偵錯工具模式名稱。如果未通過，規則預設會依序檢查 `mode.EVAL`、`mode.TRAIN`、`mode.GLOBAL`。<br />**選用**<br />有效值：字串 (`EVAL`、`TRAIN` 或 `GLOBAL`)<br />預設值：`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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
防止過度擬合的標準方法是將模型規範化。

Overfit 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：NONE | 
| start\_step | 開始比較驗證和訓練損失的起始步驟。<br />**選用**<br />有效值：整數<br />預設值：`0` | 
| patience | 將模型視為過度擬合之前，允許 `ratio_threshold` 超過設定值的步驟數。<br />**選用**<br />有效值：整數<br />預設值：`1` | 
| ratio\_threshold | 平均驗證損失與平均訓練損失之間的差異佔平均訓練損失的最大比例。如果 `patience` 步驟數超過此臨界值，表示模型過度擬合，此規則會傳回 `True`。<br />**選用**<br />有效值：浮點數<br />預設值：`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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

**注意**  
可提早停止以避免訓練過度。如需提早停止的相關資訊，請參閱[提前停止訓練任務](automatic-model-tuning-early-stopping.md)。如需示範如何將 Spot 訓練與偵錯工具搭配使用的範例，請參閱[以 Amazon SageMaker Debugger 啟用 Spot 訓練](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html)。

Overtraining 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| patience\_train | 認定訓練損失已不再改善之前等待的步驟數。<br />**選用**<br />有效值：整數<br />預設值：`5` | 
| patience\_validation | 認定驗證損失已不再改善之前等待的步驟數。**選用**<br />有效值：整數<br />預設值：`10` | 
| delta | 應該改善多少誤差才視為新的最佳結果之前的最小臨界值。<br />**選用**<br />有效值：浮點數<br />預設值：`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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

SimilarAcrossRuns 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| other\_trials | 已完成的訓練任務名稱，您想要將其張量與從目前 `base_trial` 收集的張量進行比較。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：NONE | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：NONE | 

```
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\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| threshold | 一種閾值，定義規則等待張量輸出的時間 (以秒為單位)，直到觸發已停止的訓練問題為止。預設值為 1800 秒。<br />**選用**<br />有效值：整數<br />預設值：`1800` | 
| stop\_training\_on\_fire | 如果設定為 `True`，則監看基礎訓練任務是否在 "`threshold`" 秒內輸出張量。<br />**選用**<br />有效值：布林值<br />預設值：`False` | 
| training\_job\_name\_prefix | 基礎訓練任務名稱的字首。如果 `stop_training_on_fire` 為是，則規則會在相同帳戶中搜尋具有此字首的 SageMaker 訓練任務。如果找到非作用中的情況，則規則會採取 `StopTrainingJob` 動作。請注意，如果找到多個具有相同字首的工作，則規則會略過終止。重要的是，為每個訓練任務設定唯一的字首。<br />**選用**<br />有效值：字串 | 

```
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` 參數。如果兩個參數都指定，此規則會檢查兩組的張量聯集。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

TensorVariance 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：NONE | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：NONE | 
| max\_threshold | 張量變異上限的臨界值。<br />**選用**<br />有效值：浮點數<br />預設值：NONE | 
| min\_threshold | 張量變異下限的臨界值。<br />**選用**<br />有效值：浮點數<br />預設值：NONE | 

```
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` 參數。如果兩個參數都指定，此規則會檢查兩組的張量聯集。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

UnchangedTensor 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| collection\_names | 由規則檢查張量的集合名稱清單。<br />**選用**<br />有效值：字串清單或逗號分隔的字串<br />預設值：NONE | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：NONE | 
| num\_steps | 由規則檢查判斷張量是否已變更的步驟數。<br />這會檢查最後可用的 `num_steps`。不需要連續。如果 `num_steps` 是 2，則在步驟 s 不一定要檢查 s-1 和 s。如果沒有 s-1，則會檢查除了 s 之外最後可用的步驟。在這種情況下，將會檢查包括目前步驟在內的最後可用步驟。<br />**選用**<br />有效值：整數<br />預設值：`3` | 
| rtol | 要傳遞給 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法的相對公差參數。<br />**選用**<br />有效值：浮點數<br />預設值：`1e-05` | 
| atol | 要傳遞給 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法的絕對公差參數。<br />**選用**<br />有效值：浮點數<br />預設值：`1e-08` | 
| equal\_nan | 是否將 NaN 比作相等。如果 `True`，輸入陣列 a 中的 NaN 視為等於輸出陣列中輸入陣列 b 中的 NaN。此參數會傳遞給 `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` 方法。<br />**選用**<br />有效值：布林值<br />預設值：`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>

此規則檢查輸入影像是否已正確標準化。具體來說，此規則會偵測樣本資料的平均值與零相差是否大於一個臨界值。許多電腦視覺模型要求輸入資料具有零平均值和單位變異。

此規則適用於深度學習應用程式。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

CheckInputImages 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| threshold\_mean | 此臨界值定義輸入資料的平均值可以與 0 相差的程度。<br />**選用**<br />有效值：浮點數<br />預設值：`0.2` | 
| threshold\_samples | 擲回錯誤之前必須取樣的影像數量。如果值太低，資料集平均值的估計會不準確。<br />**選用**<br />有效值：整數<br />預設值：`500` | 
| regex | 輸入資料張量的名稱。<br />**選用**<br />有效值：字串<br />預設值：`".*hybridsequential0_input_0"` (使用 HybridSequential 的 Apache MXNet 模型的輸入張量名稱) | 
| channel | 輸入張量形狀陣列中顏色頻道的位置。<br />**選用**<br />有效值：整數<br />預設值：`1` (例如，MXNet 需要 (batch\_size, 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 符記數量過高，則應該執行替代的分桶策略。您還可以計算輸入序列中未知符記的百分比。如果未知單字的數量過高，可以使用替代字彙。

此規則適用於深度學習應用程式。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

NLPSequenceRatio 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| tensor\_regex | Regex 模式清單，用於將這項比較限定於特定的純量值張量。此規則只檢查與清單中指定的 Regex 模式相符的張量。如果未傳遞模式，此規則依預設會比較試驗中收集的所有張量。只能比對純量值張量。<br />**選用**<br />有效值：字串清單或逗號分隔的字串 <br />預設值：`".*embedding0_input_0"` (假設內嵌為網路的初始層) | 
| token\_values | 符記的數值清單字串。例如，"3, 0"。<br />**選用**<br />有效值：以逗號分隔的數值字串<br />預設值：`0` | 
| token\_thresholds\_percent | 對應於每個 `token_values` 的臨界值清單字串 (以百分比表示)。例如，"50.0, 50.0"。<br />**選用**<br />有效值：以逗號分隔的浮點數字串<br />預設值：`"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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

Confusion 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| category\_no | 類別的數目。<br />**選用**<br />有效值：整數 ≥2<br />預設值：`"None"` | 
| labels | `labels` 張量集合或真實標籤的 1-d 向量。<br />**選用**<br />有效值：字串<br />預設值：`"labels"` | 
| predictions | `predictions` 張量集合或預估標籤的 1-d 向量。<br />**選用**<br />有效值：字串<br />預設值：`"predictions"` | 
| labels\_collection | 此規則檢查此 `labels` 集合中的張量。<br />**選用**<br />有效值：字串<br />預設值：`"labels"` | 
| predictions\_collection | 此規則檢查此 `predictions` 集合中的張量。<br />**選用**<br />有效值：字串<br />預設值：`"predictions"` | 
| min\_diag | 對角線資料比例的閾值下限。<br />**選用**<br />有效值：`0`≤浮動≤`1`<br />預設值：`0.9` | 
| max\_off\_diag | 非對角線資料比例的閾值上限。<br />**選用**<br />有效值：`0`≤浮動≤`1`<br />預設值：`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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

FeatureImportanceOverweight 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| threshold | 定義 `n` 最大功能之累積總和比例的閾值。數字 `n` 由 `nfeatures` 參數定義。<br />**選用**<br />有效值：浮點數<br />預設值：`0.8` | 
| nfeatures | 最大功能的數量。<br />**選用**<br />有效值：整數<br />預設值：`3` | 
| tensor\_regex | 張量的規則表達式 (regex) 命名要分析的規則。<br />**選用**<br />有效值：字串<br />預設值：`".*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 演算法。

如需如何設定和部署內建規則的範例，請參閱[如何設定偵錯工具內建規則](use-debugger-built-in-rules.md)。

TreeDepth 規則的參數描述


| 參數名稱 | 描述 | 
| --- | --- | 
| base\_trial | 基礎試驗訓練任務名稱。此參數會由 Amazon SageMaker Debugger 自動設定為目前的訓練任務。<br />**必要**<br />有效值：字串 | 
| depth | 樹狀的深度。計算最大節點 ID 的基數 2 對數可得到樹狀的深度。<br />**選用**<br />有效值：浮點數<br />預設值：`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}}"
                } 
            )
        ]
    )
]
```