# 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`](#timm.loss.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 uniquement multi-étiquette sans `multi_label` (ou une perte uniquement mono-étiquette avec).

```python
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](../training_script#multi-label-classification) 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`](#timm.loss.cross_entropy.LabelSmoothingCrossEntropy), [`SoftTargetCrossEntropy`](#timm.loss.cross_entropy.SoftTargetCrossEntropy) | Étiquette unique | L'entropie croisée softmax, la classe dépend de `smoothing` et `soft_targets`. Par défaut, étiquette unique |
| `bce` | [`BinaryCrossEntropy`](#timm.loss.binary_cross_entropy.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`](#timm.loss.asymmetric_loss.AsymmetricLossMultiLabel), [`AsymmetricLossSingleLabel`](#timm.loss.asymmetric_loss.AsymmetricLossSingleLabel) | Les deux | [Perte asymétrique](https://arxiv.org/abs/2009.14119), 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`](#timm.loss.poly_loss.PolyBinaryCrossEntropy), [`PolyCrossEntropy`](#timm.loss.poly_loss.PolyCrossEntropy) | Les deux | [Poly-1](https://arxiv.org/abs/2204.12511) 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`](#timm.loss.jsd.JsdCrossEntropy) | Étiquette unique | CE sur le split propre + divergence de Jensen-Shannon sur les `jsd_splits` splits d'augmentation ([AugMix](https://arxiv.org/abs/1912.02781)) |
| `twoway` | [`TwoWayLoss`](#timm.loss.two_way_loss.TwoWayLoss) | Multi-étiquettes | [Perte multi-étiquettes bidirectionnelle](https://staff.aist.go.jp/takumi.kobayashi/publication/2023/CVPR2023.pdf), températures `twoway_tp` / `twoway_tn`, cibles binaires uniquement |
| `zlpr` | [`ZlprLoss`](#timm.loss.zlpr_loss.ZlprLoss) | Multi-étiquettes | [ZLPR](https://arxiv.org/abs/2208.02955), extension multi-étiquettes du softmax CE sans hyperparamètres, cibles binaires uniquement |
| `db` | [`DistributionBalancedLoss`](#timm.loss.distribution_balanced_loss.DistributionBalancedLoss) | Multi-étiquettes | [Perte équilibrée par distribution](https://arxiv.org/abs/2007.09654) 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 les cibles multi-étiquettes denses). Dans ce cas, créez la perte avec `soft_targets=True` :

- **`ce`** devient `SoftTargetCrossEntropy`.
- **`bce`, multi-label `asl`, `poly` and `db`** ne lissent pas à nouveau les cibles.
- **Single-label `asl`** lève une erreur avec `soft_targets`.
- **`twoway` / `zlpr`** lèvent une exception avec `soft_targets` ou `smoothing` car 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 valeur unique 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`](#timm.loss.compute_class_weights), qui renvoie l’argument de perte auquel les poids correspondent 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](https://arxiv.org/abs/1901.05555)), 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_stats`](#timm.loss.load_class_stats) lit les compteurs depuis un fichier JSON contenant les entrées `pos_counts` et `num_samples`, tel que généré par `class_weights.py` à la racine du dépôt.
- [`load_class_weights`](#timm.loss.load_class_weights) analyse les poids explicites (un nombre, une chaîne séparée par des virgules, une liste ou un fichier JSON / texte).
- [`resolve_class_weights`](#timm.loss.resolve_class_weights) accepte soit un nom de méthode, soit des poids explicites, comme le fait `train.py` pour ses drapeaux.

La perte `db` prend les compteurs directement.

```python
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` quel que soit le 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 |
  |---|---|---|---|
  | `batchmean` | Somme | Moyenne | Par défaut |
  | `sum` | Somme | Somme | Réduction ASL d'origine ; la perte est proportionnelle à la taille du lot |
  | `mean` | Moyenne | Moyenne | Comme BCE |

  L’ASL mono-étiquette somme sur les classes et moyenne sur le lot ; la fabrique n’accepte que `batchmean` pour ce cas. `bce`, le multi-étiquette `poly` et `db` moyennent sur le lot et les classes (`bce_sum` somme sur les classes pour `bce`).

- **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_splits` sous-lots égaux, les images propres venant en premier (comme `fast_collate` organise les échantillons de `AugMixDataset`), 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]]

#### timm.loss.create_classification_loss[[timm.loss.create_classification_loss]]

```python
timm.loss.create_classification_loss(loss_type: typing.Optional[str] = None, multi_label: bool = False, smoothing: float = 0.0, soft_targets: bool = False, class_weight: typing.Union[torch.Tensor, float, typing.Sequence[float], NoneType] = None, pos_weight: typing.Union[torch.Tensor, float, typing.Sequence[float], NoneType] = None, bce_target_thresh: typing.Optional[float] = None, bce_sum: bool = False, asl_gamma_pos: float = 1.0, asl_gamma_neg: float = 4.0, asl_clip: typing.Optional[float] = 0.05, asl_reduction: str = 'batchmean', poly_epsilon: float = 2.0, poly_gamma: float = 0.0, poly_alpha: typing.Optional[float] = None, jsd_splits: int = 0, twoway_tp: float = 4.0, twoway_tn: float = 1.0, class_counts: typing.Union[torch.Tensor, typing.Sequence[float], NoneType] = None, num_samples: typing.Optional[int] = None, db_neg_scale: float = 2.0, db_init_bias: float = 0.05, db_focal_gamma: float = 2.0)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/_loss_factory.py#L31)

**Paramètres :**

loss_type : L'un des LOSS_TYPES, None sélectionne 'bce' pour les cibles multi-étiquettes et 'ce' pour les cibles mono-étiquette. 'ce' : entropie croisée softmax (variantes avec lissage d'étiquette / cibles douces si nécessaire), 'bce' : entropie croisée binaire (arguments bce_*), 'asl' : perte asymétrique, AsymmetricLossMultiLabel pour les cibles multi-étiquettes, sinon la perte asymétrique 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 la perte PolyCrossEntropy softmax (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-étiquette (class_counts, num_samples, arguments 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 au-dessus de 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 vers 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 original) 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-étiquette 'poly').

jsd_splits : Nombre de divisions 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 logit tolérante aux valeurs négatives, 1 désactive ('db' uniquement).

db_init_bias : Facteur de décalage du logit de la classe prior, 0 désactive ('db' uniquement).

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

#### timm.loss.compute_class_weights[[timm.loss.compute_class_weights]]

```python
timm.loss.compute_class_weights(pos_counts: typing.Union[torch.Tensor, typing.Sequence[float]], num_samples: int, method: str = 'neg_pos', power: float = 1.0, beta: float = 0.999, max_weight: typing.Optional[float] = None)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/class_weights.py#L19)

**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'un de 'neg_pos' : pos_weight = (negatives / positives) ** power, équilibre les termes positifs et négatifs de chaque classe, 'inv_freq' : class_weight proportionnel à (num_samples / positives) ** power, 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 repondération plus douce (racine carrée).

beta : Hyperparamètre du nombre effectif pour 'effective_num'.

max_weight : Plafond appliqué aux poids finaux.

**Retourne :**

L'argument loss pour lequel les poids sont destinés ('pos_weight' ou 'class_weight') et les poids float32.

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[[timm.loss.load_class_stats]]

```python
timm.loss.load_class_stats(path: typing.Optional[str])
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/class_weights.py#L71)

**Paramètres :**

path : fichier JSON contenant les entrées 'pos_counts' et 'num_samples'. None ou une chaîne vide renvoie None.

**Retourne :**

Les compteurs en float32 et le nombre d'échantillons sur lesquels ils ont été calculés.

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[[timm.loss.load_class_weights]]

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

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/class_weights.py#L94)

**Paramètres :**

value : valeur de poids, liste ou chemin. None ou une chaîne vide renvoie None.

key : Entrée à lire depuis des objets JSON, par exemple 'pos_weight' ou 'class_weight'.

**Retourne :**

Un float pour une valeur unique (diffusé sur les classes), sinon un tenseur float32 de dimension 1.

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 du texte avec des nombres séparés par des virgules / des espaces.

#### timm.loss.resolve_class_weights[[timm.loss.resolve_class_weights]]

```python
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]] = None, power: float = 1.0, beta: float = 0.999, max_weight: typing.Optional[float] = None)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/class_weights.py#L140)

**Paramètres :**

value : une méthode de CLASS_WEIGHT_METHODS, ou des poids explicites pour load_class_weights().

kind : l'argument de perte étant résolu, 'pos_weight' ou 'class_weight'.

class_stats : (counts, num_samples) de load_class_stats(), requis pour les noms de méthodes.

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[[timm.loss.LabelSmoothingCrossEntropy]]

#### timm.loss.LabelSmoothingCrossEntropy[[timm.loss.LabelSmoothingCrossEntropy]]

```python
timm.loss.LabelSmoothingCrossEntropy(smoothing = 0.1)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/cross_entropy.py#L11)

Perte NLL avec lissage des étiquettes.

#### timm.loss.SoftTargetCrossEntropy[[timm.loss.SoftTargetCrossEntropy]]

```python
timm.loss.SoftTargetCrossEntropy()
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/cross_entropy.py#L29)

#### timm.loss.AsymmetricLossSingleLabel[[timm.loss.AsymmetricLossSingleLabel]]

```python
timm.loss.AsymmetricLossSingleLabel(gamma_pos = 1, gamma_neg = 4, eps: float = 0.1, reduction = 'mean')
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/asymmetric_loss.py#L102)

#### forward[[timm.loss.AsymmetricLossSingleLabel.forward]]

```python
forward(inputs, target, reduction = None)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/asymmetric_loss.py#L113)

" Paramètres ---------- x: logits d'entrée y: cibles (vecteur 1-hot)

#### timm.loss.JsdCrossEntropy[[timm.loss.JsdCrossEntropy]]

```python
timm.loss.JsdCrossEntropy(num_splits = 3, alpha = 12, smoothing = 0.1)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/jsd.py#L8)

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

#### timm.loss.PolyCrossEntropy[[timm.loss.PolyCrossEntropy]]

```python
timm.loss.PolyCrossEntropy(epsilon: float = 2.0, smoothing: float = 0.0, reduction: str = 'mean')
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/poly_loss.py#L19)

**Paramètres :**

epsilon : Coefficient Poly-1, 0 correspond à l'entropie croisée simple.

smoothing : Lissage des étiquettes appliqué aux cibles d'index de classe. Les cibles denses sont supposées être adoucies 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[[timm.loss.PolyCrossEntropy.forward]]

```python
forward(x: Tensor, target: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/poly_loss.py#L41)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

target : Indices de classes (batch_size,) ou distributions cibles denses (batch_size, num_classes).

### Classes de perte multi-étiquettes[[timm.loss.BinaryCrossEntropy]]

#### timm.loss.BinaryCrossEntropy[[timm.loss.BinaryCrossEntropy]]

```python
timm.loss.BinaryCrossEntropy(smoothing = 0.1, target_threshold: typing.Optional[float] = None, weight: typing.Optional[torch.Tensor] = None, reduction: str = 'mean', sum_classes: bool = False, pos_weight: typing.Union[torch.Tensor, float, NoneType] = None, smooth_dense: bool = False)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/binary_cross_entropy.py#L12)

**Paramètres :**

smoothing : Lissage des étiquettes appliqué lors de l’encodage one-hot des cibles d’index. Les cibles denses sont supposées être lissées en amont (par exemple par Mixup/CutMix) sauf si smooth_dense est défini.

target_threshold : Binariser (de manière douce) les cibles supérieures à cette valeur.

weight : Poids de rééchelonnement par classe.

reduction : Réduction de la perte.

sum_classes : Additionner la perte sur les classes avant de faire la moyenne sur le lot.

pos_weight : Poids de la classe positive.

smooth_dense : Applique également le 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é

#### timm.loss.AsymmetricLossMultiLabel[[timm.loss.AsymmetricLossMultiLabel]]

```python
timm.loss.AsymmetricLossMultiLabel(gamma_neg: float = 4, gamma_pos: float = 1, clip: typing.Optional[float] = 0.05, eps: float = 1e-08, disable_torch_grad_focal_loss: bool = False, smoothing: float = 0.0, reduction: str = 'batchmean', weight: typing.Optional[torch.Tensor] = None, pos_weight: typing.Union[torch.Tensor, float, NoneType] = None)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/asymmetric_loss.py#L7)

**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 vers les négatifs (rognage asymétrique), désactivée si None ou 0.

eps : Probabilité minimale bornée avant l'application du logarithme.

disable_torch_grad_focal_loss : Ne pas rétropropager à travers les poids de focalisation.

smoothing : Le lissage des étiquettes (label smoothing) 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 (la réduction ASL d'origine, qui é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[[timm.loss.AsymmetricLossMultiLabel.forward]]

```python
forward(x: Tensor, y: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/asymmetric_loss.py#L52)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

y : Cibles denses (multi-hot ou douces) (batch_size, num_classes).

#### timm.loss.PolyBinaryCrossEntropy[[timm.loss.PolyBinaryCrossEntropy]]

```python
timm.loss.PolyBinaryCrossEntropy(epsilon: float = 2.0, gamma: float = 0.0, alpha: typing.Optional[float] = None, smoothing: float = 0.0, reduction: str = 'mean')
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/poly_loss.py#L64)

**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 : Le lissage des étiquettes (label smoothing) 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 calcule la 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[[timm.loss.PolyBinaryCrossEntropy.forward]]

```python
forward(x: Tensor, target: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/poly_loss.py#L98)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

target : Cibles denses (multi-hot ou douces) (batch_size, num_classes).

#### timm.loss.DistributionBalancedLoss[[timm.loss.DistributionBalancedLoss]]

```python
timm.loss.DistributionBalancedLoss(class_counts: typing.Union[torch.Tensor, typing.Sequence[float]], num_samples: int, map_alpha: float = 0.1, map_beta: float = 10.0, map_mu: float = 0.2, neg_scale: float = 2.0, init_bias: float = 0.05, focal_gamma: float = 2.0, focal_balance: float = 2.0, smoothing: float = 0.0, reduction: str = 'mean')
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/distribution_balanced_loss.py#L16)

**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 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 : Le lissage des étiquettes (label smoothing) 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-atténué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[[timm.loss.DistributionBalancedLoss.forward]]

```python
forward(x: Tensor, target: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/distribution_balanced_loss.py#L84)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

target : Cibles denses (multi-hot ou douces) (batch_size, num_classes).

#### timm.loss.TwoWayLoss[[timm.loss.TwoWayLoss]]

```python
timm.loss.TwoWayLoss(tp: float = 4.0, tn: float = 1.0)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/two_way_loss.py#L17)

**Paramètres :**

tp : Température du soft-min sur les logits positifs.

tn : Température du soft-max sur les logits négatifs.

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 possédant 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[[timm.loss.TwoWayLoss.forward]]

```python
forward(x: Tensor, target: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/two_way_loss.py#L38)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

target : Cibles binaires denses (batch_size, num_classes).

#### timm.loss.ZlprLoss[[timm.loss.ZlprLoss]]

```python
timm.loss.ZlprLoss(*args, **kwargs)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/zlpr_loss.py#L9)

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 ne croît 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[[timm.loss.ZlprLoss.forward]]

```python
forward(x: Tensor, target: Tensor)
```

[Source](https://github.com/huggingface/pytorch-image-models/blob/main/timm/loss/zlpr_loss.py#L19)

**Paramètres :**

x : Logits d'entrée (batch_size, num_classes).

target : Cibles binaires denses (batch_size, num_classes).