timm documentation
Fungsi Kehilangan
Fungsi Kehilangan
Halaman ini berisi dokumentasi referensi API untuk kerugian klasifikasi yang disertakan dalam timm, serta gambaran umum tentang bagaimana kerugian tersebut dibuat dan dikonfigurasi melalui pabrik kerugian.
Penggunaan
Losses dibuat berdasarkan nama dengan create_classification_loss. multi_label memilih antara target single-label (indeks kelas, atau distribusi lunak padat dari Mixup/CutMix)
dan target multi-label (label biner independen padat berbentuk (B, C)), dengan loss_type=None pabrik memilih ce atau bce sesuai kebutuhan. Argumen spesifik loss diberi awalan nama loss (asl_*, poly_*, db_*, β¦)
dan diabaikan oleh loss lainnya. Pabrik akan melempar error untuk kombinasi yang tidak didukung oleh loss, misalnya bobot kelas untuk
loss selain bce / multi-label asl, argumen bce_* atau class_counts untuk loss lainnya, atau loss yang hanya untuk multi-label
tanpa multi_label (atau loss yang hanya untuk single-label dengan multi_label).
import torch
import timm
from timm.data import Mixup
from timm.loss import PolyCrossEntropy, create_classification_loss
# Single-label, class index targets. Label smoothing selects LabelSmoothingCrossEntropy.
criterion = create_classification_loss(smoothing=0.1)
loss = criterion(torch.randn(8, 1000), torch.randint(0, 1000, (8,)))
# Mixup/CutMix output dense soft targets with the smoothing already applied, SoftTargetCrossEntropy.
mixup_fn = Mixup(mixup_alpha=0.8, cutmix_alpha=1.0, label_smoothing=0.1, num_classes=1000)
criterion = create_classification_loss(smoothing=0.1, soft_targets=True)
images, target = mixup_fn(torch.randn(8, 3, 224, 224), torch.randint(0, 1000, (8,)))
loss = criterion(torch.randn(8, 1000), target)
# Multi-label, dense (B, C) binary targets. BCE by default, other losses by name.
criterion = create_classification_loss(multi_label=True)
criterion = create_classification_loss('asl', multi_label=True, asl_gamma_neg=4., asl_gamma_pos=1., asl_clip=0.05)
loss = criterion(torch.randn(8, 6), torch.randint(0, 2, (8, 6)).float())
# The training tasks create their criterion with the factory, multi_label is set by the task.
from timm.task import MultiLabelClassificationTask
model = timm.create_model('resnet18', num_classes=6)
task = MultiLabelClassificationTask(model, criterion_kwargs=dict(loss_type='zlpr'))
# Losses can also be constructed directly, note the class defaults can differ from the factory's (below).
criterion = PolyCrossEntropy(epsilon=2.)Skrip pelatihan (train.py) memetakan opsinya ke loss factory sebagai berikut:
| Opsi CLI atau kondisi | Argumen atau efek pabrik |
|---|---|
--loss | loss_type |
--task multilabel | multi_label=True |
--smoothing | smoothing, default 0,1 untuk pelatihan single-label dan 0 untuk pelatihan multi-label |
| Mixup atau CutMix diaktifkan | soft_targets=True |
--asl-* | Argumen asl_* yang sesuai |
--poly-* | Argumen poly_* yang sesuai |
--twoway-* | Argumen twoway_* yang sesuai |
--db-* | Argumen db_* yang sesuai |
--bce-sum | bce_sum |
--bce-target-thresh | bce_target_thresh |
--aug-splits | jsd_splits |
--class-stats | Jumlah kelas untuk fungsi bobot kelas di bawah, dan class_counts / num_samples untuk db |
--loss-pos-weight | pos_weight, yang diselesaikan oleh fungsi bobot kelas di bawah |
--loss-class-weight | class_weight, yang diselesaikan oleh fungsi bobot kelas di bawah |
--loss-weight-* | Opsi untuk fungsi bobot kelas di bawah |
Lihat dokumentasi pelatihan untuk penggunaan baris perintah.
Jenis-jenis loss
LOSS_TYPES berisi nama-nama yang diterima oleh factory dan MULTI_LABEL_LOSS_TYPES berisi nama-nama yang dapat digunakan dengan multi_label=True.
loss_type | Kelas | Target | Catatan |
|---|---|---|---|
ce | nn.CrossEntropyLoss, LabelSmoothingCrossEntropy, SoftTargetCrossEntropy | Label tunggal | Softmax cross-entropy, kelas bergantung pada smoothing dan soft_targets. Default single-label |
bce | BinaryCrossEntropy | Keduanya | Sigmoid BCE, default untuk multi-label. Target indeks kelas di-encode one-hot, bce_target_thresh membinerkan target lunak, bce_sum menjumlahkan di atas kelas sebelum merata-ratakan di atas batch |
asl | AsymmetricLossMultiLabel, AsymmetricLossSingleLabel | Keduanya | Asymmetric Loss, pemusatan terpisah untuk positif (asl_gamma_pos) dan negatif (asl_gamma_neg), margin probabilitas pada negatif (asl_clip, hanya multi-label). Varian single-label (softmax) memerlukan target indeks kelas, tanpa Mixup/CutMix |
poly | PolyBinaryCrossEntropy, PolyCrossEntropy | Keduanya | Poly-1, menambahkan poly_epsilon * (1 - p_t) ke BCE / CE, 0 mereduksi menjadi BCE / CE. Istilah focal (poly_gamma) dan balance (poly_alpha) opsional untuk multi-label |
jsd | JsdCrossEntropy | Label tunggal | CE pada split bersih + divergensi Jensen-Shannon di seluruh jsd_splits split augmentasi (AugMix) |
twoway | TwoWayLoss | Multi-label | Loss Multi-Label Dua Arah, suhu twoway_tp / twoway_tn, hanya target biner |
zlpr | ZlprLoss | Multi-label | ZLPR, ekstensi multi-label dari softmax CE tanpa hiperparameter, hanya untuk target biner |
db | DistributionBalancedLoss | Multi-label | Distribution-Balanced Loss untuk data long-tailed, membutuhkan class_counts dan num_samples |
Label smoothing dan target lunak
smoothing secara bawaan bernilai 0. Untuk target berlabel tunggal, kelas target memperoleh 1 - s + s / C dan
kelas lainnya s / C (LabelSmoothingCrossEntropy ekuivalen dengan nn.CrossEntropyLoss(label_smoothing=s)), bce
menggunakan smoothing one-hot yang sama untuk target indeks kelas. Untuk target berlabel banyak, setiap label biner digeser mendekati 0,5, y * (1 - s) + 0.5 * s.
timm.data.Mixup menerapkan label_smoothing saat mencampur dan menghasilkan target padat (dengan multi_label=True ia mencampur dan menghaluskan target multi-label padat). Buat loss dengan soft_targets=True dalam kasus ini:
cemenjadiSoftTargetCrossEntropy.bce, multi-labelasl,polydandbtidak menghaluskan target lagi.- Single-label
aslakan menghasilkan error dengansoft_targets. twoway/zlprakan menghasilkan error jika digunakan dengansoft_targetsatausmoothingkarena keduanya membinerkan target pada 0,5.
Kelas-kelas tersebut memiliki nilai bawaan masing-masing saat dikonstruksi secara langsung, BinaryCrossEntropy, LabelSmoothingCrossEntropy dan JsdCrossEntropy secara bawaan menggunakan smoothing=0.1 dan AsymmetricLossSingleLabel menggunakan eps=0.1 (smoothing label-nya).
Penimbangan kelas
pos_weight mengalikan suku positif dari setiap kelas, menyeimbangkan positif terhadap negatif di dalam sebuah kelas. class_weight mengalikan seluruh loss dari setiap kelas, menyeimbangkan antar kelas. Keduanya menerima satu nilai atau satu nilai per kelas dan didukung oleh bce dan multi-label asl. Keduanya dapat diberikan secara eksplisit atau diturunkan dari jumlah positif per kelas dengan compute_class_weights, yang mengembalikan argumen loss yang menjadi tujuan bobot tersebut beserta bobotnya. Kelas tanpa positif dihitung sebagai memiliki satu, dan max_weight membatasi bobot akhir.
method | Argumen | Bobot untuk kelas dengan n positif |
|---|---|---|
neg_pos | pos_weight | ((num_samples - n) / n) ** power |
inv_freq | class_weight | (num_samples / n) ** power, dinormalisasi ke rata-rata 1 |
effective_num | class_weight | (1 - beta) / (1 - beta ** n) (class-balanced), dinormalisasi ke rata-rata 1 |
Metode-metode tersebut ada di CLASS_WEIGHT_METHODS, dan CLASS_WEIGHT_METHOD_KINDS memetakan masing-masing ke argumen loss-nya.
load_class_statsmembaca jumlah dari file JSON dengan entripos_countsdannum_samples, seperti yang ditulis olehclass_weights.pydi akar repositori.load_class_weightsmengurai bobot eksplisit (sebuah angka, string yang dipisahkan koma, sebuah daftar, atau file JSON / teks).resolve_class_weightsmenerima nama metode atau bobot eksplisit, seperti yang dilakukantrain.pyuntuk flag-nya.
Loss db mengambil hitungan secara langsung.
import torch
from timm.loss import compute_class_weights, create_classification_loss, resolve_class_weights
pos_counts = [120, 3400, 560, 45, 980, 2100] # positives per class
num_samples = 5000
kind, weights = compute_class_weights(pos_counts, num_samples, method='neg_pos', power=0.5) # kind == 'pos_weight'
criterion = create_classification_loss(multi_label=True, pos_weight=weights)
# Method names (w/ class stats) or explicit weights, class_stats can be loaded w/ load_class_stats('stats.json')
class_stats = (torch.tensor(pos_counts), num_samples)
class_weight = resolve_class_weights('effective_num', 'class_weight', class_stats=class_stats, beta=0.999)
pos_weight = resolve_class_weights('2.0', 'pos_weight')
criterion = create_classification_loss('asl', multi_label=True, class_weight=class_weight, pos_weight=pos_weight)
criterion = create_classification_loss('db', multi_label=True, class_counts=pos_counts, num_samples=num_samples)Catatan loss
Precision. Loss multi-label ASL, Poly-1, DB, Two-way, dan ZLPR dihitung dalam
float32terlepas dari dtype logit, karena probabilitas ASL presisi rendah (float16) akan mengalami underflow pada log clamp-nya.Reduksi. ASL multi-label mendukung nilai
asl_reductionberikut:Nilai Di atas kelas Atas batch Catatan batchmeanJumlah Rata-rata Default sumJumlah Jumlah Reduksi ASL asli; loss berskala dengan ukuran batch meanRata-rata Rata-rata Seperti BCE ASL berlabel tunggal menjumlahkan di atas kelas dan merata-ratakan di atas batch, pabrik hanya menerima
batchmeanuntuknya.bce,polyberlabel banyak, dandbmerata-ratakan di atas batch dan kelas (bce_summenjumlahkan di atas kelas untukbce).Two-way membandingkan logit negatif terberat dengan logit positif terberat di antara kelas dari setiap sampel dan di antara sampel dari setiap kelas, hanya sampel/kelas dengan nilai positif yang berkontribusi. Logit-nya adalah skor peringkat, bukan probabilitas sigmoid yang dikalibrasi, sehingga metrik ambang (F1) tidak bermakna, gunakan mAP.
ZLPR mendorong setiap logit positif di atas setiap logit negatif dengan 0 sebagai ambang keputusan, sehingga logit > 0 (sigmoid > 0.5) memprediksi positif.
DB menimbang setiap istilah (sampel, kelas) dengan rasio probabilitas pengambilan sampel tingkat kelas terhadap tingkat instans, memperhitungkan ko-terjadinya label, menggeser logit dengan prior kelas (
db_init_bias) dan menskalakan logit negatif (db_neg_scale). Hitungan dijepit ke[1, num_samples - 1]. Parameter peta re-balance dan keseimbangan focal adalah argumen kelas, tidak diekspos oleh pabrik.JSD mengharapkan batch sebagai
jsd_splitsbagian yang sama, dengan gambar bersih di awal (sebagaimanafast_collatemenyusun sampelAugMixDataset), dan suku CE hanya menggunakan bagian bersih. Bobot JSD (alpha=12) adalah argumen kelas.
API
Fungsi pabrik
timm.loss.create_classification_loss
< source >( loss_type: typing.Optional[str] = Nonemulti_label: bool = Falsesmoothing: float = 0.0soft_targets: bool = Falseclass_weight: typing.Union[torch.Tensor, float, typing.Sequence[float], NoneType] = Nonepos_weight: typing.Union[torch.Tensor, float, typing.Sequence[float], NoneType] = Nonebce_target_thresh: typing.Optional[float] = Nonebce_sum: bool = Falseasl_gamma_pos: float = 1.0asl_gamma_neg: float = 4.0asl_clip: typing.Optional[float] = 0.05asl_reduction: str = 'batchmean'poly_epsilon: float = 2.0poly_gamma: float = 0.0poly_alpha: typing.Optional[float] = Nonejsd_splits: int = 0twoway_tp: float = 4.0twoway_tn: float = 1.0class_counts: typing.Union[torch.Tensor, typing.Sequence[float], NoneType] = Nonenum_samples: typing.Optional[int] = Nonedb_neg_scale: float = 2.0db_init_bias: float = 0.05db_focal_gamma: float = 2.0 )
Parameter
- loss_type β Salah satu dari LOSSTYPES, None memilih βbceβ untuk multi-label dan βceβ untuk target single-label. βceβ: softmax cross-entropy (varian label smoothing / soft target sesuai kebutuhan), βbceβ: binary cross-entropy (bce args), βaslβ: Asymmetric Loss, AsymmetricLossMultiLabel untuk target multi-label, selain itu softmax AsymmetricLossSingleLabel, hanya target indeks kelas, tanpa Mixup/CutMix (asl_ args), βpolyβ: Poly-1 loss, PolyBinaryCrossEntropy (sigmoid) untuk target multi-label, selain itu softmax PolyCrossEntropy (poly* args), βjsdβ: Jensen-Shannon divergence + CE atas split augmentasi, single-label (jsd_splits), βtwowayβ: Two-way loss, hanya target multi-label biner (twoway args), βzlprβ: ZLPR loss, hanya target multi-label biner, βdbβ: Distribution-Balanced loss, multi-label (classcounts, num_samples, db args).
- multi_label β Target adalah label biner independen yang padat dengan bentuk (B, C).
- smoothing β Faktor label smoothing. Diabaikan ketika soft_targets disetel, karena Mixup/CutMix sudah menerapkannya saat menghasilkan soft targets.
- soft_targets β Target tiba sebagai distribusi lunak padat dari Mixup/CutMix, bukan indeks kelas.
- class_weight β Bobot loss per kelas, satu nilai tunggal atau satu nilai untuk setiap kelas (βbceβ dan βaslβ multi-label).
- pos_weight β Bobot istilah positif, satu nilai atau satu per kelas (βbceβ dan βaslβ multi-label).
- bce_target_thresh β Membinarkan target lunak di atas nilai ini (hanya βbceβ).
- bce_sum β Jumlahkan loss di seluruh kelas sebelum dirata-ratakan di batch (hanya βbceβ).
- asl_gamma_pos β Parameter fokus untuk target positif (hanya βaslβ).
- asl_gamma_neg β Parameter fokus untuk target negatif (hanya βaslβ).
- asl_clip β Margin probabilitas yang digeser ke negatif, None atau 0 menonaktifkan (hanya untuk βaslβ multi-label).
- asl_reduction β βbatchmeanβ (jumlah atas kelas, rata-rata atas batch), βsumβ (ASL asli), atau βmeanβ (hanya untuk βaslβ multi-label, ASL single-label selalu menggunakan βbatchmeanβ).
- poly_epsilon β Koefisien Poly-1, 0 mengurangi menjadi CE / BCE (hanya βpolyβ).
- poly_gamma β Parameter fokus, 0 menonaktifkan istilah fokus (hanya βpolyβ multi-label).
- poly_alpha β Bobot keseimbangan positif/negatif, None menonaktifkannya (hanya untuk βpolyβ multi-label).
- jsd_splits β Jumlah split augmentasi, harus > 1 (hanya βjsdβ).
- twoway_tp β Suhu logit positif (hanya βtwowayβ).
- twoway_tn β Suhu logit negatif (hanya βtwowayβ).
- class_counts β Jumlah sampel pelatihan positif per kelas (hanya βdbβ).
- num_samples β Jumlah sampel pelatihan yang menjadi dasar perhitungan class_counts (hanya untuk βdbβ).
- db_neg_scale β Skala logit yang toleran terhadap nilai negatif, 1 untuk menonaktifkan (hanya βdbβ).
- db_init_bias β Faktor pergeseran logit prior kelas, 0 untuk menonaktifkan (hanya βdbβ).
- db_focal_gamma β Parameter fokus, 0 menonaktifkan istilah fokus (hanya βdbβ).
Buat kriteria pelatihan untuk tugas klasifikasi.
Fungsi bobot kelas
timm.loss.compute_class_weights
< source >( pos_counts: typing.Union[torch.Tensor, typing.Sequence[float]]num_samples: intmethod: str = 'neg_pos'power: float = 1.0beta: float = 0.999max_weight: typing.Optional[float] = None )
Parameter
- pos_counts β Jumlah sampel positif per kelas (frekuensi kelas untuk target single-label).
- num_samples β Jumlah sampel yang digunakan untuk mengambil hitungan.
- method β Salah satu βneg_posβ: pos_weight = (negatives / positives) power, menyeimbangkan istilah positif dan negatif dari setiap kelas, βinv_freqβ: class_weight proporsional terhadap (num_samples / positives) power, rata-rata 1, βeffective_numβ: class_weight seimbang kelas dari jumlah sampel efektif (1 - beta ** n) / (1 - beta), https://arxiv.org/abs/1901.05555, rata-rata 1.
- power β Eksponen untuk βneg_posβ dan βinv_freqβ, 0.5 memberikan re-weighting yang lebih lembut (akar kuadrat).
- beta β Hyperparameter jumlah efektif untuk βeffective_numβ.
- max_weight β Batas yang diterapkan pada bobot akhir.
Hitung bobot kerugian per kelas dari jumlah label positif.
Kelas tanpa elemen positif dianggap memiliki satu, dan setiap bobot dibatasi pada max_weight jika disetel.
timm.loss.load_class_stats
< source >( path: typing.Optional[str] )
Muat jumlah positif per kelas dan jumlah sampel dari file statistik class_weights.py.
timm.loss.load_class_weights
< source >( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]key: str = 'class_weight' )
Analisis bobot kerugian dari sebuah angka, daftar yang dipisahkan koma, atau sebuah file.
File adalah JSON (sebuah daftar, atau objek yang menyimpan daftar di bawah key, seperti yang ditulis oleh class_weights.py) atau teks dengan angka yang dipisahkan oleh koma / spasi.
timm.loss.resolve_class_weights
< source >( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]kind: str = 'class_weight'class_stats: typing.Optional[typing.Tuple[torch.Tensor, int]] = Nonepower: float = 1.0beta: float = 0.999max_weight: typing.Optional[float] = None )
Parameter
- value β Metode dalam CLASS_WEIGHT_METHODS, atau bobot eksplisit untuk load_class_weights().
- kind β Argumen loss yang sedang dipecahkan, βpos_weightβ atau βclass_weightβ.
- class_stats β (counts, num_samples) dari load_class_stats(), diperlukan untuk nama metode.
- power β Lihat compute_class_weights().
- beta β Lihat compute_class_weights().
- max_weight β Lihat compute_class_weights().
Selesaikan bobot kerugian yang diberikan sebagai nama metode (dihitung dari statistik kelas) atau sebagai bobot eksplisit.
Kelas Loss Label Tunggal
NLL loss dengan label smoothing.
kelas timm.loss.AsymmetricLossSingleLabel
< source >( gamma_pos = 1gamma_neg = 4eps: float = 0.1reduction = 'mean' )
Divergensi Jensen-Shannon + Fungsi Kehilangan Entropi Silang
Berdasarkan implementasi di sini: https://github.com/google-research/augmix/blob/master/imagenet.py Dari makalah: βAugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty - https://arxiv.org/abs/1912.02781
Dirakit oleh / Hak cipta 2020 Ross Wightman
kelas timm.loss.PolyCrossEntropy
< source >( epsilon: float = 2.0smoothing: float = 0.0reduction: str = 'mean' )
Parameter
- epsilon β Koefisien Poly-1, 0 adalah cross-entropy biasa.
- smoothing β Label smoothing yang diterapkan pada target indeks kelas. Target padat diasumsikan telah dilunakkan di hulu (misalnya oleh Mixup/CutMix).
- reduction β βmeanβ atau βsumβ pada batch, atau βnoneβ untuk kerugian per sampel.
Poly-1 softmax cross-entropy, CE + epsilon * (1 - p_t), untuk klasifikasi label tunggal.
p_t adalah jumlah probabilitas softmax berbobot target sum_c(t_c * p_c), sehingga label smoothing dan target lunak (Mixup/CutMix) berlaku untuk kedua suku, sebagaimana pada referensi.
forward
< source >( x: Tensortarget: Tensor )
Kelas Loss Multi-label
kelas timm.loss.BinaryCrossEntropy
< source >( smoothing = 0.1target_threshold: typing.Optional[float] = Noneweight: typing.Optional[torch.Tensor] = Nonereduction: str = 'mean'sum_classes: bool = Falsepos_weight: typing.Union[torch.Tensor, float, NoneType] = Nonesmooth_dense: bool = False )
Parameter
- smoothing β Label smoothing yang diterapkan saat melakukan one-hot encoding pada target indeks. Target dense diasumsikan telah dihaluskan di hulu (misalnya oleh Mixup/CutMix) kecuali smooth_dense disetel.
- target_threshold β Membinarisasi (soft) target di atas nilai ini.
- weight β Bobat penskalaan ulang per kelas.
- reduction β Reduksi loss.
- sum_classes β Jumlahkan loss di atas kelas sebelum dirata-ratakan di atas batch.
- pos_weight β Bobot kelas positif.
- smooth_dense β Terapkan juga smoothing pada target yang sudah cocok dengan bentuk logit (multi-label), menggeser setiap target biner menuju 0,5.
BCE dengan one-hot opsional dari target padat, label smoothing, thresholding CATATAN untuk eksperimen yang membandingkan CE dengan BCE /w label smoothing, mungkin dihapus
kelas timm.loss.AsymmetricLossMultiLabel
< source >( gamma_neg: float = 4gamma_pos: float = 1clip: typing.Optional[float] = 0.05eps: float = 1e-08disable_torch_grad_focal_loss: bool = Falsesmoothing: float = 0.0reduction: str = 'batchmean'weight: typing.Optional[torch.Tensor] = Nonepos_weight: typing.Union[torch.Tensor, float, NoneType] = None )
Parameter
- gamma_neg β Parameter fokus untuk target negatif.
- gamma_pos β Parameter fokus untuk target positif.
- clip β Margin probabilitas yang digeser ke negatif (pemotongan asimetris), dinonaktifkan jika None atau 0.
- eps β Probabilitas minimum yang di-clamp sebelum log.
- disable_torch_grad_focal_loss β Jangan lakukan backprop melalui focusing weights.
- smoothing β Label smoothing, menggeser setiap target (dense, biner independen) ke arah 0,5.
- reduction β βbatchmeanβ menjumlahkan di atas kelas dan merata-ratakan di atas batch, βsumβ menjumlahkan di atas batch dan kelas (reduction ASL asli, berskala dengan ukuran batch), βmeanβ merata-ratakan di atas batch dan kelas, βnoneβ mempertahankan loss per elemen.
- weight β Bobat penskalaan ulang per kelas.
- pos_weight β Bobot dari istilah positif, berupa satu nilai atau satu nilai per kelas.
Asymmetric Loss (ASL) untuk klasifikasi multi-label, https://arxiv.org/abs/2009.14119
forward
< source >( x: Tensory: Tensor )
kelas timm.loss.PolyBinaryCrossEntropy
< source >( epsilon: float = 2.0gamma: float = 0.0alpha: typing.Optional[float] = Nonesmoothing: float = 0.0reduction: str = 'mean' )
Parameter
- epsilon β Koefisien Poly-1, 0 adalah BCE polos (atau focal loss).
- gamma β Parameter fokus, 0 menonaktifkan istilah fokus.
- alpha β Bobot keseimbangan positif/negatif, None menonaktifkannya.
- smoothing β Label smoothing, menggeser setiap target (dense, biner independen) ke arah 0,5.
- reduction β βmeanβ merata-ratakan atas batch dan kelas (seperti BCE), βbatchmeanβ menjumlahkan atas kelas dan merata-ratakan atas batch, βsumβ menjumlahkan keduanya, βnoneβ mempertahankan loss per elemen.
Poly-1 sigmoid (focal) loss, FL + epsilon * (1 - p_t) ** (gamma + 1), untuk klasifikasi multi-label.
Dengan gamma = 0, ini adalah BCE + epsilon * (1 - p_t) per kelas. Dengan alpha yang disetel, positif diberi bobot alpha dan negatif diberi bobot 1 - alpha pada kedua istilah, seperti pada referensi.
forward
< source >( x: Tensortarget: Tensor )
kelas timm.loss.DistributionBalancedLoss
< source >( class_counts: typing.Union[torch.Tensor, typing.Sequence[float]]num_samples: intmap_alpha: float = 0.1map_beta: float = 10.0map_mu: float = 0.2neg_scale: float = 2.0init_bias: float = 0.05focal_gamma: float = 2.0focal_balance: float = 2.0smoothing: float = 0.0reduction: str = 'mean' )
Parameter
- class_counts β Jumlah sampel positif per kelas pada set pelatihan.
- num_samples β Jumlah sampel pelatihan yang digunakan untuk menghitung jumlah tersebut.
- map_alpha β Bobot minimum dari peta re-balancing.
- map_beta β Skala dari peta re-balance.
- map_mu β Ambang batas peta re-balance.
- neg_scale β Skala logit negatif (lambda), 1 menonaktifkan penskalaan toleran-negatif.
- init_bias β Faktor pergeseran logit prior kelas (kappa), 0 menonaktifkannya.
- focal_gamma β Parameter fokus, 0 menonaktifkan istilah fokus (dan focal_balance).
- focal_balance β Skala konstan dari focal loss.
- smoothing β Label smoothing, menggeser setiap target ke arah 0,5.
- reduction β βmeanβ merata-ratakan atas batch dan kelas (skala referensi), βbatchmeanβ menjumlahkan atas kelas dan merata-ratakan atas batch, βsumβ menjumlahkan keduanya, βnoneβ mempertahankan loss per elemen.
Loss Distribution-Balanced (DB) untuk klasifikasi multi-label dengan distribusi ekor panjang.
Sigmoid BCE dengan dua tambahan:
- Penimbangan ulang: setiap istilah (sampel, kelas) diberi bobot berdasarkan rasio probabilitas pengambilan sampel tingkat kelas 1 / n_i terhadap probabilitas tingkat instans sampel sum_j(y_j / n_j), yang memperhitungkan ko-keberadaan label dari setiap sampel, dihaluskan sebagai alpha + sigmoid(beta * (r - mu)).
- Regularisasi yang toleran terhadap nilai negatif: logits digeser oleh bias prior kelas, dan istilah negatif menggunakan logits yang diskalakan, softplus(neg_scale * z) / neg_scale, sehingga banyak nilai negatif dari kelas langka tidak terlalu ditekan. Istilah focal opsional (1 - p_t) ** gamma mengikuti konfigurasi DB referensi.
Target lunak (Mixup/CutMix) memberikan bobot pada istilah positif dan negatif, sedangkan bobot penyeimbangan ulang menggunakan target sebagaimana diberikan. Keduanya sesuai dengan referensi untuk target biner.
forward
< source >( x: Tensortarget: Tensor )
kelas timm.loss.TwoWayLoss
< source >( tp: float = 4.0tn: float = 1.0 )
Loss multi-label dua arah.
Membandingkan logit negatif terberat (soft-max) dengan logit positif terberat (soft-min) dalam dua arah, melintasi kelas dari setiap sampel dan melintasi sampel dari setiap kelas dalam batch. Hanya sampel / kelas yang memiliki setidaknya satu positif yang berkontribusi pada arah yang bersangkutan.
Target dibinarkan, entri di atas 0,5 adalah positif. Logits adalah skor peringkat, mereka tidak dikalibrasi sebagai probabilitas sigmoid independen.
forward
< source >( x: Tensortarget: Tensor )
Loss ZLPR, ekstensi multi-label dari softmax cross-entropy.
Per sampel, log(1 + sum_neg exp(s_j)) + log(1 + sum_pos exp(-s_i)). Setiap logit positif didorong di atas setiap logit negatif dan 0 bertindak sebagai ambang keputusan, sehingga logits > 0 (sigmoid > 0.5) memprediksi positif. Tidak ada hiperparameter, dan loss tidak tumbuh seiring dengan jumlah kelas negatif seperti pada BCE per kelas.
Target dibinarkan, entri di atas 0,5 adalah positif.
forward
< source >( x: Tensortarget: Tensor )