timm documentation
Các hàm mất mát
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. 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ó).
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 để 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, 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 | 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, AsymmetricLossSingleLabel | Cả hai | Asymmetric Loss, 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, PolyCrossEntropy | Cả hai | Poly-1, 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 | 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) |
twoway | TwoWayLoss | Nhiều nhãn | Two-way Multi-Label Loss, nhiệt độ twoway_tp / twoway_tn, chỉ dành cho mục tiêu nhị phân |
zlpr | ZlprLoss | Nhiều nhãn | ZLPR, 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 | Nhiều nhãn | Loss cân bằng phân bố 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 phương pháp làm mượt one-hot tương tự 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:
cetrở thànhSoftTargetCrossEntropy.bce, đa nhãnasl,polyvàdbkhông làm mượt các mục tiêu một lần nữa.- Single-label
aslsẽ gây ra lỗi khi sử dụngsoft_targets. twoway/zlprsẽ gây ra lỗi nếu dùng cùng vớisoft_targetshoặcsmoothingvì 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 chỉ định 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, hàm này trả về đối số loss mà các trọng số tương ứng 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), đượ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đọc các số đếm từ một tệp JSON có các mụcpos_countsvànum_samples, như đã được ghi bởiclass_weights.pyở thư mục gốc của kho.load_class_weightsphâ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_weightschấp nhận tên phương pháp hoặc trọng số tường minh, giống như cáchtrain.pyxử lý các cờ của nó.
Mất db nhận các giá trị đếm trực tiếp.
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
float32bấ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_reductionsau:Giá trị Trên các lớp Trên toàn bộ lô Ghi chú batchmeanTổng Trung bình Mặc định sumTổng Tổng Giảm ASL gốc; loss tỷ lệ với kích thước batch meanTrung 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
batchmeancho nó.bce, đa nhãn (multi-label)polyvàdblấy trung bình trên batch và các lớp (bce_sumcộng trên các lớp chobce).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 là 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_splitsphần bằng nhau, với các ảnh sạch ở đầu (theo cáchfast_collatesắp xếp các mẫu củaAugMixDataset), 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
< 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 )
Tham số
- loss_type — Một trong LOSSTYPES, None sẽ chọn ‘bce’ cho đa nhãn và ‘ce’ cho đơn nhã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 (bce args), ‘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 (asl_ args), ‘poly’: Poly-1 loss, PolyBinaryCrossEntropy (sigmoid) cho mục tiêu đa nhãn, ngược lại là softmax PolyCrossEntropy (poly* args), ‘jsd’: phân kỳ Jensen-Shannon + CE trên các phần chia tăng cường, đơn nhãn (jsd_splits), ‘twoway': Two-way loss, chỉ cho mục tiêu đa nhãn nhị phân (twoway args), ‘zlpr’: ZLPR loss, chỉ cho mục tiêu đa nhãn nhị phân, ‘db’: Distribution-Balanced loss, đa nhãn (classcounts, num_samples, db args).
- 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ượt 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 được nhận dưới dạng phân phối mềm dày đặc từ Mixup/CutMix thay vì 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 số hạ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 (soft targets) có giá trị lớn hơn ngưỡng 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ỉ dành cho ‘asl’).
- asl_clip — Biên độ xác suất được 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ỉ áp dụng cho ‘asl’ đa nhãn, ASL đơn nhãn luôn dùng ‘batchmean’).
- poly_epsilon — Hệ số Poly-1, giá trị 0 sẽ giảm về CE / BCE (chỉ áp dụng với ‘poly’).
- poly_gamma — Tham số tập trung, 0 để tắt thành phần focal (chỉ áp dụng cho ‘poly’ đa nhãn).
- poly_alpha — Trọng số cân bằng 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ỉ áp dụng 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ỉ áp dụng với ‘db’).
- num_samples — Số lượng mẫu huấn luyện mà class_counts được lấy trên (chỉ với ‘db’).
- db_neg_scale — Thang logit dung sai âm, 1 để tắt (chỉ ‘db’).
- 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ố tập trung, 0 sẽ vô hiệu hóa số hạng focal (chỉ với ‘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
< 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 )
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 các tùy chọn: ‘neg_pos’: pos_weight = (negatives / positives) mũ, 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) mũ, trung bình 1, ‘effective_num’: class_weight cân bằng lớp từ số 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ố số hiệu dụng cho ‘effective_num’.
- max_weight — Giá trị tối đa áp dụng cho trọng số cuối cùng.
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
< source >( path: typing.Optional[str] )
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
< source >( value: typing.Union[str, float, typing.Sequence[float], torch.Tensor, NoneType]key: str = 'class_weight' )
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
< 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 )
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 đang được xử lý, ‘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
Mất NLL với làm mịn nhãn.
lớp timm.loss.AsymmetricLossSingleLabel
< source >( gamma_pos = 1gamma_neg = 4eps: float = 0.1reduction = 'mean' )
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
lớp timm.loss.PolyCrossEntropy
< source >( epsilon: float = 2.0smoothing: float = 0.0reduction: str = 'mean' )
Tham số
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, như trong tài liệu tham khảo.
forward
< source >( x: Tensortarget: Tensor )
Các lớp Loss cho nhiều nhãn
lớp 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 )
Tham số
- smoothing — Label smoothing được áp dụng khi mã hóa one-hot cho các mục tiêu dạng index. Các mục tiêu dạng dense được giả định là đã được làm mềm ở phía trước (ví dụ: bằng Mixup/CutMix) trừ khi smooth_dense được đặt.
- target_threshold — Nhị phân hóa (soft) các target có giá trị lớn hơn ngưỡng này.
- weight — Trọng số điều chỉnh tỷ lệ cho từng lớp.
- reduction — Phương pháp 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ố của lớp dương.
- smooth_dense — Cũng áp dụng làm mịn cho các mục tiêu đã khớp với hình dạng logit (nhiều nhãn), 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
lớp 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 )
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 dịch sang các mẫu âm (cắt không đố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ố focusing.
- smoothing — Làm mượt nhãn, dịch chuyển mỗi mục tiêu (mật độ, 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 (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ữ lại loss cho từng phần tử.
- weight — Trọng số điều chỉnh tỷ lệ cho từng lớp.
- pos_weight — Trọng số của hạng tử 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
< source >( x: Tensory: Tensor )
lớp timm.loss.PolyBinaryCrossEntropy
< source >( epsilon: float = 2.0gamma: float = 0.0alpha: typing.Optional[float] = Nonesmoothing: float = 0.0reduction: str = 'mean' )
Tham số
- epsilon — Hệ số Poly-1, 0 là BCE thuần túy (hoặc focal loss).
- gamma — Tham số tập trung, 0 sẽ vô hiệu hóa số hạng focal.
- alpha — Trọng số cân bằng dương / âm, None để tắt tính năng này.
- smoothing — Làm mượt nhãn, dịch chuyển mỗi mục tiêu (mật độ, 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
< source >( x: Tensortarget: Tensor )
lớp 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' )
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 đo 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), giá trị 1 sẽ tắt việc mở rộng dung sai cho logit âm.
- init_bias — Hệ số dịch logit tiên nghiệm của lớp (kappa), 0 để tắt.
- focal_gamma — Tham số tập trung, giá trị 0 sẽ vô hiệu hóa thành phần focal (và focal_balance).
- focal_balance — Hệ số tỷ lệ cố định của hàm mất mát focal.
- smoothing — Làm mượt nhãn, dịch chuyển mỗi nhãn 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 co giãn, 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. Một số hạng focal tùy chọn (1 - p_t) ** gamma tuân theo cấu hình DB tham chiếu.
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
< source >( x: Tensortarget: Tensor )
lớp timm.loss.TwoWayLoss
< source >( tp: float = 4.0tn: float = 1.0 )
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, xuyên suốt các lớp của mỗi mẫu và xuyên suốt 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
< source >( x: Tensortarget: Tensor )
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 đó logits > 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
< source >( x: Tensortarget: Tensor )