# Các hàm mất mát

Trang này chứa tài liệu tham khảo API cho các hàm mất (losses) phân loại có trong `timm`, cùng với tổng quan về cách chúng được tạo và cấu hình thông qua nhà máy mất (loss factory).

## Cách sử dụng

Losses được tạo theo tên bằng [`create_classification_loss`](#timm.loss.create_classification_loss). `multi_label` chọn giữa các mục tiêu đơn nhãn (chỉ số lớp, hoặc các phân phối mềm dày đặc từ Mixup/CutMix) và các mục tiêu đa nhãn (các nhãn nhị phân độc lập dày đặc có hình dạng `(B, C)`), với `loss_type=None` nhà máy sẽ chọn `ce` hoặc `bce` cho phù hợp. Các đối số cụ thể của loss được đặt tiền tố là tên của loss (`asl_*`, `poly_*`, `db_*`, ...) và bị bỏ qua bởi các loss khác. Nhà máy sẽ gây ra lỗi với các tổ hợp mà một loss không hỗ trợ, ví dụ như trọng số lớp cho các loss khác `bce` / đa nhãn `asl`, các đối số `bce_*` hoặc `class_counts` cho các loss khác, hoặc một loss chỉ dành cho đa nhãn mà không có `multi_label` (hoặc một loss chỉ dành cho đơn nhãn mà có nó).

```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.)
```

Tệp kịch bản huấn luyện (`train.py`) ánh xạ các tùy chọn của nó vào nhà máy loss như sau:

| Tùy chọn CLI hoặc điều kiện | Đối số hoặc hiệu ứng của nhà máy |
|---|---|
| `--loss` | `loss_type` |
| `--task multilabel` | `multi_label=True` |
| `--smoothing` | `smoothing`, mặc định là 0,1 cho huấn luyện nhãn đơn và 0 cho huấn luyện nhãn đa |
| Bật Mixup hoặc CutMix | `soft_targets=True` |
| `--asl-*` | Các đối số `asl_*` tương ứng |
| `--poly-*` | Các đối số `poly_*` tương ứng |
| `--twoway-*` | Các đối số `twoway_*` tương ứng |
| `--db-*` | Các đối số `db_*` tương ứng |
| `--bce-sum` | `bce_sum` |
| `--bce-target-thresh` | `bce_target_thresh` |
| `--aug-splits` | `jsd_splits` |
| `--class-stats` | Số lượng lớp cho các hàm trọng số lớp bên dưới, và `class_counts` / `num_samples` cho `db` |
| `--loss-pos-weight` | `pos_weight`, được xác định bởi các hàm trọng số lớp bên dưới |
| `--loss-class-weight` | `class_weight`, được xác định bởi các hàm trọng số lớp bên dưới |
| `--loss-weight-*` | Các tùy chọn cho các hàm trọng số lớp bên dưới |

Xem [tài liệu huấn luyện](../training_script#multi-label-classification) để biết cách sử dụng dòng lệnh.

### Các loại loss

`LOSS_TYPES` chứa các tên được chấp nhận bởi nhà máy và `MULTI_LABEL_LOSS_TYPES` chứa các tên có thể dùng với `multi_label=True`.

| `loss_type` | Lớp | Mục tiêu | Ghi chú |
|---|---|---|---|
| `ce` | `nn.CrossEntropyLoss`, [`LabelSmoothingCrossEntropy`](#timm.loss.cross_entropy.LabelSmoothingCrossEntropy), [`SoftTargetCrossEntropy`](#timm.loss.cross_entropy.SoftTargetCrossEntropy) | Nhãn đơn | Softmax cross-entropy, lớp phụ thuộc vào `smoothing` và `soft_targets`. Mặc định là nhãn đơn |
| `bce` | [`BinaryCrossEntropy`](#timm.loss.binary_cross_entropy.BinaryCrossEntropy) | Cả hai | Sigmoid BCE, mặc định cho đa nhãn. Mục tiêu chỉ số lớp được mã hóa one-hot, `bce_target_thresh` nhị phân hóa các mục tiêu mềm, `bce_sum` cộng gộp trên các lớp trước khi lấy trung bình trên batch |
| `asl` | [`AsymmetricLossMultiLabel`](#timm.loss.asymmetric_loss.AsymmetricLossMultiLabel), [`AsymmetricLossSingleLabel`](#timm.loss.asymmetric_loss.AsymmetricLossSingleLabel) | Cả hai | [Asymmetric Loss](https://arxiv.org/abs/2009.14119), tách biệt việc tập trung cho các mẫu dương (`asl_gamma_pos`) và âm (`asl_gamma_neg`), một biên xác suất cho các mẫu âm (`asl_clip`, chỉ dành cho đa nhãn). Biến thể đơn nhãn (softmax) cần các mục tiêu chỉ số lớp, không hỗ trợ Mixup/CutMix |
| `poly` | [`PolyBinaryCrossEntropy`](#timm.loss.poly_loss.PolyBinaryCrossEntropy), [`PolyCrossEntropy`](#timm.loss.poly_loss.PolyCrossEntropy) | Cả hai | [Poly-1](https://arxiv.org/abs/2204.12511), thêm `poly_epsilon * (1 - p_t)` vào BCE / CE, `0` thu gọn về BCE / CE. Các số hạng focal tùy chọn (`poly_gamma`) và cân bằng (`poly_alpha`) cho đa nhãn |
| `jsd` | [`JsdCrossEntropy`](#timm.loss.jsd.JsdCrossEntropy) | Nhãn đơn | CE trên tập dữ liệu sạch + độ phân kỳ Jensen-Shannon trên `jsd_splits` tập dữ liệu tăng cường ([AugMix](https://arxiv.org/abs/1912.02781)) |
| `twoway` | [`TwoWayLoss`](#timm.loss.two_way_loss.TwoWayLoss) | Nhiều nhãn | [Two-way Multi-Label Loss](https://staff.aist.go.jp/takumi.kobayashi/publication/2023/CVPR2023.pdf), nhiệt độ `twoway_tp` / `twoway_tn`, chỉ dành cho mục tiêu nhị phân |
| `zlpr` | [`ZlprLoss`](#timm.loss.zlpr_loss.ZlprLoss) | Nhiều nhãn | [ZLPR](https://arxiv.org/abs/2208.02955), mở rộng đa nhãn của softmax CE không có siêu tham số, chỉ dành cho mục tiêu nhị phân |
| `db` | [`DistributionBalancedLoss`](#timm.loss.distribution_balanced_loss.DistributionBalancedLoss) | Nhiều nhãn | [Loss cân bằng phân bố](https://arxiv.org/abs/2007.09654) cho dữ liệu đuôi dài, cần `class_counts` và `num_samples` |

### Làm mượt nhãn và mục tiêu mềm

`smoothing` mặc định là 0 trong nhà máy. Đối với mục tiêu đơn nhãn, lớp đích nhận `1 - s + s / C` và các lớp khác nhận `s / C` (`LabelSmoothingCrossEntropy` tương đương với `nn.CrossEntropyLoss(label_smoothing=s)`), `bce` sử dụng cùng một phương pháp làm mượt one-hot cho các mục tiêu chỉ số lớp. Đối với mục tiêu đa nhãn, mỗi nhãn nhị phân được dịch chuyển về phía 0.5, `y * (1 - s) + 0.5 * s`.

`timm.data.Mixup` áp dụng `label_smoothing` của nó trong khi trộn và xuất ra các mục tiêu dạng dense (với `multi_label=True`, nó trộn và làm mịn các mục tiêu đa nhãn dạng dense). Trong trường hợp này, hãy tạo loss với `soft_targets=True`:

- **`ce`** trở thành `SoftTargetCrossEntropy`.
- **`bce`, đa nhãn `asl`, `poly` và `db`** không làm mượt các mục tiêu một lần nữa.
- **Single-label `asl`** sẽ gây ra lỗi khi sử dụng `soft_targets`.
- **`twoway` / `zlpr`** sẽ gây ra lỗi nếu dùng cùng với `soft_targets` hoặc `smoothing` vì chúng nhị phân hóa các target tại 0.5.

Các lớp có giá trị mặc định riêng khi được khởi tạo trực tiếp, `BinaryCrossEntropy`, `LabelSmoothingCrossEntropy` và `JsdCrossEntropy` mặc định là `smoothing=0.1` và `AsymmetricLossSingleLabel` là `eps=0.1` (làm mịn nhãn của nó).

### Trọng số lớp

`pos_weight` nhân vào số hạng dương của mỗi lớp, cân bằng giữa các mẫu dương và âm trong cùng một lớp. `class_weight` nhân vào toàn bộ loss của mỗi lớp, cân bằng giữa các lớp với nhau. Cả hai đều nhận một giá trị duy nhất hoặc một giá trị cho mỗi lớp và được hỗ trợ bởi `bce` và `asl` đa nhãn. Chúng có thể được cung cấp trực tiếp hoặc suy ra từ số lượng mẫu dương của từng lớp bằng [`compute_class_weights`](#timm.loss.compute_class_weights), hàm này trả về đối số loss mà các trọng số áp dụng cho và chính các trọng số đó. Các lớp không có mẫu dương được tính là có một mẫu, và `max_weight` giới hạn các trọng số cuối cùng.

| `method` | Tham số | Trọng số cho một lớp có `n` mẫu dương |
|---|---|---|
| `neg_pos` | `pos_weight` | `((num_samples - n) / n) ** power` |
| `inv_freq` | `class_weight` | `(num_samples / n) ** power`, được chuẩn hóa để có trung bình bằng 1 |
| `effective_num` | `class_weight` | `(1 - beta) / (1 - beta ** n)` ([class-balanced](https://arxiv.org/abs/1901.05555)), được chuẩn hóa để có giá trị trung bình bằng 1 |

Các phương pháp nằm trong `CLASS_WEIGHT_METHODS`, và `CLASS_WEIGHT_METHOD_KINDS` ánh xạ mỗi phương pháp đến đối số loss tương ứng.

- [`load_class_stats`](#timm.loss.load_class_stats) đọc các số đếm từ một tệp JSON có các mục `pos_counts` và `num_samples`, như đã được ghi bởi `class_weights.py` ở thư mục gốc của kho.
- [`load_class_weights`](#timm.loss.load_class_weights) phân tích các trọng số tường minh (một số, một chuỗi phân tách bằng dấu phẩy, một danh sách, hoặc một tệp JSON / văn bản).
- [`resolve_class_weights`](#timm.loss.resolve_class_weights) chấp nhận tên phương pháp hoặc trọng số tường minh, giống như cách `train.py` xử lý các cờ của nó.

Mất `db` nhận các giá trị đếm trực tiếp.

```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)
```

### Ghi chú về Loss

- **Độ chính xác.** Các hàm mất đa nhãn ASL, Poly-1, DB, Two-way và ZLPR được tính trong `float32` bất kể kiểu dữ liệu của logit, vì xác suất ASL ở độ chính xác thấp (`float16`) sẽ bị tràn dưới (underflow) khi áp dụng kẹp log (log clamp).
- **Giảm.** ASL đa nhãn hỗ trợ các giá trị `asl_reduction` sau:

  | Giá trị | Trên các lớp | Trên toàn bộ lô | Ghi chú |
  |---|---|---|---|
  | `batchmean` | Tổng | Trung bình | Mặc định |
  | `sum` | Tổng | Tổng | Giảm ASL gốc; loss tỷ lệ với kích thước batch |
  | `mean` | Trung bình | Trung bình | Giống BCE |

  ASL cho nhãn đơn lẻ (single-label) cộng trên các lớp và lấy trung bình trên batch, nhà máy (factory) chỉ chấp nhận `batchmean` cho nó. `bce`, đa nhãn (multi-label) `poly` và `db` lấy trung bình trên batch và các lớp (`bce_sum` cộng trên các lớp cho `bce`).

- **Two-way** so sánh logit âm khó nhất với logit dương khó nhất trên các lớp của mỗi mẫu và trên các mẫu của mỗi lớp, chỉ các mẫu / lớp có giá trị dương mới đóng góp. Các logit của nó là điểm xếp hạng, không phải xác suất sigmoid đã hiệu chuẩn, do đó các chỉ số có ngưỡng (F1) không có ý nghĩa, hãy dùng mAP.
- **ZLPR** đẩy mọi logit dương lên trên mọi logit âm với ngưỡng quyết định là 0, do đó các logit > 0 (sigmoid > 0.5) dự đoán các trường hợp dương.
- **DB** nhân mỗi hạng tử (mẫu, lớp) với tỷ số giữa xác suất lấy mẫu ở cấp độ lớp và cấp độ thực thể, có tính đến sự đồng hiện của nhãn, dịch các logits bằng tiên nghiệm của lớp (`db_init_bias`) và nhân các logits âm (`db_neg_scale`). Các giá trị đếm được kẹp trong khoảng `[1, num_samples - 1]`. Tham số của bản đồ cân bằng lại và cân bằng focal là các đối số của lớp, không được phơi bày bởi nhà máy.
- **JSD** kỳ vọng batch được chia thành `jsd_splits` phần bằng nhau, với các ảnh sạch ở đầu (theo cách `fast_collate` sắp xếp các mẫu của `AugMixDataset`), trong đó số hạng CE chỉ sử dụng phần sạch. Trọng số JSD (`alpha=12`) là một đối số của lớp.

## API

### Hàm nhà máy[[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)
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/_loss_factory.py#L31)

**Tham số:**

loss_type : Một trong các LOSS_TYPES, None sẽ chọn 'bce' cho nhãn đa nhãn và 'ce' cho nhãn đơn. 'ce': entropy chéo softmax (các biến thể làm mịn nhãn / mục tiêu mềm khi cần), 'bce': entropy chéo nhị phân (các đối số bce_*), 'asl': Asymmetric Loss, AsymmetricLossMultiLabel cho mục tiêu đa nhãn, ngược lại là softmax AsymmetricLossSingleLabel, chỉ cho mục tiêu chỉ số lớp, không có Mixup/CutMix (các đối số asl_*), 'poly': tổn thất Poly-1, PolyBinaryCrossEntropy (sigmoid) cho mục tiêu đa nhãn, ngược lại là softmax PolyCrossEntropy (các đối số poly_*), 'jsd': phân kỳ Jensen-Shannon + CE trên các phần chia tăng cường, nhãn đơn (jsd_splits), 'twoway': tổn thất Two-way, chỉ cho mục tiêu đa nhãn nhị phân (các đối số twoway_*), 'zlpr': tổn thất ZLPR, chỉ cho mục tiêu đa nhãn nhị phân, 'db': tổn thất Distribution-Balanced, đa nhãn (class_counts, num_samples, các đối số db_*).

multi_label : Các mục tiêu là nhãn nhị phân độc lập dạng đặc, có hình dạng (B, C).

smoothing : Hệ số làm mịn nhãn. Bỏ qua khi soft_targets được đặt, vì Mixup/CutMix đã áp dụng nó khi tạo ra các nhãn mềm.

soft_targets : Các mục tiêu đến dưới dạng các phân phối mềm dày đặc từ Mixup/CutMix thay vì các chỉ số lớp.

class_weight : Trọng số loss cho từng lớp, một giá trị duy nhất hoặc một giá trị cho mỗi lớp ('bce' và 'asl' đa nhãn).

pos_weight : Trọng số của thuật ngữ dương, một giá trị duy nhất hoặc một giá trị cho mỗi lớp ('bce' và 'asl' đa nhãn).

bce_target_thresh : Nhị phân hóa các mục tiêu mềm lớn hơn giá trị này (chỉ áp dụng cho 'bce').

bce_sum : Cộng loss trên các lớp trước khi lấy trung bình trên batch (chỉ áp dụng cho 'bce').

asl_gamma_pos : Tham số tập trung cho các mục tiêu dương (chỉ 'asl').

asl_gamma_neg : Tham số tập trung cho các mục tiêu âm (chỉ 'asl').

asl_clip : Biên độ xác suất dịch sang các nhãn âm, None hoặc 0 để tắt (chỉ áp dụng cho 'asl' đa nhãn).

asl_reduction : 'batchmean' (tổng trên các lớp, trung bình trên batch), 'sum' (ASL gốc), hoặc 'mean' (chỉ cho 'asl' đa nhãn, ASL đơn nhãn luôn dùng 'batchmean').

poly_epsilon : Hệ số Poly-1, 0 giảm xuống CE / BCE (chỉ 'poly').

poly_gamma : Tham số Focusing, 0 vô hiệu hóa số hạng focal (chỉ áp dụng cho 'poly' đa nhãn).

poly_alpha : Cân bằng trọng số dương / âm, None để tắt (chỉ áp dụng cho 'poly' đa nhãn).

jsd_splits : Số lượng phần chia tăng cường, phải > 1 (chỉ dành cho 'jsd').

twoway_tp : Nhiệt độ logit dương (chỉ dành cho 'twoway').

twoway_tn : Nhiệt độ logit âm (chỉ dành cho 'twoway').

class_counts : Số lượng mẫu huấn luyện dương cho mỗi lớp (chỉ 'db').

num_samples : Số lượng mẫu huấn luyện mà class_counts được tính trên (chỉ 'db').

db_neg_scale : Thang logit dung sai âm, 1 để tắt ('db' only).

db_init_bias : Hệ số dịch logit tiên nghiệm của lớp, 0 để tắt (chỉ 'db').

db_focal_gamma : Tham số Focusing, 0 vô hiệu hóa số hạng focal (chỉ 'db').

Tạo tiêu chí huấn luyện cho một tác vụ phân loại.

### Hàm trọng số lớp[[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)
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/class_weights.py#L19)

**Tham số:**

pos_counts : Số lượng mẫu dương cho mỗi lớp (tần suất lớp đối với mục tiêu đơn nhãn).

num_samples : Số lượng mẫu mà các giá trị đếm được lấy trên đó.

method : Một trong 'neg_pos': pos_weight = (negatives / positives) ** power, cân bằng các số hạng dương và âm của mỗi lớp, 'inv_freq': class_weight tỷ lệ với (num_samples / positives) ** power, trung bình 1, 'effective_num': class_weight cân bằng lớp từ số lượng mẫu hiệu dụng (1 - beta ** n) / (1 - beta), https://arxiv.org/abs/1901.05555, trung bình 1.

power : Số mũ cho 'neg_pos' và 'inv_freq', 0.5 cho phép tái trọng số hóa mềm hơn (căn bậc hai).

beta : Siêu tham số hiệu quả cho 'effective_num'.

max_weight : Giới hạn áp dụng cho trọng số cuối cùng.

**Trả về:**

Tham số loss, các trọng số được áp dụng ('pos_weight' hoặc 'class_weight') và các trọng số float32.

Tính trọng số loss cho từng lớp từ số lượng nhãn dương.

Các lớp không có mẫu dương nào được coi là có một mẫu dương, và mọi trọng số đều bị giới hạn ở max_weight nếu được đặt.

#### timm.loss.load_class_stats[[timm.loss.load_class_stats]]

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/class_weights.py#L71)

**Tham số:**

path : tệp JSON chứa các mục 'pos_counts' và 'num_samples'. None hoặc chuỗi rỗng sẽ trả về None.

**Trả về:**

Số lượng float32 và số lượng mẫu mà chúng được lấy trên đó.

Tải số lượng mẫu dương cho từng lớp và tổng số mẫu từ tệp thống kê 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')
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/class_weights.py#L94)

**Tham số:**

value : Giá trị trọng số, danh sách hoặc đường dẫn. None hoặc chuỗi rỗng sẽ trả về None.

key : Mục để đọc từ các đối tượng JSON, ví dụ 'pos_weight' hoặc 'class_weight'.

**Trả về:**

Một float cho một giá trị đơn lẻ (được phát sóng trên các lớp), nếu không thì là một tensor float32 1 chiều.

Phân tích trọng số tổn thất từ một số, một danh sách phân tách bằng dấu phẩy, hoặc một tệp.

Các tệp là JSON (một danh sách, hoặc một đối tượng chứa danh sách dưới `key`, như được ghi bởi class_weights.py) hoặc văn bản với các số được phân tách bằng dấu phẩy / khoảng trắng.

#### 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)
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/class_weights.py#L140)

**Tham số:**

value : Một phương thức trong CLASS_WEIGHT_METHODS, hoặc trọng số rõ ràng cho load_class_weights().

kind : Đối số loss được giải quyết, 'pos_weight' hoặc 'class_weight'.

class_stats : (counts, num_samples) từ load_class_stats(), bắt buộc cho các tên phương pháp.

power : Xem compute_class_weights().

beta : Xem compute_class_weights().

max_weight : Xem compute_class_weights().

Giải quyết trọng số tổn thất được cung cấp dưới dạng tên phương thức (được tính từ thống kê của lớp) hoặc dưới dạng trọng số tường minh.

### Các lớp Loss cho nhãn đơn[[timm.loss.LabelSmoothingCrossEntropy]]

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/cross_entropy.py#L11)

Mất NLL với làm mịn nhãn.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/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')
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/asymmetric_loss.py#L102)

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/asymmetric_loss.py#L113)

" Tham số ---------- x: logits đầu vào y: nhãn đích (vector 1-hot)

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/jsd.py#L8)

Divergence Jensen-Shannon + Cross-Entropy Loss

Dựa trên cài đặt tại đây: https://github.com/google-research/augmix/blob/master/imagenet.py Từ bài báo: 'AugMix: A Simple Data Processing Method to Improve Robustness and Uncertainty - https://arxiv.org/abs/1912.02781

Được tạo bởi / Bản quyền 2020 Ross Wightman

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/poly_loss.py#L19)

**Tham số:**

epsilon : Hệ số Poly-1, 0 là cross-entropy thông thường.

smoothing : Nhẵn nhãn (label smoothing) được áp dụng cho các mục tiêu chỉ số lớp. Các mục tiêu dạng đặc (dense) được giả định là đã được làm mềm ở phía trước (ví dụ: bằng Mixup/CutMix).

reduction : 'mean' hoặc 'sum' trên batch, hoặc 'none' cho tổn thất theo từng mẫu.

Poly-1 softmax cross-entropy, CE + epsilon * (1 - p_t), cho phân loại nhãn đơn.

p_t là tổng xác suất softmax có trọng số mục tiêu sum_c(t_c * p_c), do đó việc làm mịn nhãn và các mục tiêu mềm (Mixup/CutMix) được áp dụng cho cả hai số hạng, giống như trong tài liệu tham khảo.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/poly_loss.py#L41)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

target : Chỉ số lớp (batch_size,) hoặc phân phối mục tiêu dày đặc (batch_size, num_classes).

### Các lớp Loss cho nhiều nhãn[[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)
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/binary_cross_entropy.py#L12)

**Tham số:**

smoothing : Nhẵn nhãn (label smoothing) được áp dụng khi mã hóa one-hot cho các mục tiêu dạng chỉ số. Các mục tiêu dạng dense được giả định là đã được làm nhẵn ở phía trước (ví dụ: bằng Mixup/CutMix) trừ khi đặt smooth_dense.

target_threshold : Nhị phân hóa (mềm) các mục tiêu lớn hơn giá trị này.

weight : Trọng số điều chỉnh tỷ lệ theo từng lớp.

reduction : Giảm loss.

sum_classes : Cộng loss trên các lớp trước khi lấy trung bình trên batch.

pos_weight : Trọng số lớp dương.

smooth_dense : Áp dụng làm mịn (smoothing) cho cả các mục tiêu (targets) đã khớp với hình dạng của logit (multi-label), di chuyển từng mục tiêu nhị phân về phía 0.5.

BCE với tùy chọn one-hot từ các mục tiêu dạng dense, làm mịn nhãn, ngưỡng hóa GHI CHÚ cho các thí nghiệm so sánh CE với BCE /w làm mịn nhãn, có thể xóa

#### 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)
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/asymmetric_loss.py#L7)

**Tham số:**

gamma_neg : Tham số tập trung cho các mục tiêu âm.

gamma_pos : Tham số tập trung cho các mục tiêu dương.

clip : Biên độ xác suất bị dịch sang phía các mẫu âm (cắt xén bất đối xứng), bị vô hiệu hóa nếu là None hoặc 0.

eps : Xác suất tối thiểu được kẹp lại trước khi lấy log.

disable_torch_grad_focal_loss : Không thực hiện backprop qua các trọng số tập trung.

smoothing : Label smoothing, dịch chuyển mỗi mục tiêu (mật độ cao, nhị phân độc lập) về phía 0.5.

reduction : 'batchmean' cộng trên các lớp và lấy trung bình trên batch, 'sum' cộng trên batch và các lớp (phương pháp giảm ASL gốc, tỷ lệ với kích thước batch), 'mean' lấy trung bình trên batch và các lớp, 'none' giữ nguyên loss cho từng phần tử.

weight : Trọng số điều chỉnh tỷ lệ theo từng lớp.

pos_weight : Trọng số của số hạng dương, một giá trị duy nhất hoặc một giá trị cho mỗi lớp.

Mất đối xứng (ASL) cho phân loại nhiều nhãn, https://arxiv.org/abs/2009.14119

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/asymmetric_loss.py#L52)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

y : Mục tiêu dạng Dense (multi-hot hoặc soft) (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')
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/poly_loss.py#L64)

**Tham số:**

epsilon : Hệ số Poly-1, 0 là BCE thuần túy (hoặc focal loss).

gamma : Tham số Focusing, 0 để tắt thành phần focal.

alpha : Cân bằng trọng số dương / âm, None để tắt tính năng này.

smoothing : Label smoothing, dịch chuyển mỗi mục tiêu (mật độ cao, nhị phân độc lập) về phía 0.5.

reduction : 'mean' lấy trung bình trên batch và các lớp (như BCE), 'batchmean' cộng trên các lớp và lấy trung bình trên batch, 'sum' cộng trên cả hai, 'none' giữ nguyên loss cho từng phần tử.

Mất Poly-1 sigmoid (focal), FL + epsilon * (1 - p_t) ** (gamma + 1), cho phân loại đa nhãn.

Với gamma = 0, đây là BCE + epsilon * (1 - p_t) cho mỗi lớp. Khi alpha được đặt, các mẫu dương được trọng số hóa bởi alpha và các mẫu âm bởi 1 - alpha trong cả hai số hạng, như trong tài liệu tham khảo.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/poly_loss.py#L98)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

target : Mục tiêu dạng Dense (multi-hot hoặc soft) (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')
```

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/distribution_balanced_loss.py#L16)

**Tham số:**

class_counts : Số lượng mẫu dương cho mỗi lớp trên tập huấn luyện.

num_samples : Số lượng mẫu huấn luyện mà các giá trị đếm được lấy trên đó.

map_alpha : Trọng số tối thiểu của bản đồ cân bằng lại.

map_beta : Thang của bản đồ cân bằng lại.

map_mu : Ngưỡng của bản đồ cân bằng lại.

neg_scale : Thang logit âm (lambda), 1 để tắt việc mở rộng dung sai âm.

init_bias : Hệ số dịch logit tiên nghiệm của lớp (kappa), 0 để tắt.

focal_gamma : Tham số Focusing, 0 sẽ vô hiệu hóa số hạng focal (và focal_balance).

focal_balance : Thang đo cố định của tổn thất tiêu điểm (focal loss).

smoothing : Làm mượt nhãn, dịch chuyển mỗi mục tiêu về phía 0.5.

reduction : 'mean' lấy trung bình trên batch và các lớp (thang đo tham chiếu), 'batchmean' cộng trên các lớp và lấy trung bình trên batch, 'sum' cộng trên cả hai, 'none' giữ nguyên loss cho từng phần tử.

Mất cân bằng phân phối (DB) cho phân loại đa nhãn có đuôi dài.

Sigmoid BCE với hai bổ sung:
* Trọng số được cân bằng lại: mỗi hạng tử (mẫu, lớp) được nhân với tỷ số giữa xác suất lấy mẫu ở cấp độ lớp 1 / n_i và xác suất ở cấp độ bản thể của mẫu sum_j(y_j / n_j), trong đó có tính đến sự đồng hiện của nhãn cho từng mẫu, được làm mượt theo công thức alpha + sigmoid(beta * (r - mu)).
* Quy tắc hóa dung nạp âm: các logits được dịch chuyển bởi một độ chệch tiên nghiệm của lớp, và các số hạng âm sử dụng logits đã được nhân hệ số, softplus(neg_scale * z) / neg_scale, để các mẫu âm nhiều của các lớp hiếm không bị ức chế quá mức.
Thuật ngữ focal tùy chọn (1 - p_t) ** gamma tuân theo cấu hình tham chiếu DB.

Mục tiêu mềm (Mixup/CutMix) gán trọng số cho các hạng tử dương và âm, trong khi các trọng số cân bằng lại sử dụng các mục tiêu như đã cho. Cả hai đều khớp với tham chiếu cho các mục tiêu nhị phân.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/distribution_balanced_loss.py#L84)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

target : Mục tiêu dạng Dense (multi-hot hoặc soft) (batch_size, num_classes).

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/two_way_loss.py#L17)

**Tham số:**

tp : Nhiệt độ của soft-min trên các logits dương.

tn : Nhiệt độ của hàm soft-max trên các logit âm.

Mất đa nhãn hai chiều.

So sánh logit âm khó nhất (soft-max) với logit dương khó nhất (soft-min) theo hai hướng: qua các lớp của mỗi mẫu và qua các mẫu của mỗi lớp trong batch. Chỉ các mẫu / lớp có ít nhất một giá trị dương mới đóng góp vào hướng tương ứng.

Targets được nhị phân hóa, các mục có giá trị lớn hơn 0.5 là dương. Logits là điểm xếp hạng, chúng không được hiệu chuẩn như các xác suất sigmoid độc lập.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/two_way_loss.py#L38)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

target : Mục tiêu nhị phân dạng đặc (batch_size, num_classes).

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/zlpr_loss.py#L9)

Mất ZLPR, phần mở rộng đa nhãn của entropy chéo softmax.

Mỗi mẫu, log(1 + sum_neg exp(s_j)) + log(1 + sum_pos exp(-s_i)). Mọi logit dương đều được đẩy lên trên mọi logit âm và 0 đóng vai trò là ngưỡng quyết định, do đó các logit > 0 (sigmoid > 0.5) dự đoán các mẫu dương. Không có siêu tham số, và hàm mất mát không tăng theo số lượng lớp âm như BCE theo từng lớp.

Targets được nhị phân hóa, các mục có giá trị lớn hơn 0.5 là dương.

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

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

[Nguồn](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/loss/zlpr_loss.py#L19)

**Tham số:**

x : Logit đầu vào (batch_size, num_classes).

target : Mục tiêu nhị phân dạng đặc (batch_size, num_classes).