timm documentation
Pertes
Pertes
Cette page contient la documentation de référence de l'API pour les pertes de classification incluses dans timm, ainsi qu'un aperçu de leur création et de leur configuration via l'usine de pertes.
Utilisation
Les pertes sont créées par nom à l’aide de create_classification_loss. multi_label permet de choisir entre des cibles mono-étiquette (indices de classes, ou distributions douces denses issues de Mixup/CutMix)
et des cibles multi-étiquettes (étiquettes binaires indépendantes denses de forme (B, C)), avec loss_type=None la fabrique sélectionne ce ou bce en conséquence. Les arguments spécifiques à une perte sont préfixés par le nom de la perte (asl_*, poly_*, db_*, …)
et ignorés par les autres pertes. La fabrique lève une exception pour les combinaisons non prises en charge par une perte, par exemple des poids de classes pour
des pertes autres que bce / multi-étiquette asl, des arguments bce_* ou class_counts pour d’autres pertes, ou une perte
réservée au multi-étiquette sans multi_label (ou une perte réservée au mono-étiquette avec).
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.)Le script d’entraînement (train.py) associe ses options à la fabrique de pertes de la manière suivante :
| Option ou condition CLI | Argument d'usine ou effet |
|---|---|
--loss | loss_type |
--task multilabel | multi_label=True |
--smoothing | smoothing, par défaut 0,1 pour l'entraînement mono-étiquette et 0 pour l'entraînement multi-étiquettes |
| Mixup ou CutMix activé | soft_targets=True |
--asl-* | Arguments asl_* correspondants |
--poly-* | Arguments poly_* correspondants |
--twoway-* | Arguments twoway_* correspondants |
--db-* | Arguments db_* correspondants |
--bce-sum | bce_sum |
--bce-target-thresh | bce_target_thresh |
--aug-splits | jsd_splits |
--class-stats | Nombres de classes pour les fonctions de pondération des classes ci-dessous, et class_counts / num_samples pour db |
--loss-pos-weight | pos_weight, résolu par les fonctions de poids de classe ci-dessous |
--loss-class-weight | class_weight, résolu par les fonctions de poids de classe ci-dessous |
--loss-weight-* | Options pour les fonctions de poids de classe ci-dessous |
Consultez la documentation d’entraînement pour l’utilisation en ligne de commande.
Types de pertes
LOSS_TYPES contient les noms acceptés par la fabrique et MULTI_LABEL_LOSS_TYPES ceux utilisables avec multi_label=True.
loss_type | Classe | Cibles | Notes |
|---|---|---|---|
ce | nn.CrossEntropyLoss, LabelSmoothingCrossEntropy, SoftTargetCrossEntropy | Étiquette unique | L'entropie croisée softmax, la classe dépend de smoothing et soft_targets. Par défaut, étiquette unique |
bce | BinaryCrossEntropy | Les deux | Sigmoid BCE, par défaut pour les étiquettes multiples. Les cibles d’index de classe sont encodées en one-hot, bce_target_thresh binarise les cibles douces, bce_sum somme sur les classes avant de faire la moyenne sur le lot |
asl | AsymmetricLossMultiLabel, AsymmetricLossSingleLabel | Les deux | Perte asymétrique, focalisation séparée pour les positifs (asl_gamma_pos) et les négatifs (asl_gamma_neg), une marge de probabilité sur les négatifs (asl_clip, uniquement pour les étiquettes multiples). La variante à étiquette unique (softmax) nécessite des cibles d'index de classe, pas de Mixup/CutMix |
poly | PolyBinaryCrossEntropy, PolyCrossEntropy | Les deux | Poly-1 ajoute poly_epsilon * (1 - p_t) à BCE / CE, 0 se réduit à BCE / CE. Termes focal (poly_gamma) et d'équilibrage (poly_alpha) optionnels pour les étiquettes multiples |
jsd | JsdCrossEntropy | Étiquette unique | CE sur le split propre + divergence de Jensen-Shannon sur les jsd_splits splits d'augmentation (AugMix) |
twoway | TwoWayLoss | Multi-étiquettes | Perte multi-étiquettes bidirectionnelle, températures twoway_tp / twoway_tn, cibles binaires uniquement |
zlpr | ZlprLoss | Multi-étiquettes | ZLPR, extension multi-étiquettes du softmax CE sans hyperparamètres, cibles binaires uniquement |
db | DistributionBalancedLoss | Multi-étiquettes | Perte équilibrée par distribution pour les données à longue traîne, nécessite class_counts et num_samples |
Lissage des étiquettes et cibles douces
smoothing est défini sur 0 par défaut dans l’usine. Pour des cibles mono-classe, la classe cible reçoit 1 - s + s / C et les
autres s / C (LabelSmoothingCrossEntropy est équivalent à nn.CrossEntropyLoss(label_smoothing=s)), bce utilise
le même lissage one-hot pour les cibles d’index de classe. Pour des cibles multi-classes, chaque étiquette binaire est rapprochée de 0,5, y * (1 - s) + 0.5 * s.
timm.data.Mixup applique son label_smoothing lors du mélange et produit des cibles denses (avec multi_label=True, il mélange et lisse des cibles multi-étiquettes denses). Dans ce cas, créez la perte avec soft_targets=True :
cedevientSoftTargetCrossEntropy.bce, multi-labelasl,polyanddbne lissent pas à nouveau les cibles.- Single-label
asllève une erreur avecsoft_targets. twoway/zlprlèvent une exception avecsoft_targetsousmoothingcar ils binarisent les cibles à 0,5.
Les classes ont leurs propres valeurs par défaut lorsqu’elles sont construites directement, BinaryCrossEntropy, LabelSmoothingCrossEntropy et JsdCrossEntropy sont par défaut smoothing=0.1 et AsymmetricLossSingleLabel est eps=0.1 (son lissage des étiquettes).
Pondération des classes
pos_weight multiplie le terme positif de chaque classe, équilibrant les positifs par rapport aux négatifs au sein d'une classe. class_weight multiplie la perte entière de chaque classe, équilibrant les classes entre elles. Les deux acceptent une seule valeur ou une valeur par classe et sont pris en charge par bce et asl multi-étiquettes. Ils peuvent être fournis explicitement ou dérivés des compteurs de positifs par classe à l'aide de compute_class_weights, qui renvoie l'argument de perte pour lequel les poids sont destinés ainsi que les poids. Les classes sans positifs sont comptées comme en ayant un, et max_weight plafonne les poids finaux.
method | Argument | Poids pour une classe avec n positifs |
|---|---|---|
neg_pos | pos_weight | ((num_samples - n) / n) ** power |
inv_freq | class_weight | (num_samples / n) ** power, normalisé à une moyenne de 1 |
effective_num | class_weight | (1 - beta) / (1 - beta ** n) (class-balanced), normalisé à une moyenne de 1 |
Les méthodes sont dans CLASS_WEIGHT_METHODS, et CLASS_WEIGHT_METHOD_KINDS associe chacune à son argument de perte.
load_class_statslit les compteurs depuis un fichier JSON contenant les entréespos_countsetnum_samples, tel que généré parclass_weights.pyà la racine du dépôt.load_class_weightsanalyse les poids explicites (un nombre, une chaîne séparée par des virgules, une liste ou un fichier JSON / texte).resolve_class_weightsaccepte soit un nom de méthode, soit des poids explicites, comme le faittrain.pypour ses drapeaux.
La perte db prend les compteurs directement.
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)Notes sur la perte
Précision. Les pertes multi-étiquettes ASL, Poly-1, DB, Two-way et ZLPR sont calculées en
float32, indépendamment du type de données des logits, car les probabilités ASL en basse précision (float16) entraîneraient sinon un sous-débordement de son clamp logarithmique.Réduction. L'ASL multi-étiquettes prend en charge les valeurs suivantes de
asl_reduction:Valeur Sur les classes Sur le lot Notes batchmeanSomme Moyenne Par défaut sumSomme Somme Réduction ASL d'origine ; la perte est proportionnelle à la taille du lot meanMoyenne Moyenne Comme BCE L’ASL mono-étiquette somme sur les classes et moyenne sur le lot ; la fabrique n’accepte que
batchmeanpour ce cas.bce, le multi-étiquettepolyetdbmoyennent sur le lot et les classes (bce_sumsomme sur les classes pourbce).Two-way compare le logit négatif le plus difficile avec le logit positif le plus difficile, à la fois entre les classes de chaque échantillon et entre les échantillons de chaque classe ; seuls les échantillons / classes avec un positif contribuent. Ses logits sont des scores de classement, et non des probabilités sigmoïdes calibrées, les métriques seuilées (F1) n’ont donc pas de sens, utilisez mAP.
ZLPR pousse chaque logit positif au-dessus de chaque logit négatif avec 0 comme seuil de décision, de sorte que les logits > 0 (sigmoid > 0.5) prédisent des positifs.
DB pondère chaque terme (échantillon, classe) par le rapport entre la probabilité d’échantillonnage au niveau de la classe et celle au niveau de l’instance, en tenant compte de la co-occurrence des étiquettes, décale les logits par un a priori de classe (
db_init_bias) et met à l’échelle les logits négatifs (db_neg_scale). Les compteurs sont bornés à[1, num_samples - 1]. Les paramètres de la carte de rééquilibrage et l’équilibre focal sont des arguments de classe, non exposés par la fabrique.JSD s'attend à ce que le lot soit fourni sous forme de
jsd_splitssous-lots égaux, les images propres venant en premier (commefast_collateorganise les échantillons deAugMixDataset), le terme CE n'utilise que le sous-lot propre. Le poids JSD (alpha=12) est un argument de classe.
API
Fonctions d'usine
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 )
Paramètres
- loss_type — L’un des LOSSTYPES, None sélectionne ‘bce’ pour les cibles multi-étiquettes et ‘ce’ pour les cibles mono-étiquettes. ‘ce’ : entropie croisée softmax (variantes avec lissage des étiquettes / cibles douces si nécessaire), ‘bce’ : entropie croisée binaire (arguments bce), ‘asl’ : perte asymétrique, AsymmetricLossMultiLabel pour les cibles multi-étiquettes, sinon le softmax AsymmetricLossSingleLabel, uniquement pour les cibles d’index de classe, sans Mixup/CutMix (arguments asl_), ‘poly’ : perte Poly-1, PolyBinaryCrossEntropy (sigmoïde) pour les cibles multi-étiquettes, sinon le softmax PolyCrossEntropy (arguments poly*), ‘jsd’ : divergence de Jensen-Shannon + entropie croisée sur les divisions d’augmentation, mono-étiquette (jsd_splits), ‘twoway’ : perte bidirectionnelle, uniquement pour les cibles multi-étiquettes binaires (arguments twoway), ‘zlpr’ : perte ZLPR, uniquement pour les cibles multi-étiquettes binaires, ‘db’ : perte équilibrée par distribution, multi-étiquettes (arguments classcounts, num_samples, db).
- multi_label — Les cibles sont des étiquettes binaires indépendantes denses de forme (B, C).
- smoothing — Facteur de lissage des étiquettes. Ignoré lorsque soft_targets est défini, car Mixup/CutMix l'applique déjà lors de la génération des étiquettes douces.
- soft_targets — Les cibles arrivent sous forme de distributions douces denses issues de Mixup/CutMix plutôt que d’indices de classes.
- class_weight — Poids de la perte par classe, une valeur unique ou une valeur par classe (‘bce’ et ‘asl’ multi-étiquettes).
- pos_weight — Poids du terme positif, une valeur unique ou une valeur par classe (‘bce’ et ‘asl’ multi-étiquettes).
- bce_target_thresh — Binariser les cibles douces supérieures à cette valeur (uniquement « bce »).
- bce_sum — Somme la perte sur les classes avant de faire la moyenne sur le lot (uniquement « bce »).
- asl_gamma_pos — Paramètre de focalisation pour les cibles positives (uniquement « asl »).
- asl_gamma_neg — Paramètre de focalisation pour les cibles négatives (uniquement « asl »).
- asl_clip — Marge de probabilité décalée sur les négatifs, None ou 0 désactive (uniquement pour « asl » multi-étiquettes).
- asl_reduction — ‘batchmean’ (somme sur les classes, moyenne sur le lot), ‘sum’ (ASL d’origine) ou ‘mean’ (uniquement pour ‘asl’ multi-étiquettes, l’ASL mono-étiquette utilise toujours ‘batchmean’).
- poly_epsilon — Coefficient Poly-1, 0 réduit à CE / BCE (uniquement ‘poly’).
- poly_gamma — Paramètre de focalisation, 0 désactive le terme focal (uniquement pour « poly » multi-étiquettes).
- poly_alpha — Poids d'équilibre positif/négatif, None le désactive (uniquement pour le multi-étiquetage « poly »).
- jsd_splits — Nombre de splits d'augmentation, doit être > 1 (uniquement « jsd »).
- twoway_tp — Température des logits positifs (uniquement « twoway »).
- twoway_tn — Température des logits négatifs (uniquement « twoway »).
- class_counts — Nombre d'échantillons d'entraînement positifs par classe (uniquement « db »).
- num_samples — Nombre d'échantillons d'entraînement sur lesquels les class_counts ont été calculés (uniquement « db »).
- db_neg_scale — Échelle de logits tolérante aux valeurs négatives, 1 pour désactiver (uniquement « db »).
- db_init_bias — Facteur de décalage du logit de la classe a priori, 0 pour désactiver (uniquement « db »).
- db_focal_gamma — Paramètre de focalisation, 0 désactive le terme focal (uniquement « db »).
Créer le critère d’entraînement pour une tâche de classification.
Fonctions de pondération des classes
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 )
Paramètres
- pos_counts — Nombre d'échantillons positifs par classe (la fréquence de la classe pour les cibles mono-étiquette).
- num_samples — Nombre d'échantillons sur lesquels les compteurs ont été calculés.
- method — L’une des ‘neg_pos’ : pos_weight = (négatifs / positifs) puissance, équilibre les termes positifs et négatifs de chaque classe, ‘inv_freq’ : class_weight proportionnel à (num_samples / positifs) puissance, moyenne 1, ‘effective_num’ : class_weight équilibré par classe à partir du nombre effectif d’échantillons (1 - beta ** n) / (1 - beta), https://arxiv.org/abs/1901.05555, moyenne 1.
- power — Exposant pour « neg_pos » et « inv_freq », 0,5 donne un rééquilibrage plus doux (racine carrée).
- beta — Hyperparamètre du nombre effectif pour ‘effective_num’.
- max_weight — Plafond appliqué aux poids finaux.
Calculer les poids de perte par classe à partir des nombres de labels positifs.
Les classes sans aucun exemple positif sont traitées comme en ayant un, et chaque poids est plafonné à max_weight si celui-ci est défini.
timm.loss.load_class_stats
< source >( path: typing.Optional[str] )
Charger les nombres de positifs par classe et le nombre d'échantillons depuis un fichier de statistiques class_weights.py.
timm.loss.load_class_weights
< source >( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]key: str = 'class_weight' )
Analyser les poids de perte à partir d'un nombre, d'une liste séparée par des virgules ou d'un fichier.
Les fichiers sont au format JSON (une liste, ou un objet contenant la liste sous la clé key, comme écrit par class_weights.py) ou texte avec des nombres séparés par des virgules / des espaces.
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 )
Paramètres
- value — Une méthode de CLASS_WEIGHT_METHODS, ou des poids explicites pour load_class_weights().
- kind — L’argument de perte à résoudre, ‘pos_weight’ ou ‘class_weight’.
- class_stats — (counts, num_samples) de load_class_stats(), requis pour les noms de méthode.
- power — Voir compute_class_weights().
- beta — Voir compute_class_weights().
- max_weight — Voir compute_class_weights().
Résoudre les poids de perte fournis sous forme de nom de méthode (calculés à partir des statistiques de classe) ou sous forme de poids explicites.
Classes de perte à étiquette unique
Perte NLL avec lissage des étiquettes.
classe timm.loss.AsymmetricLossSingleLabel
< source >( gamma_pos = 1gamma_neg = 4eps: float = 0.1reduction = 'mean' )
Divergence de Jensen-Shannon + Perte d'entropie croisée
Basé sur l’implémentation ici : https://github.com/google-research/augmix/blob/master/imagenet.py D’après l’article : ‘AugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty - https://arxiv.org/abs/1912.02781
Assemblé par / Copyright 2020 Ross Wightman
classe timm.loss.PolyCrossEntropy
< source >( epsilon: float = 2.0smoothing: float = 0.0reduction: str = 'mean' )
Paramètres
- epsilon — Coefficient Poly-1, 0 correspond à l'entropie croisée standard.
- smoothing — Lissage des étiquettes appliqué aux cibles d’index de classe. Les cibles denses sont supposées avoir été lissées en amont (par exemple par Mixup/CutMix).
- reduction — « mean » ou « sum » sur le lot, ou « none » pour les pertes par échantillon.
Poly-1 softmax d'entropie croisée, CE + epsilon * (1 - p_t), pour la classification mono-étiquette.
p_t est la somme des probabilités softmax pondérées par la cible, sum_c(t_c * p_c), de sorte que le lissage des étiquettes et les cibles douces (Mixup/CutMix) s'appliquent aux deux termes, comme dans la référence.
forward
< source >( x: Tensortarget: Tensor )
Classes de perte multi-étiquettes
classe 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 )
Paramètres
- smoothing — Lissage des étiquettes appliqué lors de l’encodage one-hot des cibles d’index. Les cibles denses sont supposées avoir été lissées en amont (par exemple par Mixup/CutMix) sauf si smooth_dense est défini.
- target_threshold — Binariser (soft) les cibles supérieures à cette valeur.
- weight — Poids de rééchelonnement par classe.
- reduction — Réduction de la perte.
- sum_classes — Somme la perte sur les classes avant de faire la moyenne sur le lot.
- pos_weight — Poids de la classe positive.
- smooth_dense — Applique également un lissage aux cibles qui correspondent déjà à la forme des logits (multi-étiquettes), en déplaçant chaque cible binaire vers 0,5.
BCE avec option one-hot à partir de cibles denses, lissage des étiquettes, seuillage NOTE pour les expériences comparant CE à BCE /w lissage des étiquettes, peut être supprimé
classe 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 )
Paramètres
- gamma_neg — Paramètre de focalisation pour les cibles négatives.
- gamma_pos — Paramètre de focalisation pour les cibles positives.
- clip — Marge de probabilité décalée sur les négatifs (rognage asymétrique), désactivée si None ou 0.
- eps — Probabilité minimale appliquée avant le logarithme.
- disable_torch_grad_focal_loss — Ne pas rétropropager à travers les poids de focalisation.
- smoothing — Lissage des étiquettes, déplace chaque cible (dense, binaire indépendante) vers 0,5.
- reduction — « batchmean » somme sur les classes et fait la moyenne sur le lot, « sum » somme sur le lot et les classes (réduction ASL d'origine, évolue avec la taille du lot), « mean » fait la moyenne sur le lot et les classes, « none » conserve la perte par élément.
- weight — Poids de rééchelonnement par classe.
- pos_weight — Poids du terme positif, une valeur unique ou une valeur par classe.
Perte asymétrique (ASL) pour la classification multi-étiquettes, https://arxiv.org/abs/2009.14119
forward
< source >( x: Tensory: Tensor )
classe timm.loss.PolyBinaryCrossEntropy
< source >( epsilon: float = 2.0gamma: float = 0.0alpha: typing.Optional[float] = Nonesmoothing: float = 0.0reduction: str = 'mean' )
Paramètres
- epsilon — Coefficient Poly-1, 0 correspond à une BCE simple (ou une perte focale).
- gamma — Paramètre de focalisation, 0 désactive le terme focal.
- alpha — Poids d'équilibre positif/négatif, None le désactive.
- smoothing — Lissage des étiquettes, déplace chaque cible (dense, binaire indépendante) vers 0,5.
- reduction — « mean » calcule la moyenne sur le lot et les classes (comme BCE), « batchmean » somme sur les classes et moyenne sur le lot, « sum » somme sur les deux, « none » conserve la perte par élément.
Perte sigmoïde (focale) Poly-1, FL + epsilon * (1 - p_t) ** (gamma + 1), pour la classification multi-étiquettes.
Avec gamma = 0, il s'agit de BCE + epsilon * (1 - p_t) par classe. Si alpha est défini, les positifs sont pondérés par alpha et les négatifs par 1 - alpha dans les deux termes, comme dans la référence.
forward
< source >( x: Tensortarget: Tensor )
classe 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' )
Paramètres
- class_counts — Nombre d'échantillons positifs par classe sur l'ensemble d'entraînement.
- num_samples — Nombre d'échantillons d'entraînement sur lesquels les compteurs ont été calculés.
- map_alpha — Poids minimal de la carte de rééquilibrage.
- map_beta — Échelle de la carte de rééquilibrage.
- map_mu — Seuil de la carte de rééquilibrage.
- neg_scale — Échelle des logits négatifs (lambda), 1 désactive le mise à l'échelle tolérante aux négatifs.
- init_bias — Facteur de décalage du logit de la classe a priori (kappa), 0 le désactive.
- focal_gamma — Paramètre de focalisation, 0 désactive le terme focal (et focal_balance).
- focal_balance — Échelle constante de la perte focale.
- smoothing — Lissage des étiquettes, déplace chaque cible vers 0,5.
- reduction — « mean » calcule la moyenne sur le lot et les classes (l’échelle de référence), « batchmean » somme sur les classes et calcule la moyenne sur le lot, « sum » somme sur les deux, « none » conserve la perte par élément.
Perte équilibrée par distribution (DB) pour la classification multi-étiquettes à longue traîne.
BCE sigmoïde avec deux ajouts :
- Pondération rééquilibrée : chaque terme (échantillon, classe) est pondéré par le rapport entre la probabilité d'échantillonnage au niveau de la classe 1 / n_i et celle au niveau de l'instance de l'échantillon sum_j(y_j / n_j), ce qui tient compte de la co-occurrence des étiquettes de chaque échantillon, lissée sous la forme alpha + sigmoid(beta * (r - mu)).
- Régularisation tolérante aux négatifs : les logits sont décalés par un biais a priori de classe, et les termes négatifs utilisent un logit mis à l'échelle, softplus(neg_scale * z) / neg_scale, afin que les nombreux négatifs des classes rares ne soient pas sur-supprimés. Un terme focal optionnel (1 - p_t) ** gamma suit la configuration de référence DB.
Les cibles douces (Mixup/CutMix) pondent les termes positifs et négatifs, tandis que les poids de rééquilibrage utilisent les cibles telles qu’elles sont fournies. Les deux approches correspondent à la référence pour les cibles binaires.
forward
< source >( x: Tensortarget: Tensor )
classe timm.loss.TwoWayLoss
< source >( tp: float = 4.0tn: float = 1.0 )
Perte multi-étiquettes bidirectionnelle.
Compare le logit négatif le plus difficile (soft-max) au logit positif le plus difficile (soft-min) dans deux directions, à travers les classes de chaque échantillon et à travers les échantillons de chaque classe du lot. Seuls les échantillons / classes avec au moins un positif contribuent à la direction respective.
Les cibles sont binarisées, les valeurs supérieures à 0,5 sont positives. Les logits sont des scores de classement, ils ne sont pas calibrés comme des probabilités sigmoides indépendantes.
forward
< source >( x: Tensortarget: Tensor )
Perte ZLPR, extension multi-étiquettes de l'entropie croisée softmax.
Par échantillon, log(1 + sum_neg exp(s_j)) + log(1 + sum_pos exp(-s_i)). Chaque logit positif est poussé au-dessus de chaque logit négatif et 0 agit comme seuil de décision, de sorte que les logits > 0 (sigmoid > 0.5) prédisent des positifs. Aucun hyperparamètre, et la perte n'augmente pas avec le nombre de classes négatives comme le BCE par classe.
Les cibles sont binarisées, les valeurs supérieures à 0,5 sont positives.
forward
< source >( x: Tensortarget: Tensor )