Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Liste der in den Debugger integrierten Regeln
<a name="debugger-built-in-rules"></a>

Sie können anhand der in den Debugger integrierten Regeln, die von Amazon SageMaker Debugger bereitgestellt werden, Kennzahlen und Tensoren analysieren, die beim Training Ihrer Modelle gesammelt wurden. Im Folgenden sind die Debugger-Regeln aufgeführt, einschließlich Informationen und eines Beispiels zur Konfiguration und Bereitstellung der einzelnen integrierten Regeln.

Die in den Debugger integrierten Regeln überwachen verschiedene häufige Bedingungen, die für den Erfolg eines Trainings-Jobs entscheidend sind. Die integrierten Regeln können Sie mithilfe der [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) oder der Low-Level-SageMaker-API-Operationen aufrufen. 

Für die Nutzung der integrierten Regeln fallen keine zusätzlichen Kosten an. Weitere Informationen zur Fakturierung finden Sie unter [Amazon SageMaker – Preise](https://aws.amazon.com/sagemaker/pricing/).

**Anmerkung**  
Die maximale Anzahl integrierter Regeln, die Sie einem Training-Job zuordnen können, beträgt 20. Der SageMaker Debugger verwaltet die integrierten Regeln vollständig und analysiert synchron Ihren Training-Job.

**Wichtig**  
Um die neuen Debugger-Features nutzen zu können, müssen Sie das SageMaker Python SDK und die SMDebug-Client-Bibliothek erweitern. Führen Sie in Ihrer IPython-Kernel-, Jupyter-Notebook- oder JupyterLab-Umgebung den folgenden Code aus, um die aktuellen Versionen der Bibliotheken zu installieren, und starten Sie den Kernel neu.  

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

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

Die folgenden Regeln sind die in den Debugger integrierten Regeln, die mit der Klassenmethode `Rule.sagemaker` aufgerufen werden können.

In den Debugger integrierte Regeln zum Erzeugen von Trainingsberichten


| Gültigkeitsbereich | Integrierte Regeln | 
| --- | --- | 
| Trainingsbericht für den Trainingsjob in SageMaker AI XGBoost |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

In den Debugger integrierte Regeln zum Debuggen von Modelltrainingsdaten (Ausgabetensoren)


| Gültigkeitsbereich | Integrierte Regeln | 
| --- | --- | 
| Deep-Learning-Frameworks (TensorFlow, Apache MXNet und PyTorch) |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Deep-Learning-Frameworks (TensorFlow, MXNet und PyTorch) und der XGBoost-Algorithmus  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Deep-Learning-Anwendungen |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| XGBoost-Algorithmus |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

**Um die integrierten Regeln mit Standardparameterwerten zu verwenden**, verwenden Sie das folgende Konfigurationsformat:

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

**Um die integrierten Regeln mit individuellen Parameterwerten zu verwenden**, verwenden Sie das folgende Konfigurationsformat:

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

Die verfügbaren Schlüssel für den Parameter `rule_parameters` finden Sie in den Tabellen mit den Parameterbeschreibungen.

Unter den Tabellen mit den Parameterbeschreibungen finden Sie für jede integrierte Regel Beispielkonfigurationscodes.
+ Eine vollständige Anleitung und Beispiele für die Verwendung der in den Debugger integrierten Regeln finden Sie unter [Beispielcode für integrierte Debugger-Regeln](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Eine vollständige Anleitung zur Verwendung der integrierten Regeln mit den SageMaker-API-Operationen auf niedriger Ebene finden Sie unter [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md).

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

Die Regel CreateXGBoostReport sammelt Ausgabetensoren aus einem XGBoost-Training-Job und erzeugt automatisch einen umfassenden Trainingsbericht. Sie können einen umfassenden Profilerstellungsbericht herunterladen, während ein Training-Job ausgeführt wird oder nachdem der Training-Job abgeschlossen ist, und den Trainingsfortschritt oder das Endergebnis des Training-Jobs überprüfen. Die Regel CreateXGBoostReport erfasst standardmäßig die folgenden Ausgabetensoren: 
+ `hyperparameters`– Speichert beim ersten Schritt
+ `metrics`– Speichert Verlust und Genauigkeit alle 5 Schritte
+ `feature_importance`– Speichert alle 5 Schritte
+ `predictions`– Speichert alle 5 Schritte
+ `labels`– Speichert alle 5 Schritte

Parameterbeschreibungen für die Regel CreateXgboostReport


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String  | 

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

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

Diese Regel erkennt, wenn der Prozentsatz der Aktivierungsfunktionen für die berichtigte lineare Einheit (ReLU) in einer Testversion als tot angesehen wird, da ihre Aktivierungsaktivität einen bestimmten Schwellenwert unterschritten hat. Wenn der Prozentsatz der inaktiven ReLUs in einer Ebene größer ist als der `threshold_layer`-Wert inaktiver ReLUs, gibt die Regel `True` zurück.

Parameterbeschreibungen für die DeadRelu-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: `".*relu_output"`  | 
| threshold\$1inactivity |  Definiert einen Aktivitätsgrad, unter dem ein ReLU als tot angesehen wird. Ein ReLU kann zu Beginn einer Testphase aktiv sein und dann während des Trainings langsam inaktiv werden. Wenn das ReLU weniger aktiv ist als der `threshold_inactivity`, gilt es als tot. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `1.0` (in Prozent)  | 
| threshold\$1layer |  Gibt `True` zurück, wenn der Prozentsatz der inaktiven ReLUs in einer Ebene größer als `threshold_layer` ist. Gibt `False` zurück, wenn der Prozentsatz der inaktiven ReLUs in einer Ebene kleiner als `threshold_layer` ist. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `50.0` (in Prozent)  | 

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

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

Diese Regel erkennt, ob die während des Trainings ausgegebenen Tensoren unendliche Werte aufweisen, entweder unendlich oder NaN (keine Zahl). Wenn ein nicht endlicher Wert erkannt wird, gibt die Regel `True` zurück.

Parameterbeschreibungen für die ExplodingTensor-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Zulässige Werte: String Standardwert: `None`  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String  Standardwert: `None`  | 
| only\$1nan |   `True`, um die `base_trial`-Tensoren nur auf `NaN`-Werte und nicht auf Unendlichkeit zu überwachen.  `False`, um sowohl `NaN` als auch Unendlichkeit als explodierende Werte zu behandeln und beide zu überwachen. **Optional** Standardwert: `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"
                }
            )
        ]
    )
]
```

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

 Diese Regel erkennt, ob die Modellparameter schlecht initialisiert wurden. 

Eine gute Initialisierung unterbricht die Symmetrie der Gewichte und Gradienten in einem neuronalen Netzwerk und behält die angemessenen Aktivierungsvarianzen über Ebenen hinweg bei. Andernfalls lernt das neuronale Netzwerk nicht effektiv. Initialisierer wie Xavier zielen darauf ab, die Varianz über Aktivierungen hinweg konstant zu halten, was besonders für das Training sehr tiefer neuronaler Netze relevant ist. Eine zu kleine Initialisierung kann zu verschwindenden Gradienten führen. Eine zu große Initialisierung kann zu explodierenden Gradienten führen. Diese Regel überprüft die Varianz der Aktivierungseingänge über Ebenen hinweg, die Verteilung der Gradienten und die Verlustkonvergenz für die ersten Schritte, um festzustellen, ob ein neuronales Netzwerk schlecht initialisiert wurde.

Parameterbeschreibungen für die PoorWeightInitialization-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| activation\$1inputs\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String Standardwert: `".*relu_input"`  | 
| threshold |  Wenn das Verhältnis zwischen minimaler und maximaler Varianz der Gewichtungen pro Ebene die `threshold` bei einem Schritt überschreitet, gibt die Regel `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10.0`  | 
| distribution\$1range |  Wenn die Mindestdifferenz zwischen dem 5. und dem 95. Perzentil der Gradientenverteilung kleiner ist als der `distribution_range`, gibt die Regel `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.001`  | 
| patience |  Die Anzahl der Schritte, über die hinweg gewartet werden soll, bis der Verlust als nicht mehr abnehmend betrachtet wird. **Optional** Gültige Werte: Ganzzahl Standardwert: `5`  | 
| steps |  Die Anzahl der Schritte, die diese Regel analysiert. In der Regel müssen Sie nur die ersten paar Iterationen überprüfen. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `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"
                } 
            )
        ]
    )
]
```

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

Diese Regel erkennt, ob die Tanh- und Sigmoid-Aktivierungsebenen gesättigt werden. Eine Aktivierungsschicht ist gesättigt, wenn die Eingabe der Schicht nahe dem Maximum oder Minimum der Aktivierungsfunktion liegt. Das Minimum und Maximum der Tanh- und Sigmoid-Aktivierungsfunktionen werden durch ihre jeweiligen – `min_threshold`und `max_thresholds`-Werte definiert. Wenn die Aktivität eines Knotens unter den `threshold_inactivity`-Prozentsatz fällt, gilt er als gesättigt. Wenn mehr als ein `threshold_layer`-Prozent der Knoten gesättigt sind, gibt die Regel `True` zurück.

Parameterbeschreibungen für die SaturatedActivation-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String  Standardwert: `".*tanh_input\|.*sigmoid_input".`  | 
| threshold\$1tanh\$1min |  Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Tanh-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `-9.4999`  | 
| threshold\$1tanh\$1max |  Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Tanh-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `9.4999`  | 
| threshold\$1sigmoid\$1min |  Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Sigmoid-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `-23`  | 
| threshold\$1sigmoid\$1max |  Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Sigmoid-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `16.99999`  | 
| threshold\$1inactivity |  Der Prozentsatz der Inaktivität, unterhalb dessen die Aktivierungsebene als gesättigt angesehen wird. Die Aktivierung kann zu Beginn einer Testphase aktiv sein und dann langsam während des Trainings weniger aktiv werden. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `1.0`  | 
| threshold\$1layer |  Gibt `True` zurück, wenn die Anzahl der gesättigten Aktivierungen in einer Ebene größer als der `threshold_layer`-Prozentsatz ist. Gibt `False` zurück, wenn die Anzahl der gesättigten Aktivierungen in einer Ebene kleiner als der `threshold_layer`-Prozentsatz ist. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `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"
                } 
            )
        ]
    )
]
```

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

Diese Regel erkennt, ob die Gradients in einer Testversion extrem klein werden oder auf eine Größenordnung von Null abfallen. Wenn der Mittelwert der Absolutwerte der Gradienten unter einen angegebenen `threshold` fällt, gibt die Regel `True` zurück.

Parameterbeschreibungen für die VanishingGradient-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| threshold | Der Wert, ab dem der Gradienten als verschwindend betrachtet wird.**Optional**Gültige Werte: Gleitkommazahl.Standardwert: `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"
                } 
            )
        ]
    )
]
```

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

Diese Regel verfolgt das Verhältnis von Aktualisierungen zu Gewichten während des Trainings und erkennt, ob dieses Verhältnis zu groß oder zu klein wird. Wenn das Verhältnis von Aktualisierungen zu Gewichten größer ist als der `large_threshold value` oder wenn dieses Verhältnis kleiner ist als der `small_threshold`, gibt die Regel `True` zurück.

Die Bedingungen für das Training sind optimal, wenn die Aktualisierungen den Gradienten entsprechen. Übermäßig große Aktualisierungen können dazu führen, dass weniger Gewichte auf optimale Werte fallen, und sehr kleine Aktualisierungen haben eine stark verlangsamte Konvergenz zur Folge. Für diese Regel ist es erforderlich, dass Gewichte für zwei Trainingsschritte zur Verfügung stehen, und `train.save_interval` muss so eingestellt werden, dass es gleich `num_steps` ist.

Parameterbeschreibungen für die WeightUpdateRatio-Regel


| Parametername, | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| num\$1steps |  Die Anzahl der Schritte, über die hinweg die Regel prüft, ob sich der Tensor geändert hat.  Die Anzahl der Schritte, über die Sie die Gewichtsverhältnisse vergleichen möchten. Wenn Sie keinen Wert übergeben, wird die Regel standardmäßig für den aktuellen Schritt und den unmittelbar vorherigen gespeicherten Schritt ausgeführt. Wenn Sie den Standardwert umgehen, indem Sie einen Wert für diesen Parameter übergeben, erfolgt der Vergleich zwischen Gewichten in Schritt `s` und in Schritt `>= s - num_steps`. **Optional** Gültige Werte: Ganzzahl Standardwert: `None`  | 
| large\$1threshold |  Der Maximalwert, den das Verhältnis von Aktualisierungen zu Gewichten erreichen kann, bevor die Regel `True` zurückgibt.  **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10.0`  | 
| small\$1threshold |  Der Mindestwert, den das Verhältnis von Aktualisierungen zu Gewichten erreichen kann, unterhalb dessen die Regel `True` zurückgibt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.00000001`  | 
| epsilon |  Eine kleine Konstante, die sicherstellt, dass der Debugger nicht durch Null teilt, wenn die Berechnung des Verhältnisses auf Gewicht aktualisiert wird. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `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"
                } 
            )
        ]
    )
]
```

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.

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

Diese Regel erkennt, ob alle oder ein bestimmter Prozentsatz der Tensorwerte Null sind.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die AllZero-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None`  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None`  | 
| threshold |  Gibt den Prozentsatz der Werte im Tensor an, der Null sein muss, damit diese Regel aufgerufen wird.  **Optional** Gültige Werte: Gleitkommazahl. Standardwert: 100 (in Prozent)  | 

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

Diese Regel misst Stichprobenungleichgewichte zwischen Klassen und löst Fehler aus, wenn das Ungleichgewicht einen Schwellenwert überschreitet oder wenn aufgrund des Ungleichgewichts zu viele Fehlprognosen für unterrepräsentierte Klassen auftreten.

Klassifizierungsmodelle erfordern ausgewogene Klassen im Trainingsdatensatz oder eine korrekte Gewichtung bzw. Stichprobenahme von Klassen während des Trainings. Die Regel nimmt die folgenden Prüfungen vor:
+  Sie zählt die Vorkommen pro Klasse. Wenn das Verhältnis der Anzahl der Stichproben zwischen kleinster und größter Klasse größer ist als die `threshold_imbalance`, wird ein Fehler ausgelöst.
+  Sie überprüft die Vorhersagegenauigkeit pro Klasse. Wenn Resampling (Stichprobenwiederholung) oder Gewichtung nicht korrekt angewendet wurde, kann das Modell mit vielen Trainingsstichproben eine hohe Genauigkeit für die Klasse erreichen, aber geringe Genauigkeit für die Klassen mit wenigen Trainingsstichproben. Wenn ein Anteil von Fehlvorhersagen für eine bestimmte Klasse `threshold_misprediction` übersteigt, wird ein Fehler ausgelöst.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die ClassImbalance-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| threshold\$1imbalance |  Das akzeptable Ungleichgewicht zwischen der Anzahl der Stichproben in der kleinsten Klasse und in der größten Klasse. Wenn Sie diesen Schwellenwert überschreiten, wird ein Fehler ausgegeben. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10`  | 
| threshold\$1misprediction |  Eine Begrenzung für den Anteil an Fehlvorhersagen, der für jede Klasse zulässig ist. Wenn Sie diesen Schwellenwert überschreiten, wird ein Fehler ausgegeben. Die unterrepräsentierten Klassen sind am meisten gefährdet, diese Schwelle zu überschreiten.  **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.7`  | 
| samples |  Die Anzahl von Labels, die verarbeitet werden müssen, bevor ein Ungleichgewicht ausgewertet wird. Die Regel wird möglicherweise erst ausgelöst, wenn über mehrere Schritte hinweg ausreichende Stichproben angezeigt wurden. Je mehr Klassen Ihr Datensatz enthält, desto größer sollte diese `sample`-Anzahl sein.  **Optional** Gültige Werte: Ganzzahl Standardwert: `500` (unter der Annahme eines Datensatzes wie MNIST mit 10 Klassen)  | 
| argmax |  Wenn `True`, wird [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) auf den Vorhersage-Tensor angewendet. Erforderlich, wenn ein Vektor von Wahrscheinlichkeiten für jede Klasse vorhanden ist. Anhand von ihm wird bestimmt, welche Klasse die höchste Wahrscheinlichkeit hat. **Bedingt** Zulässige Werte: Boolesch Standardwert: `False`  | 
| labels\$1regex |  Der Name des Tensors, der die Labels enthält. **Optional** Zulässige Werte: String Standardwert: `".*labels"`  | 
| predictions\$1regex |  Der Name des Tensors, der die Vorhersagen enthält. **Optional** Zulässige Werte: String Standardwert: `".*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>

Diese Regel erkennt, wenn der Verlust nicht mit einer angemessenen Rate an Wert abnimmt. Diese Verluste müssen Skalare sein. 

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die LossNotDecreasing-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None`  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: `None`  | 
| use\$1losses\$1collection |  Wenn diese Option auf `True` gesetzt ist, wird nach Verlusten in der Sammlung „losses (Verluste)“ gesucht, sofern die Sammlung vorhanden ist. **Optional** Zulässige Werte: Boolesch Standardwert: `True`  | 
| num\$1steps |  Die Mindestanzahl von Schritten, nach denen die Regel prüft, ob der Verlust zurückgegangen ist. Regelauswertung findet alle `num_steps` statt. Die Regel vergleicht den Verlust für diesen Schritt mit dem Verlust bei einem Schritt, der zumindest `num_steps` hinter dem aktuellen Schritt liegt. Angenommen, der Verlust wird alle drei Schritte gespeichert, aber `num_steps` ist auf 10 gesetzt. Bei Schritt 21 wird der Verlust für Schritt 21 mit dem Verlust für Schritt 9 verglichen. Der nächste Schritt, bei dem der Verlust überprüft wird, ist Schritt 33, da zehn Schritte nach Schritt 21 Schritt 31 ist und bei Schritt 31 und Schritt 32 der Verlust nicht gespeichert wird.  **Optional** Gültige Werte: Ganzzahl Standardwert: `10`  | 
| diff\$1percent |  Die minimale prozentuale Differenz, um die sich der Verlust zwischen `num_steps` verringern sollte. **Optional** Gültige Werte: `0.0` < Gleitkommazahl < `100` Standardwert: `0.1` (in Prozent)  | 
| increase\$1threshold\$1percent |  Der maximale prozentuale Schwellenwert, um den sich der Verlust erhöhen darf, falls der Verlust gestiegen ist **Optional** Gültige Werte: `0` < Gleitkommazahl < `100` Standardwert: `5` (in Prozent)  | 
| mode |  Der Name des Debugger-Modus für die Abfrage von Tensorwerten zur Prüfung der Regel. Wenn er nicht übergeben wird, prüft die Regel standardmäßig nacheinander auf `mode.EVAL`, `mode.TRAIN` und dann `mode.GLOBAL`.  **Optional** Gültige Werte: Zeichenfolge (`EVAL`, `TRAIN` oder `GLOBAL`) Standardwert: `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>

Diese Regel erkennt, ob Ihr Modell übermäßig an die Trainingsdaten angepasst ist, indem die Validierungs- und Trainingsverluste miteinander verglichen werden.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Eine Standardmethode, eine Überanpassung zu verhindern, besteht darin, Ihr Modell zu regulieren.

Parameterbeschreibungen für die Overfit-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: Keiner  | 
| start\$1step |  Der Schritt, ab dem Validierung und Trainingsverlust miteinander verglichen werden sollen. **Optional** Gültige Werte: Ganzzahl Standardwert: `0`  | 
| patience |  Die Anzahl der Schritte, für die der `ratio_threshold` den eingestellten Wert überschreiten darf, bevor das Modell als überdimensioniert angesehen wird. **Optional** Gültige Werte: Ganzzahl Standardwert: `1`  | 
| ratio\$1threshold |  Das maximale Verhältnis der Differenz zwischen dem mittleren Validierungsverlust und dem mittleren Trainingsverlust. Wenn dieser Schwellenwert für eine `patience`-Anzahl von Schritten überschritten wird, erfolgt eine Überanpassung des Modells und die Regel gibt `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `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>

Diese Regel erkennt, wenn ein Modell übertrainiert wird. Nach einer Reihe von Trainingsdurchgängen mit einem gut funktionierenden Modell (sowohl der Trainings- als auch der Validierungsverlust nehmen ab) nähert sich das Modell einem Minimum der Verlustfunktion und verbessert sich nicht mehr. Wenn das Modell weiter trainiert wird, kann es vorkommen, dass der Validierungsverlust zunimmt, weil das Modell anfängt, zu starke Anpassungen vorzunehmen. Diese Regel legt Schwellenwerte und Bedingungen fest, um festzustellen, ob sich das Modell nicht mehr verbessert, und verhindert Probleme durch zu starke Anpassungen aufgrund von Übertraining.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

**Anmerkung**  
Overtraining kann durch frühzeitiges Stoppen vermieden werden. Hinweise zum vorzeitigen Beenden finden Sie unter [Vorzeitiges Beenden von Trainingsaufträgen](automatic-model-tuning-early-stopping.md). Ein Beispiel, das zeigt, wie das Spot-Training zusammen mit dem Debugger verwendet wird, finden Sie unter [Spot-Training mit Amazon SageMaker Debugger aktivieren](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html). 

Parameterbeschreibungen für die Overtraining-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| patience\$1train |  Die Anzahl der Schritte, die vor dem Trainingsverlust zu warten sind, soll nicht mehr verbessert werden. **Optional** Gültige Werte: Ganzzahl Standardwert: `5`  | 
| patience\$1validation | Die Anzahl von Schritte, die gewartet werden soll, bis dem Validierungsverlust als sich nicht mehr verbessernd angesehen wird.**Optional**Gültige Werte: GanzzahlStandardwert: `10` | 
| delta |  Die Mindestschwelle, um die sich der Fehler verbessern sollte, bevor er als neues Optimum angesehen wird. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `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>

Diese Regel vergleicht Tensoren, die aus einer Basisversion gesammelt wurden, mit Tensoren aus einer anderen Testversion. 

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die SimilarAcrossRuns-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| other\$1trials |  Der Name eines abgeschlossenen Training-Jobs, dessen Tensoren Sie mit denjenigen Tensoren vergleichen möchten, die aus dem aktuellen `base_trial` erhalten wurden. **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: Keiner  | 

```
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 erkennt, ob bei einem Training-Job keine Fortschritte mehr erzielt werden, und stoppt den Training-Job, wenn die Regel ausgelöst wird. Für diese Regel ist es erforderlich, dass Tensoren regelmäßig in einem Zeitintervall gespeichert werden, das durch ihren Parameter `threshold` festgelegt wird. Diese Regel hält ständig nach neuen Tensoren Ausschau, und wenn kein neuer Tensor für den Schwellenwert ausgegeben wurde, wird die Intervallregel ausgelöst. 

Parameterbeschreibungen für die Regel StalledTrainingRule


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| threshold |  Ein Schwellenwert, der festlegt, wie viel Zeit in Sekunden die Regel auf eine Tensorausgabe wartet, bis ein Problem wegen eines stehengebliebenen Trainings ausgelöst wird. Der Standardwert beträgt 1800 Sekunden. **Optional** Gültige Werte: Ganzzahl Standardwert: `1800`  | 
| stop\$1training\$1on\$1fire |  Falls dieser auf `True` gesetzt ist, wird überwacht, ob der Basis-Training-Job innerhalb von „`threshold`“ Sekunden Tensoren ausgibt. **Optional** Zulässige Werte: Boolesch Standardwert: `False`  | 
| training\$1job\$1name\$1prefix |  Das Präfix des Namens eines Basis-Training-Jobs. Falls `stop_training_on_fire` zutrifft, sucht die Regel im selben Konto nach SageMaker-Training-Jobs mit diesem Präfix. Wenn eine Inaktivität gefunden wird, ergreift die Regel eine `StopTrainingJob` Maßnahme. Beachten Sie, dass die Regel den Abbruch überspringt, wenn mehrere Jobs mit demselben Präfix gefunden wurden. Es ist wichtig, dass das Präfix für jeden Training-Job eindeutig festgelegt wird. **Optional** Zulässige Werte: String  | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.stalled_training_rule(),
        rule_parameters={
                "threshold": "1800",
                "stop_training_on_fire": "True",
                "training_job_name_prefix": "<specify-training-base-job-name>"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                    "save_interval": "500"
                } 
            )
        ]
    )
]
```

## TensorVariance
<a name="tensor-variance"></a>

Diese Regel erkennt, ob Sie Tensoren mit sehr hohen oder niedrigen Varianzen haben. Sehr hohe oder niedrige Abweichungen in einem Tensor könnten zu einer Neuronensättigung führen, wodurch die Lernfähigkeit des neuronalen Netzwerks verringert wird. Eine sehr hohe Varianz in Tensoren kann letztendlich auch zu explodierenden Tensoren führen. Verwenden Sie diese Regel, um solche Probleme frühzeitig zu erkennen.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die TensorVariance-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: Keiner  | 
| max\$1threshold |  Der Schwellenwert für die Obergrenze der Tensorvarianz. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keiner  | 
| min\$1threshold |  Der Schwellenwert für die Untergrenze der Tensorvarianz. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keiner  | 

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

Diese Regel erkennt, ob sich ein Tensor über Schritte hinweg nicht mehr ändert. 

Diese Regel führt die Methode [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) aus, um zu überprüfen, ob sich der Tensor nicht ändert.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die UnchangedTensor-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| collection\$1names |  Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: Keiner  | 
| num\$1steps |  Die Anzahl der Schritte, über die hinweg die Regel prüft, ob sich der Tensor geändert hat.  Hiermit werden die letzten verfügbaren `num_steps` überprüft. Sie müssen nicht aufeinander folgen. Wenn `num_steps` 2 ist, überprüft es bei Schritt „s“ nicht unbedingt auf „s-1“ und „s“. Wenn „s-1“ nicht verfügbar ist, wird der letzte verfügbare Schritt zusammen mit „s“ überprüft. In diesem Fall wird der letzte verfügbare Schritt anhand des aktuellen Schritts überprüft. **Optional** Gültige Werte: Ganzzahl Standardwert: `3`  | 
| rtol |  Der relative Toleranzparameter, der an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben werden soll.  **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `1e-05`  | 
| atol |  Der absolute Toleranzparameter, der an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben werden soll. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `1e-08`  | 
| equal\$1nan |  Ob NaNs als gleichwertig zu vergleichen sind. Bei dem Wert `True` werden NaNs in Eingabe-Array a im Ausgabe-Array als gleichwertig mit NaNs in Eingabe-Array b angesehen. Dieser Parameter wird an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben. **Optional** Zulässige Werte: Boolesch Standardwert: `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>

Diese Regel prüft, ob Eingabebilder korrekt normalisiert wurden. Insbesondere wird festgestellt, ob der Mittelwert der Stichprobendaten um mehr als einen Schwellenwert von Null abweicht. Viele Modelle des maschinellen Sehens erfordern Eingabedaten mit einem Mittelwert und einer Einheitenvarianz von Null.

Diese Regel gilt für Deep-Learning-Anwendungen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die CheckInputImages-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| threshold\$1mean |  Ein Schwellenwert, der definiert, um wie viel der Mittelwert der Eingabedaten von 0 abweichen kann. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.2`  | 
| threshold\$1samples |  Die Anzahl der Bilder, von denen Stichproben genommen werden müssen, bevor ein Fehler ausgelöst werden kann. Wenn der Wert zu niedrig ist, ist die Schätzung des Mittelwerts des Datensatzes ungenau. **Optional** Gültige Werte: Ganzzahl Standardwert: `500`  | 
| regex |  Der Name des Eingabedatentensors. **Optional** Zulässige Werte: String Standardwert: `".*hybridsequential0_input_0"` (der Name des Eingabe-Tensors für Apache MXNet-Modelle, die HybridSequential verwenden)  | 
| channel |  Die Position des Farbkanals im Formarray des Eingabetensors.  **Optional** Gültige Werte: Ganzzahl Standardwert: `1` (Beispiel: MXNet erwartet Eingabedaten in Form von (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>

Diese Regel berechnet das Verhältnis bestimmter Token, wenn der Rest der Eingabesequenz angegeben wird, die für die Optimierung der Leistung nützlich ist. Sie können beispielsweise den Prozentsatz von EOS-Auffüllungs-Token (End-of-Sentence, Satzende) in Ihrer Eingabesequenz berechnen. Wenn die Anzahl der EOS-Token zu hoch ist, sollte eine alternative Bucketing-Strategie durchgeführt werden. Sie können auch den Prozentsatz unbekannter Token in Ihrer Eingabesequenz berechnen. Wenn die Anzahl unbekannter Wörter zu hoch ist, kann ein alternatives Vokabular verwendet werden.

Diese Regel gilt für Deep-Learning-Anwendungen.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die NLPSequenceRatio-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| tensor\$1regex |  Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge  Standardwert: `".*embedding0_input_0"` (unter der Annahme einer Einbettung als Anfangsebene des Netzwerks)  | 
| token\$1values |  Eine Zeichenfolge einer Liste der numerischen Werte der Token. Beispiel: „3, 0“. **Optional** Gültige Werte: Kommagetrennte Zeichenfolge von numerischen Werten Standardwert: `0`  | 
| token\$1thresholds\$1percent |  Eine Zeichenfolge einer Liste von Schwellenwerten (in Prozentsätzen), die jedem der `token_values` entsprechen. Beispiel: „50,0, 50,0“. **Optional** Gültige Werte: durch Komma getrennte Gleitkommazahlen Standardwert: `"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>

Diese Regel wertet die Güte einer Konfusionmatrix für ein Klassifizierungsproblem aus.

Es erstellt eine Matrix der Größe `category_no*category_no` und füllt sie mit Daten aus (`labels`, `predictions`)-Paaren. Für jedes (`labels`, `predictions`)-Paar wird die Anzahl in `confusion[labels][predictions]` um 1 erhöht. Wenn die Matrix vollständig gefüllt ist, wird das Verhältnis zwischen auf Diagonalen liegenden Daten und nicht auf Diagonalen liegenden Werten folgt ausgewertet:
+ Für Elemente auf der Diagonalen: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Für Elemente außerhalb der Diagonalen: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`

Diese Regel kann auf den XGBoost-Algorithmus angewendet werden.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die Confusion-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| category\$1no |  Die Anzahl der Kategorien. **Optional** Gültige Werte: ganzzahlig ≥2 Standardwert: `"None"`  | 
| labels |  Die `labels` Tensorsammlung oder ein 1-D-Vektor mit zutreffenden Bezeichnungen.  **Optional** Zulässige Werte: String Standardwert: `"labels"`  | 
| predictions |  Die `predictions` Tensorsammlung oder ein 1-D-Vektor mit geschätzten Bezeichnungen.  **Optional** Zulässige Werte: String Standardwert: `"predictions"`  | 
| labels\$1collection |  Die Regel prüft die Tensoren in dieser Sammlung auf `labels`. **Optional** Zulässige Werte: String Standardwert: `"labels"`  | 
| predictions\$1collection |  Die Regel prüft die Tensoren in dieser Sammlung auf `predictions`. **Optional** Zulässige Werte: String Standardwert: `"predictions"`  | 
| min\$1diag |  Der untere Schwellenwert für das Verhältnis der Daten auf der Diagonale. **Optional** Gültige Werte: `0`≤Gleikomma≤`1` Standardwert: `0.9`  | 
| max\$1off\$1diag |  Der obere Schwellenwert für das Verhältnis der Daten abseits der Diagonale. **Optional** Gültige Werte: `0`≤Gleikomma≤`1` Standardwert: `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"
                } 
            )
        ]
    )
]
```

**Anmerkung**  
Diese Regel leitet Standardwerte für die optionalen Parameter ab, wenn ihre Werte nicht angegeben sind.

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

Diese Regel akkumuliert die Gewichtungen der n größten Feature-Wichtigkeitswerte pro Schritt und stellt sicher, dass diese den Schwellenwert nicht überschreiten. Sie können z. B. festlegen, dass der Schwellenwert für die drei wichtigsten Features nicht mehr als 80 Prozent der Gesamtgewichtungen des Modells ausmacht.

Diese Regel gilt nur für den XGBoost-Algorithmus.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die Regel FeatureImportanceOverweight


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| threshold |  Legt den Schwellenwert für den Anteil der `n` größten Features an der Gesamtsumme fest. Die Zahl `n` wird durch den Parameter `nfeatures` festgelegt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.8`  | 
| nfeatures |  Die Anzahl der größten Features. **Optional** Gültige Werte: Ganzzahl Standardwert: `3`  | 
| tensor\$1regex |  Der reguläre Ausdruck (regex) des Tensors benennt die zu analysierende Regel. **Optional** Zulässige Werte: String Standardwert: `".*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>

Diese Regel misst die Tiefe von Bäumen in einem XGBoost-Modell. XGBoost lehnt Aufteilungen ab, wenn sie den Verlust nicht verbessern. Dadurch wird das Training geregelt. Infolgedessen wächst der Baum möglicherweise nicht so tief wie durch den Parameter `depth` definiert.

Diese Regel gilt nur für den XGBoost-Algorithmus.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).

Parameterbeschreibungen für die TreeDepth-Regel


| Name des Parameters | Beschreibung | 
| --- | --- | 
| base\$1trial |  Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt.  **Erforderlich** Zulässige Werte: String  | 
| depth |  Die Tiefe des Baums. Die Tiefe des Baumes wird durch Berechnung des Basis-2-Logarithmus der größten Knoten-ID bestimmt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `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"
                } 
            )
        ]
    )
]
```