Daftar Aturan Built-in Debugger

Gunakan aturan bawaan Debugger yang disediakan oleh Amazon SageMaker Debugger dan analisis metrik dan tensor yang dikumpulkan saat melatih model Anda. Aturan bawaan Debugger memantau berbagai kondisi umum yang sangat penting untuk keberhasilan pekerjaan pelatihan. Anda dapat memanggil aturan bawaan menggunakan Amazon SageMaker Python SDK atau operasi API tingkat rendah SageMaker . Tidak ada biaya tambahan untuk menggunakan aturan bawaan. Untuk informasi selengkapnya tentang penagihan, lihat halaman SageMaker Harga Amazon.

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

Aturan Debugger

Aturan berikut adalah aturan bawaan Debugger yang dapat dipanggil menggunakan classmethod. Rule.sagemaker

Untuk menggunakan aturan bawaan dengan nilai parameter default - gunakan format konfigurasi berikut:

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

Untuk menggunakan aturan bawaan dengan menyesuaikan nilai parameter — gunakan format konfigurasi berikut:

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

Untuk menemukan kunci yang tersedia untuk rule_parameters parameter, lihat tabel deskripsi parameter.

Contoh kode konfigurasi aturan disediakan untuk setiap aturan bawaan di bawah tabel deskripsi parameter.

CreateXgboostLaporkan

CreateXgboostReport Aturan tersebut mengumpulkan tensor keluaran dari pekerjaan pelatihan XGBoost dan membuat laporan pelatihan yang komprehensif secara otomatis. Anda dapat mengunduh laporan pembuatan profil yang komprehensif saat pekerjaan pelatihan sedang berjalan atau setelah pekerjaan pelatihan selesai, dan memeriksa kemajuan pelatihan atau hasil akhir dari pekerjaan pelatihan. CreateXgboostReport Aturan mengumpulkan tensor keluaran berikut secara default:

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

DeadRelu

Aturan ini mendeteksi ketika persentase fungsi aktivasi unit linier yang diperbaiki (ReLU) dalam percobaan dianggap mati karena aktivitas aktivasi mereka telah turun di bawah ambang batas. Jika persentase RelU tidak aktif dalam lapisan lebih besar dari threshold_layer nilai RelU tidak aktif, aturan akan kembali. True

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

ExplodingTensor

Aturan ini mendeteksi apakah tensor yang dipancarkan selama pelatihan memiliki nilai yang tidak terbatas, baik tak terbatas atau NaN (bukan angka). Jika nilai non-terbatas terdeteksi, aturan kembali. True

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

PoorWeightInisialisasi

Aturan ini mendeteksi jika parameter model Anda telah diinisialisasi dengan buruk.

Inisialisasi yang baik memecah simetri bobot dan gradien dalam jaringan saraf dan mempertahankan varians aktivasi yang sepadan di seluruh lapisan. Jika tidak, jaringan saraf tidak belajar secara efektif. Inisialisasi seperti Xavier bertujuan untuk menjaga varians konstan di seluruh aktivasi, yang sangat relevan untuk melatih jaring saraf yang sangat dalam. Inisialisasi yang terlalu kecil dapat menyebabkan gradien menghilang. Inisialisasi yang terlalu besar dapat menyebabkan gradien meledak. Aturan ini memeriksa varians input aktivasi lintas lapisan, distribusi gradien, dan konvergensi kerugian untuk langkah awal untuk menentukan apakah jaringan saraf telah diinisialisasi dengan buruk.

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

SaturatedActivation

Aturan ini mendeteksi jika lapisan aktivasi tanh dan sigmoid menjadi jenuh. Lapisan aktivasi jenuh ketika input lapisan mendekati maksimum atau minimum fungsi aktivasi. Minimum dan maksimum fungsi aktivasi tanh dan sigmoid ditentukan oleh masing-masing min_threshold dan nilainya. max_thresholds Jika aktivitas node turun di bawah threshold_inactivity persentase, itu dianggap jenuh. Jika lebih dari satu threshold_layer persen node jenuh, aturan akan kembaliTrue.

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

VanishingGradient

Aturan ini mendeteksi jika gradien dalam percobaan menjadi sangat kecil atau turun ke magnitudo nol. Jika rata-rata nilai absolut gradien turun di bawah yang ditentukanthreshold, aturan akan kembaliTrue.

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

WeightUpdateRasio

Aturan ini melacak rasio pembaruan terhadap bobot selama pelatihan dan mendeteksi apakah rasio itu terlalu besar atau terlalu kecil. Jika rasio pembaruan terhadap bobot lebih besar dari large_threshold value atau jika rasio ini lebih kecil darismall_threshold, aturan akan kembaliTrue.

Kondisi untuk pelatihan adalah yang terbaik ketika pembaruan sepadan dengan gradien. Pembaruan yang terlalu besar dapat mendorong bobot menjauh dari nilai optimal, dan pembaruan yang sangat kecil menghasilkan konvergensi yang sangat lambat. Aturan ini mengharuskan bobot tersedia untuk dua langkah pelatihan, dan train.save_interval perlu ditetapkan sama dengan. num_steps

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

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

AllZero

Aturan ini mendeteksi jika semua atau persentase tertentu dari nilai tensor adalah nol.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost. Anda harus menentukan tensor_regex parameter collection_names atau. Jika kedua parameter ditentukan, aturan memeriksa penyatuan tensor dari kedua set.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Aturan ini mengukur ketidakseimbangan pengambilan sampel antara kelas dan melempar kesalahan jika ketidakseimbangan melebihi ambang batas atau jika terlalu banyak kesalahan prediksi untuk kelas yang kurang terwakili terjadi sebagai akibat dari ketidakseimbangan.

Model klasifikasi membutuhkan kelas yang seimbang dalam kumpulan data pelatihan atau bobot/pengambilan sampel kelas yang tepat selama pelatihan. Aturan melakukan pemeriksaan berikut:

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

LossNotMenurunnya

Aturan ini mendeteksi ketika kerugian tidak menurun nilainya pada tingkat yang memadai. Kerugian ini harus skalar.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost. Anda harus menentukan tensor_regex parameter collection_names atau. Jika kedua parameter ditentukan, aturan memeriksa penyatuan tensor dari kedua set.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Aturan ini mendeteksi jika model Anda terlalu cocok dengan data pelatihan dengan membandingkan validasi dan kerugian pelatihan.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Latihan berlebihan

Aturan ini mendeteksi jika model sedang dilatih berlebihan. Setelah sejumlah iterasi pelatihan pada model yang berperilaku baik (baik pelatihan dan kehilangan validasi menurun), model mendekati minimum fungsi kerugian dan tidak membaik lagi. Jika model melanjutkan pelatihan, dapat terjadi bahwa kehilangan validasi mulai meningkat, karena model mulai overfitting. Aturan ini menetapkan ambang batas dan kondisi untuk menentukan apakah model tidak membaik, dan mencegah masalah overfitting karena overtraining.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

SimilarAcrossBerjalan

Aturan ini membandingkan tensor yang dikumpulkan dari uji coba dasar dengan tensor dari uji coba lain.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

StalledTrainingAturan

StalledTrainingRule mendeteksi jika tidak ada kemajuan yang dibuat pada pekerjaan pelatihan, dan menghentikan pekerjaan pelatihan jika aturan tersebut berlaku. Aturan ini mengharuskan tensor disimpan secara berkala dalam interval waktu yang ditentukan oleh parameternyathreshold. Aturan ini terus memantau tensor baru, dan jika tidak ada tensor baru yang dipancarkan untuk aturan interval ambang akan diaktifkan.

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

Aturan ini mendeteksi jika Anda memiliki tensor dengan varians yang sangat tinggi atau rendah. Varians yang sangat tinggi atau rendah dalam tensor dapat menyebabkan saturasi neuron, yang mengurangi kemampuan belajar jaringan saraf. Varians yang sangat tinggi dalam tensor juga pada akhirnya dapat menyebabkan tensor meledak. Gunakan aturan ini untuk mendeteksi masalah tersebut sejak dini.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost. Anda harus menentukan tensor_regex parameter collection_names atau. Jika kedua parameter ditentukan, aturan memeriksa penyatuan tensor dari kedua set.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Aturan ini mendeteksi apakah tensor tidak lagi berubah di seluruh langkah.

Aturan ini menjalankan metode numpy.allclose untuk memeriksa apakah tensor tidak berubah.

Aturan ini dapat diterapkan baik ke salah satu kerangka kerja pembelajaran mendalam yang didukung (TensorFlow, MXNet, PyTorch dan) atau ke algoritma XGBoost. Anda harus menentukan tensor_regex parameter collection_names atau. Jika kedua parameter ditentukan, aturan memeriksa penyatuan tensor dari kedua set.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

CheckInputGambar

Aturan ini memeriksa apakah gambar input telah dinormalisasi dengan benar. Secara khusus, ini mendeteksi jika rata-rata data sampel berbeda lebih dari nilai ambang dari nol. Banyak model visi komputer mengharuskan data input memiliki mean nol dan varians unit.

Aturan ini berlaku untuk aplikasi pembelajaran mendalam.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Aturan ini menghitung rasio token tertentu mengingat sisa urutan input yang berguna untuk mengoptimalkan kinerja. Misalnya, Anda dapat menghitung persentase token padding end-of-sentence (EOS) dalam urutan input Anda. Jika jumlah token EOS terlalu tinggi, strategi bucketing alternatif harus dilakukan. Anda juga dapat menghitung persentase token yang tidak diketahui dalam urutan input Anda. Jika jumlah kata yang tidak diketahui terlalu tinggi, kosakata alternatif dapat digunakan.

Aturan ini berlaku untuk aplikasi pembelajaran mendalam.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Kebingungan

Aturan ini mengevaluasi kebaikan matriks kebingungan untuk masalah klasifikasi.

Ini menciptakan matriks ukuran category_no*category_no dan mengisinya dengan data yang berasal dari (labels,predictions) pasangan. Untuk setiap pasangan (labels,predictions), hitungan dalam confusion[labels][predictions] bertambah 1. Ketika matriks terisi penuh, rasio data nilai on-diagonal dan nilai off-diagonal dievaluasi sebagai berikut:

Aturan ini dapat diterapkan pada algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

FeatureImportanceKelebihan berat badan

Aturan ini mengakumulasi bobot n nilai kepentingan fitur terbesar per langkah dan memastikan bahwa mereka tidak melebihi ambang batas. Misalnya, Anda dapat mengatur ambang batas untuk 3 fitur teratas agar tidak menampung lebih dari 80 persen dari total bobot model.

Aturan ini hanya berlaku untuk algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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

Aturan ini mengukur kedalaman pohon dalam model XGBoost. XGBoost menolak perpecahan jika mereka tidak meningkatkan kerugian. Ini mengatur pelatihan. Akibatnya, pohon mungkin tidak tumbuh sedalam yang ditentukan oleh depth parameter.

Aturan ini hanya berlaku untuk algoritma XGBoost.

Untuk contoh cara mengonfigurasi dan menerapkan aturan bawaan, lihatKonfigurasikan Aturan Built-in Debugger.

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