timm documentation
Pérdidas
Pérdidas
Esta página contiene la documentación de referencia de la API para las pérdidas de clasificación incluidas en timm, y una
visión general de cómo se crean y configuran a través de la fábrica de pérdidas.
Uso
Las pérdidas se crean por nombre con create_classification_loss. multi_label selecciona entre objetivos de una sola etiqueta (índices de clase, o distribuciones suaves densas de Mixup/CutMix)
y objetivos de múltiples etiquetas (etiquetas binarias independientes densas con forma (B, C)), y con loss_type=None la fábrica elige ce o bce en consecuencia. Los argumentos específicos de cada pérdida se prefijan con el nombre de la pérdida (asl_*, poly_*, db_*, …)
y son ignorados por las demás pérdidas. La fábrica lanza una excepción para combinaciones que una pérdida no admite, por ejemplo, pesos de clase para
pérdidas distintas de bce / asl de múltiples etiquetas, argumentos bce_* o class_counts para otras pérdidas, o una pérdida
solo de múltiples etiquetas sin multi_label (o una pérdida solo de una etiqueta con él).
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.)El script de entrenamiento (train.py) mapea sus opciones a la fábrica de pérdidas de la siguiente manera:
| Opción de CLI o condición | Argumento de fábrica o efecto |
|---|---|
--loss | loss_type |
--task multilabel | multi_label=True |
--smoothing | smoothing, por defecto 0.1 para entrenamiento de una sola etiqueta y 0 para entrenamiento de varias etiquetas |
| Mixup o CutMix habilitado | soft_targets=True |
--asl-* | Argumentos asl_* correspondientes |
--poly-* | Argumentos poly_* correspondientes |
--twoway-* | Argumentos twoway_* correspondientes |
--db-* | Argumentos db_* correspondientes |
--bce-sum | bce_sum |
--bce-target-thresh | bce_target_thresh |
--aug-splits | jsd_splits |
--class-stats | Conteos de clases para las funciones de peso de clase a continuación, y class_counts / num_samples para db |
--loss-pos-weight | pos_weight, resuelto por las funciones de peso de clase a continuación |
--loss-class-weight | class_weight, resuelto por las funciones de peso de clase a continuación |
--loss-weight-* | Opciones para las funciones de peso de clase a continuación |
Consulte la documentación de entrenamiento para el uso de la línea de comandos.
Tipos de pérdida
LOSS_TYPES contiene los nombres aceptados por la fábrica y MULTI_LABEL_LOSS_TYPES los que se pueden usar con multi_label=True.
loss_type | Clase | Objetivos | Notas |
|---|---|---|---|
ce | nn.CrossEntropyLoss, LabelSmoothingCrossEntropy, SoftTargetCrossEntropy | Etiqueta única | La entropía cruzada de softmax, la clase depende de smoothing y soft_targets. Predeterminado de una sola etiqueta |
bce | BinaryCrossEntropy | Ambos | Sigmoid BCE, predeterminado para multietiqueta. Las dianas de índice de clase se codifican en one-hot, bce_target_thresh binariza las dianas suaves y bce_sum suma sobre las clases antes de promediar sobre el lote. |
asl | AsymmetricLossMultiLabel, AsymmetricLossSingleLabel | Ambos | Pérdida asimétrica, enfoque separado para positivos (asl_gamma_pos) y negativos (asl_gamma_neg), un margen de probabilidad para negativos (asl_clip, solo multietiqueta). La variante de una sola etiqueta (softmax) requiere objetivos de índice de clase, sin Mixup/CutMix |
poly | PolyBinaryCrossEntropy, PolyCrossEntropy | Ambos | Poly-1 añade poly_epsilon * (1 - p_t) a BCE / CE; 0 se reduce a BCE / CE. Términos opcionales de focal (poly_gamma) y de balanceo (poly_alpha) para multietiquetas |
jsd | JsdCrossEntropy | Etiqueta única | CE en el split limpio + divergencia de Jensen-Shannon a través de los jsd_splits splits de aumento (AugMix) |
twoway | TwoWayLoss | Multi-etiqueta | Pérdida de multi-etiqueta bidireccional, temperaturas twoway_tp / twoway_tn, solo objetivos binarios |
zlpr | ZlprLoss | Multi-etiqueta | ZLPR, extensión de multi-etiqueta de la CE de softmax sin hiperparámetros, solo objetivos binarios |
db | DistributionBalancedLoss | Multi-etiqueta | Pérdida equilibrada por distribución para datos con cola larga, requiere class_counts y num_samples |
Suavizado de etiquetas y objetivos suaves
smoothing tiene un valor predeterminado de 0 en la fábrica. Para objetivos de una sola etiqueta, la clase objetivo recibe 1 - s + s / C y las
otras s / C (LabelSmoothingCrossEntropy es equivalente a nn.CrossEntropyLoss(label_smoothing=s)), bce utiliza
el mismo suavizado one-hot para objetivos de índice de clase. Para objetivos de varias etiquetas, cada etiqueta binaria se desplaza hacia 0.5, y * (1 - s) + 0.5 * s.
timm.data.Mixup aplica su label_smoothing durante la mezcla y emite objetivos densos (con multi_label=True mezcla y suaviza objetivos multietiqueta densos). En este caso, crea la pérdida con soft_targets=True:
cese convierte enSoftTargetCrossEntropy.bce, multi-labelasl,polyanddbno suavizan las etiquetas de nuevo.- Single-label
asllanza una excepción consoft_targets. twoway/zlprlanzan una excepción si se usasoft_targetsosmoothing, ya que binarizan las etiquetas en 0.5.
Las clases tienen sus propios valores predeterminados cuando se construyen directamente: BinaryCrossEntropy, LabelSmoothingCrossEntropy y JsdCrossEntropy usan smoothing=0.1 por defecto, y AsymmetricLossSingleLabel usa eps=0.1 (su suavizado de etiquetas).
Ponderación de clases
pos_weight multiplica el término positivo de cada clase, equilibrando los positivos frente a los negativos dentro de una clase. class_weight multiplica la pérdida total de cada clase, equilibrando las clases entre sí. Ambas aceptan un único valor o un valor por clase y son compatibles con bce y asl de múltiples etiquetas. Se pueden proporcionar explícitamente o derivar a partir de los recuentos de positivos por clase con compute_class_weights, que devuelve el argumento de pérdida para el que se destinan los pesos y los pesos en sí. Las clases sin positivos se cuentan como si tuvieran uno, y max_weight limita los pesos finales.
method | Argumento | Pesos para una clase con n positivos |
|---|---|---|
neg_pos | pos_weight | ((num_samples - n) / n) ** power |
inv_freq | class_weight | (num_samples / n) ** power, normalizado a una media de 1 |
effective_num | class_weight | (1 - beta) / (1 - beta ** n) (class-balanced), normalizado a una media de 1 |
Los métodos están en CLASS_WEIGHT_METHODS, y CLASS_WEIGHT_METHOD_KINDS asigna cada uno a su argumento de pérdida.
load_class_statslee las cuentas de un archivo JSON con entradaspos_countsynum_samples, tal como las escribeclass_weights.pyen la raíz del repositorio.load_class_weightsanaliza pesos explícitos (un número, una cadena separada por comas, una lista o un archivo JSON / de texto).resolve_class_weightsacepta un nombre de método o pesos explícitos, tal como hacetrain.pycon sus banderas.
La pérdida db toma las cuentas directamente.
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)Notas sobre la pérdida
Precisión. Las pérdidas multi-etiqueta ASL, Poly-1, DB, Two-way y ZLPR se calculan en
float32independientemente del tipo de datos de los logits; de lo contrario, las probabilidades ASL de baja precisión (float16) provocarían un desbordamiento por debajo del rango en su recorte de logaritmo.Reducción. El ASL de múltiples etiquetas admite estos valores de
asl_reduction:Valor Sobre las clases Sobre el lote Notas batchmeanSuma Media Predeterminado sumSuma Suma Reducción de ASL original; la pérdida escala con el tamaño del lote meanMedia Media Como BCE El ASL de una sola etiqueta suma sobre las clases y promedia sobre el lote; la fábrica solo acepta
batchmeanpara él.bce,polyydbde varias etiquetas promedian sobre el lote y las clases (bce_sumsuma sobre las clases parabce).Two-way contrasta el logit negativo más difícil con el logit positivo más difícil entre las clases de cada muestra y entre las muestras de cada clase; solo contribuyen las muestras/clases con un positivo. Sus logits son puntuaciones de clasificación, no probabilidades sigmoidales calibradas, por lo que las métricas con umbral (F1) no son significativas; use mAP.
ZLPR eleva cada logit positivo por encima de cada logit negativo, con 0 como umbral de decisión, por lo que los logits > 0 (sigmoid > 0.5) predicen positivos.
DB pondera cada término (muestra, clase) por la razón entre la probabilidad de muestreo a nivel de clase y la probabilidad de muestreo a nivel de instancia, teniendo en cuenta la co-ocurrencia de etiquetas, desplaza los logits por un prior de clase (
db_init_bias) y escala los logits negativos (db_neg_scale). Las cuentas se limitan a[1, num_samples - 1]. Los parámetros del mapa de reequilibrio y el balance focal son argumentos de clase, no expuestos por la fábrica.JSD espera el lote como
jsd_splitsdivisiones iguales, con las imágenes limpias al principio (comofast_collateorganiza las muestras deAugMixDataset); el término CE utiliza solo la división limpia. El peso de JSD (alpha=12) es un argumento de clase.
API
Funciones de fábrica
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 )
Parámetros
- loss_type — Uno de LOSSTYPES, None selecciona ‘bce’ para multietiquetas y ‘ce’ para objetivos de una sola etiqueta. ‘ce’: entropía cruzada softmax (variantes de suavizado de etiquetas / objetivos suaves según sea necesario), ‘bce’: entropía cruzada binaria (bce args), ‘asl’: Asymmetric Loss, AsymmetricLossMultiLabel para objetivos multietiqueta, en caso contrario el softmax AsymmetricLossSingleLabel, solo objetivos de índice de clase, sin Mixup/CutMix (asl_ args), ‘poly’: pérdida Poly-1, PolyBinaryCrossEntropy (sigmoide) para objetivos multietiqueta, en caso contrario el softmax PolyCrossEntropy (poly* args), ‘jsd’: divergencia de Jensen-Shannon + CE sobre divisiones de aumento, una sola etiqueta (jsd_splits), ‘twoway’: pérdida bidireccional, solo objetivos binarios multietiqueta (twoway args), ‘zlpr’: pérdida ZLPR, solo objetivos binarios multietiqueta, ‘db’: pérdida equilibrada por distribución, multietiqueta (classcounts, num_samples, db args).
- multi_label — Los objetivos son etiquetas binarias independientes y densas con forma (B, C).
- smoothing — Factor de suavizado de etiquetas. Se ignora cuando se establece soft_targets, ya que Mixup/CutMix ya lo aplican al generar las etiquetas suaves.
- soft_targets — Los objetivos llegan como distribuciones suaves densas de Mixup/CutMix en lugar de índices de clase.
- class_weight — Peso de la pérdida por clase, un único valor o uno por clase (‘bce’ y ‘asl’ multietiqueta).
- pos_weight — Peso del término positivo, un único valor o uno por clase (‘bce’ y ‘asl’ multietiqueta).
- bce_target_thresh — Binariza los objetivos suaves que superan este valor (solo ‘bce’).
- bce_sum — Suma la pérdida sobre las clases antes de promediar sobre el lote (solo ‘bce’).
- asl_gamma_pos — Parámetro de enfoque para objetivos positivos (solo ‘asl’).
- asl_gamma_neg — Parámetro de enfoque para objetivos negativos (solo ‘asl’).
- asl_clip — Margen de probabilidad desplazado hacia los negativos, None o 0 lo desactiva (solo ‘asl’ de multi-etiqueta).
- asl_reduction — ‘batchmean’ (suma sobre las clases, media sobre el lote), ‘sum’ (ASL original) o ‘mean’ (solo para ‘asl’ multietiqueta; el ASL de una sola etiqueta siempre usa ‘batchmean’).
- poly_epsilon — Coeficiente Poly-1, 0 se reduce a CE / BCE (solo ‘poly’).
- poly_gamma — Parámetro de enfoque, 0 desactiva el término focal (solo ‘poly’ de multi-etiqueta).
- poly_alpha — Peso de equilibrio positivo/negativo; None lo desactiva (solo para ‘poly’ de multi-etiqueta).
- jsd_splits — Número de divisiones de aumento, debe ser > 1 (solo ‘jsd’).
- twoway_tp — Temperatura de logit positiva (solo ‘twoway’).
- twoway_tn — Temperatura de logit negativa (solo ‘twoway’).
- class_counts — Cantidad de muestras de entrenamiento positivas por clase (solo ‘db’).
- num_samples — Número de muestras de entrenamiento sobre las que se tomaron class_counts (solo ‘db’).
- db_neg_scale — Escala de logits tolerante a negativos, 1 la desactiva (solo ‘db’).
- db_init_bias — Factor de desplazamiento del logit de la clase previa, 0 lo desactiva (solo ‘db’).
- db_focal_gamma — Parámetro de enfoque, 0 desactiva el término focal (solo ‘db’).
Cree el criterio de entrenamiento para una tarea de clasificación.
Funciones de peso de clase
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 )
Parámetros
- pos_counts — Número de muestras positivas por clase (la frecuencia de la clase para objetivos de una sola etiqueta).
- num_samples — Número de muestras sobre las que se tomaron los recuentos.
- method — Uno de ‘neg_pos’: pos_weight = (negativos / positivos) potencia, equilibra los términos positivos y negativos de cada clase, ‘inv_freq’: class_weight proporcional a (num_samples / positivos) potencia, media 1, ‘effective_num’: class_weight equilibrado por clase a partir del número efectivo de muestras (1 - beta ** n) / (1 - beta), https://arxiv.org/abs/1901.05555, media 1.
- power — Exponente para ‘neg_pos’ e ‘inv_freq’, 0.5 da una reponderación más suave (raíz cuadrada).
- beta — Hipervariable de número efectivo para ‘effective_num’.
- max_weight — Límite aplicado a los pesos finales.
Calcule los pesos de pérdida por clase a partir de las cantidades de etiquetas positivas.
Las clases sin positivos se tratan como si tuvieran uno, y cada peso se limita a max_weight si está definido.
timm.loss.load_class_stats
< source >( path: typing.Optional[str] )
Carga los recuentos de positivos por clase y el recuento de muestras desde un archivo de estadísticas de class_weights.py.
timm.loss.load_class_weights
< source >( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]key: str = 'class_weight' )
Analiza los pesos de pérdida a partir de un número, una lista separada por comas o un archivo.
Los archivos son JSON (una lista, o un objeto que contiene la lista bajo key, tal como lo escribe class_weights.py) o texto con números separados por comas o espacios en blanco.
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 )
Parámetros
- value — Un método en CLASS_WEIGHT_METHODS, o pesos explícitos para load_class_weights().
- kind — El argumento de pérdida que se está resolviendo, ‘pos_weight’ o ‘class_weight’.
- class_stats — (counts, num_samples) de load_class_stats(), necesario para los nombres de los métodos.
- power — Consulte compute_class_weights().
- beta — Consulte compute_class_weights().
- max_weight — Consulte compute_class_weights().
Resuelve los pesos de pérdida dados como un nombre de método (calculado a partir de las estadísticas de la clase) o como pesos explícitos.
Clases de pérdida de una sola etiqueta
Pérdida NLL con suavizado de etiquetas.
clase timm.loss.AsymmetricLossSingleLabel
< source >( gamma_pos = 1gamma_neg = 4eps: float = 0.1reduction = 'mean' )
Divergencia de Jensen-Shannon + Pérdida de entropía cruzada
Basado en la implementación aquí: https://github.com/google-research/augmix/blob/master/imagenet.py Del artículo: ‘AugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty - https://arxiv.org/abs/1912.02781
Creado por / Copyright 2020 Ross Wightman
clase timm.loss.PolyCrossEntropy
< source >( epsilon: float = 2.0smoothing: float = 0.0reduction: str = 'mean' )
Parámetros
- epsilon — Coeficiente Poly-1, 0 es la entropía cruzada simple.
- smoothing — Suavizado de etiquetas aplicado a los objetivos de índice de clase. Se asume que los objetivos densos se suavizan aguas arriba (p. ej., mediante Mixup/CutMix).
- reduction — ‘mean’ o ‘sum’ sobre el lote, o ‘none’ para pérdidas por muestra.
Entropía cruzada de softmax Poly-1, CE + epsilon * (1 - p_t), para clasificación de una sola etiqueta.
p_t es la suma de probabilidades de softmax ponderadas por la etiqueta objetivo sum_c(t_c * p_c), por lo que el suavizado de etiquetas y los objetivos suaves (Mixup/CutMix) se aplican a ambos términos, tal como en la referencia.
forward
< source >( x: Tensortarget: Tensor )
Clases de pérdida de múltiples etiquetas
clase 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 )
Parámetros
- smoothing — Suavizado de etiquetas aplicado al codificar en one-hot los objetivos de índice. Se asume que los objetivos densos ya han sido suavizados aguas arriba (p. ej., mediante Mixup/CutMix) a menos que se establezca smooth_dense.
- target_threshold — Binariza (de forma suave) los objetivos que superan este valor.
- weight — Peso de reescalado por clase.
- reduction — Reducción de la pérdida.
- sum_classes — Suma la pérdida sobre las clases antes de promediar sobre el lote.
- pos_weight — Peso de la clase positiva.
- smooth_dense — También aplica suavizado a los objetivos que ya coinciden con la forma de los logits (multi-etiqueta), moviendo cada objetivo binario hacia 0.5.
BCE con one-hot opcional a partir de objetivos densos, suavizado de etiquetas y umbralización NOTA para experimentos que comparan CE con BCE /w suavizado de etiquetas, se puede eliminar
clase 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 )
Parámetros
- gamma_neg — Parámetro de enfoque para objetivos negativos.
- gamma_pos — Parámetro de enfoque para objetivos positivos.
- clip — Margen de probabilidad desplazado hacia los negativos (recorte asimétrico), desactivado si es None o 0.
- eps — Probabilidad mínima a la que se limita antes del logaritmo.
- disable_torch_grad_focal_loss — No realizar la retropropagación a través de los pesos de enfoque.
- smoothing — Suavizado de etiquetas, desplaza cada objetivo (denso, binario independiente) hacia 0,5.
- reduction — ‘batchmean’ suma sobre las clases y promedia sobre el lote, ‘sum’ suma sobre el lote y las clases (la reducción original de ASL, escala con el tamaño del lote), ‘mean’ promedia sobre el lote y las clases, ‘none’ conserva la pérdida por elemento.
- weight — Peso de reescalado por clase.
- pos_weight — Peso del término positivo, un único valor o uno por clase.
Pérdida asimétrica (ASL) para clasificación multietiqueta, https://arxiv.org/abs/2009.14119
forward
< source >( x: Tensory: Tensor )
clase timm.loss.PolyBinaryCrossEntropy
< source >( epsilon: float = 2.0gamma: float = 0.0alpha: typing.Optional[float] = Nonesmoothing: float = 0.0reduction: str = 'mean' )
Parámetros
- epsilon — Coeficiente Poly-1, 0 es BCE simple (o pérdida focal).
- gamma — Parámetro de enfoque, 0 desactiva el término focal.
- alpha — Peso de equilibrio positivo/negativo. None lo desactiva.
- smoothing — Suavizado de etiquetas, desplaza cada objetivo (denso, binario independiente) hacia 0,5.
- reduction — ‘mean’ promedia sobre el lote y las clases (como BCE), ‘batchmean’ suma sobre las clases y promedia sobre el lote, ‘sum’ suma sobre ambos, ‘none’ conserva la pérdida por elemento.
Pérdida sigmoide (focal) Poly-1, FL + epsilon * (1 - p_t) ** (gamma + 1), para clasificación multietiqueta.
Con gamma = 0, esto es BCE + epsilon * (1 - p_t) por clase. Con alpha definido, los positivos se ponderan por alpha y los negativos por 1 - alpha en ambos términos, como en la referencia.
forward
< source >( x: Tensortarget: Tensor )
clase 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' )
Parámetros
- class_counts — Cantidad de muestras positivas por clase en el conjunto de entrenamiento.
- num_samples — Número de muestras de entrenamiento sobre las que se tomaron las cuentas.
- map_alpha — Peso mínimo del mapa de reequilibrio.
- map_beta — Escala del mapa de reequilibrio.
- map_mu — Umbral del mapa de reequilibrio.
- neg_scale — Escala de logits negativos (lambda), 1 desactiva la escalada tolerante a negativos.
- init_bias — Factor de desplazamiento del logit de la clase previa (kappa), 0 lo desactiva.
- focal_gamma — Parámetro de enfoque, 0 desactiva el término focal (y focal_balance).
- focal_balance — Escala constante de la pérdida focal.
- smoothing — Suavizado de etiquetas, mueve cada objetivo hacia 0.5.
- reduction — ‘mean’ promedia sobre el lote y las clases (la escala de referencia), ‘batchmean’ suma sobre las clases y promedia sobre el lote, ‘sum’ suma sobre ambos, ‘none’ conserva la pérdida por elemento.
Pérdida equilibrada por distribución (DB) para clasificación multietiqueta con cola larga.
BCE con sigmoide con dos adiciones:
- Ponderación reequilibrada: cada término (muestra, clase) se pondera por la relación entre la probabilidad de muestreo a nivel de clase 1 / n_i y la probabilidad a nivel de instancia de la muestra sum_j(y_j / n_j), lo cual tiene en cuenta la coocurrencia de etiquetas de cada muestra, suavizada como alpha + sigmoid(beta * (r - mu)).
- Regularización tolerante a negativos: los logits se desplazan mediante un sesgo de prior de clase, y los términos negativos utilizan un logit escalado, softplus(neg_scale * z) / neg_scale, para que los muchos negativos de las clases raras no se supriman en exceso. Un término focal opcional (1 - p_t) ** gamma sigue la configuración de referencia DB.
Los objetivos suaves (Mixup/CutMix) ponderan los términos positivos y negativos, mientras que los pesos de reequilibrio utilizan los objetivos tal como se proporcionan. Ambos coinciden con la referencia para objetivos binarios.
forward
< source >( x: Tensortarget: Tensor )
clase timm.loss.TwoWayLoss
< source >( tp: float = 4.0tn: float = 1.0 )
Pérdida de multi-etiqueta bidireccional.
Contrasta el logit negativo más difícil (soft-max) con el logit positivo más difícil (soft-min) en dos direcciones, a través de las clases de cada muestra y a través de las muestras de cada clase en el lote. Solo las muestras / clases con al menos un positivo contribuyen a la dirección respectiva.
Los objetivos se binarizan, las entradas superiores a 0.5 son positivas. Los logits son puntuaciones de clasificación, no están calibrados como probabilidades sigmoides independientes.
forward
< source >( x: Tensortarget: Tensor )
Pérdida ZLPR, la extensión de multietiquetas de la entropía cruzada softmax.
Por muestra, log(1 + sum_neg exp(s_j)) + log(1 + sum_pos exp(-s_i)). Cada logit positivo se empuja por encima de cada logit negativo y 0 actúa como umbral de decisión, por lo que los logits > 0 (sigmoid > 0.5) predicen positivos. Sin hiperparámetros, y la pérdida no crece con el número de clases negativas como lo hace el BCE por clase.
Los objetivos se binarizan; las entradas superiores a 0.5 son positivas.
forward
< source >( x: Tensortarget: Tensor )