timm documentation

Fungsi Kehilangan

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.0.31).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 kondisiArgumen atau efek pabrik
--lossloss_type
--task multilabelmulti_label=True
--smoothingsmoothing, default 0,1 untuk pelatihan single-label dan 0 untuk pelatihan multi-label
Mixup atau CutMix diaktifkansoft_targets=True
--asl-*Argumen asl_* yang sesuai
--poly-*Argumen poly_* yang sesuai
--twoway-*Argumen twoway_* yang sesuai
--db-*Argumen db_* yang sesuai
--bce-sumbce_sum
--bce-target-threshbce_target_thresh
--aug-splitsjsd_splits
--class-statsJumlah kelas untuk fungsi bobot kelas di bawah, dan class_counts / num_samples untuk db
--loss-pos-weightpos_weight, yang diselesaikan oleh fungsi bobot kelas di bawah
--loss-class-weightclass_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_typeKelasTargetCatatan
cenn.CrossEntropyLoss, LabelSmoothingCrossEntropy, SoftTargetCrossEntropyLabel tunggalSoftmax cross-entropy, kelas bergantung pada smoothing dan soft_targets. Default single-label
bceBinaryCrossEntropyKeduanyaSigmoid 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
aslAsymmetricLossMultiLabel, AsymmetricLossSingleLabelKeduanyaAsymmetric 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
polyPolyBinaryCrossEntropy, PolyCrossEntropyKeduanyaPoly-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
jsdJsdCrossEntropyLabel tunggalCE pada split bersih + divergensi Jensen-Shannon di seluruh jsd_splits split augmentasi (AugMix)
twowayTwoWayLossMulti-labelLoss Multi-Label Dua Arah, suhu twoway_tp / twoway_tn, hanya target biner
zlprZlprLossMulti-labelZLPR, ekstensi multi-label dari softmax CE tanpa hiperparameter, hanya untuk target biner
dbDistributionBalancedLossMulti-labelDistribution-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:

  • ce menjadi SoftTargetCrossEntropy.
  • bce, multi-label asl, poly dan db tidak menghaluskan target lagi.
  • Single-label asl akan menghasilkan error dengan soft_targets.
  • twoway / zlpr akan menghasilkan error jika digunakan dengan soft_targets atau smoothing karena 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.

methodArgumenBobot untuk kelas dengan n positif
neg_pospos_weight((num_samples - n) / n) ** power
inv_freqclass_weight(num_samples / n) ** power, dinormalisasi ke rata-rata 1
effective_numclass_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_stats membaca jumlah dari file JSON dengan entri pos_counts dan num_samples, seperti yang ditulis oleh class_weights.py di akar repositori.
  • load_class_weights mengurai bobot eksplisit (sebuah angka, string yang dipisahkan koma, sebuah daftar, atau file JSON / teks).
  • resolve_class_weights menerima nama metode atau bobot eksplisit, seperti yang dilakukan train.py untuk 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 float32 terlepas dari dtype logit, karena probabilitas ASL presisi rendah (float16) akan mengalami underflow pada log clamp-nya.

  • Reduksi. ASL multi-label mendukung nilai asl_reduction berikut:

    NilaiDi atas kelasAtas batchCatatan
    batchmeanJumlahRata-rataDefault
    sumJumlahJumlahReduksi ASL asli; loss berskala dengan ukuran batch
    meanRata-rataRata-rataSeperti BCE

    ASL berlabel tunggal menjumlahkan di atas kelas dan merata-ratakan di atas batch, pabrik hanya menerima batchmean untuknya. bce, poly berlabel banyak, dan db merata-ratakan di atas batch dan kelas (bce_sum menjumlahkan di atas kelas untuk bce).

  • 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_splits bagian yang sama, dengan gambar bersih di awal (sebagaimana fast_collate menyusun sampel AugMixDataset), dan suku CE hanya menggunakan bagian bersih. Bobot JSD (alpha=12) adalah argumen kelas.

API

Fungsi pabrik

timm.loss.create_classification_loss

< >

( 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

< >

( 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

< >

( path: typing.Optional[str] )

Parameter

  • path β€” file JSON dengan entri β€˜pos_counts’ dan β€˜num_samples’. None atau string kosong mengembalikan None.

Muat jumlah positif per kelas dan jumlah sampel dari file statistik class_weights.py.

timm.loss.load_class_weights

< >

( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]key: str = 'class_weight' )

Parameter

  • value β€” Nilai bobot, daftar, atau path. None atau string kosong mengembalikan None.
  • key β€” Entri untuk dibaca dari objek JSON, misalnya β€˜pos_weight’ atau β€˜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

< >

( 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

kelas timm.loss.LabelSmoothingCrossEntropy

< >

( smoothing = 0.1 )

NLL loss dengan label smoothing.

kelas timm.loss.SoftTargetCrossEntropy

< >

( )

kelas timm.loss.AsymmetricLossSingleLabel

< >

( gamma_pos = 1gamma_neg = 4eps: float = 0.1reduction = 'mean' )

forward

< >

( inputstargetreduction = None )

”

Parameter

x: logits input y: target (vektor 1-hot)

kelas timm.loss.JsdCrossEntropy

< >

( num_splits = 3alpha = 12smoothing = 0.1 )

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

< >

( 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

< >

( x: Tensortarget: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • target β€” Indeks kelas (batch_size,) atau distribusi target padat (batch_size, num_classes).

Kelas Loss Multi-label

kelas timm.loss.BinaryCrossEntropy

< >

( 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

< >

( 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

< >

( x: Tensory: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • y β€” Target padat (multi-hot atau lunak) (batch_size, num_classes).

kelas timm.loss.PolyBinaryCrossEntropy

< >

( 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

< >

( x: Tensortarget: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • target β€” Target padat (multi-hot atau lunak) (batch_size, num_classes).

kelas timm.loss.DistributionBalancedLoss

< >

( 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

< >

( x: Tensortarget: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • target β€” Target padat (multi-hot atau lunak) (batch_size, num_classes).

kelas timm.loss.TwoWayLoss

< >

( tp: float = 4.0tn: float = 1.0 )

Parameter

  • tp β€” Suhu soft-min pada logit positif.
  • tn β€” Suhu soft-max pada logit negatif.

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

< >

( x: Tensortarget: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • target β€” Target biner padat (batch_size, num_classes).

kelas timm.loss.ZlprLoss

< >

( *args**kwargs )

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

< >

( x: Tensortarget: Tensor )

Parameter

  • x β€” Logit input (batch_size, num_classes).
  • target β€” Target biner padat (batch_size, num_classes).
Update on GitHub