Liste der in den Debugger integrierten Regeln

Verwenden Sie die integrierten Debuger-Regeln von Amazon SageMaker Debugger und analysieren Sie Metriken und Tensoren, die beim Training Ihrer Modelle gesammelt wurden. 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 mithilfe des Amazon SageMaker Python SDK oder der SageMaker Low-Level-API-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.

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.

CreateXgboostBericht

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:

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 der inaktiven ReLUs in einer Ebene größer ist als der threshold_layer-Wert inaktiver ReLUs, gibt die Regel True zurück.

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 Integrierte Debuger-Regeln konfigurieren.

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.

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 Integrierte Debuger-Regeln konfigurieren.

PoorWeightInitialisierung

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.

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 Integrierte Debuger-Regeln konfigurieren.

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.

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 Integrierte Debuger-Regeln konfigurieren.

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.

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 Integrierte Debuger-Regeln konfigurieren.

WeightUpdateVerhältnis

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.

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 Integrierte Debuger-Regeln konfigurieren.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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

LossNotAbnehmend

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 Integrierte Debuger-Regeln konfigurieren.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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

SimilarAcrossLäuft

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 Integrierte Debuger-Regeln konfigurieren.

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

StalledTrainingRegel

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.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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 (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 Integrierte Debuger-Regeln konfigurieren.

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

CheckInputBilder

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 Integrierte Debuger-Regeln konfigurieren.

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

NLP SequenceRatio

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 Füllungstoken end-of-sentence (EOS) 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 Integrierte Debuger-Regeln konfigurieren.

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 Integrierte Debuger-Regeln konfigurieren.

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

FeatureImportanceÜbergewichtig

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 Integrierte Debuger-Regeln konfigurieren.

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. 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 Integrierte Debuger-Regeln konfigurieren.

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