Liste der integrierten Debuger-Regeln

Sie können die von Amazon Debugger bereitgestellten integrierten SageMaker Debuger-Regeln verwenden, um Metriken und Tensoren zu analysieren, die beim Training Ihrer Modelle erfasst 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. Sie können die integrierten Regeln mit Amazon SageMaker Python SDK oder den SageMaker API Low-Level-Operationen aufrufen.

Für die Nutzung der integrierten Regeln fallen keine zusätzlichen Kosten an. Weitere Informationen zur Abrechnung finden Sie auf der Seite mit den SageMaker Amazon-Preisen.

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

Debugger-Regel

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

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

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.

CreateXgboostReport

Die CreateXgboostReport Regel sammelt Ausgangstensoren aus einem XGBoost Trainingsjob und generiert 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 CreateXgboostReport Regel sammelt standardmäßig die folgenden Ausgabetensoren:

Parameterbeschreibungen für die Regel CreateXgboostReport

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

DeadRelu

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 von inaktivem R eLUs in einer Ebene größer ist als der threshold_layer Wert von inaktivem ReLUs, kehrt die Regel zurückTrue.

Parameterbeschreibungen für die DeadRelu Regel

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 die integrierten Debuger-Regeln.

ExplodingTensor

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

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 die integrierten Debuger-Regeln.

PoorWeightInitialization

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 Regel PoorWeightInitialization

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 die integrierten Debuger-Regeln.

SaturatedActivation

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_thresholdund 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 Regel SaturatedActivation

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 die integrierten Debuger-Regeln.

VanishingGradient

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.

Parameter, Beschreibungen für die Regel VanishingGradient

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 die integrierten Debuger-Regeln.

WeightUpdateRatio

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 Regel WeightUpdateRatio

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 die integrierten Debuger-Regeln.

AllZero

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameter, Beschreibungen für die AllZero Regel

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

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:

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die ClassImbalance Regel

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

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die LossNotDecreasing Regel

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

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die Overfit-Regel

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

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die Overtraining-Regel

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

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die SimilarAcrossRuns Regel

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

StalledTrainingRule erkennt, ob beim Trainingsjob kein Fortschritt erzielt wurde, und stoppt den Trainingsjob, 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 StalledTrainingRule Regel

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

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 (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die TensorVariance Regel

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

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

Diese Regel führt die Methode numpy.allclose aus, um zu überprüfen, ob sich der Tensor nicht ändert.

Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlowMXNet, 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die UnchangedTensor Regel

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

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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die Regel CheckInputImages

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

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 der Padding end-of-sentence (EOS) -Token in Ihrer Eingabesequenz berechnen. Wenn die Anzahl der EOS Token zu hoch ist, sollte eine alternative Bucketing-Strategie angewendet 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die Regel NLPSequenceRatio

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

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:

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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die Confusion-Regel

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

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 ist nur für den XGBoost Algorithmus gültig.

Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter So konfigurieren Sie die integrierten Debuger-Regeln.

Parameterbeschreibungen für die FeatureImportanceOverweight Regel

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

Diese Regel misst die Tiefe von Bäumen in einem XGBoost Modell. XGBoostlehnt Splits 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 die integrierten Debuger-Regeln.

Parameterbeschreibungen für die TreeDepth Regel

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