Spaces:
Running on Zero
Running on Zero
Download temp_DRCT_reference/utils/losses.py from Thiru1122/Multimodel_setup: direct link, hf CLI and curl.
- Browser
- Download file 3.91 kB
-
https://huggingface.co/spaces/Thiru1122/Multimodel_setup/resolve/main/temp_DRCT_reference/utils/losses.py
- Command line
-
hf download hf://spaces/Thiru1122/Multimodel_setup/temp_DRCT_reference/utils/losses.py
-
curl -L -o losses.py https://huggingface.co/spaces/Thiru1122/Multimodel_setup/resolve/main/temp_DRCT_reference/utils/losses.py
3.91 kB
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from pytorch_metric_learning import losses, miners | |
| class LabelSmoothing(nn.Module): | |
| def __init__(self, smoothing=0.05): | |
| super(LabelSmoothing, self).__init__() | |
| self.confidence = 1.0 - smoothing | |
| self.smoothing = smoothing | |
| def forward(self, x, target): | |
| if self.training: | |
| x = x.float() | |
| target = target.float() | |
| logprobs = torch.nn.functional.log_softmax(x, dim=-1) | |
| nll_loss = -logprobs * target | |
| nll_loss = nll_loss.sum(-1) | |
| smooth_loss = -logprobs.mean(dim=-1) | |
| loss = self.confidence * nll_loss + self.smoothing * smooth_loss | |
| return loss.mean() | |
| else: | |
| return torch.nn.functional.cross_entropy(x, target) | |
| # 自定义ContrastiveLoss | |
| class ContrastiveLoss(torch.nn.Module): | |
| """ | |
| Contrastive loss function. | |
| Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf | |
| """ | |
| def __init__(self, margin=1.0): | |
| super(ContrastiveLoss, self).__init__() | |
| self.margin = margin | |
| def forward(self, output1, output2, label): | |
| euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True) | |
| loss_contrastive = torch.mean((1-label) * torch.pow(euclidean_distance, 2) + | |
| label * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2)) | |
| return loss_contrastive | |
| class FocalLoss(nn.Module): | |
| def __init__(self, alpha=0.25, gamma=2, weight=None, ignore_index=255): | |
| super(FocalLoss, self).__init__() | |
| self.alpha = alpha | |
| self.gamma = gamma | |
| self.weight = weight | |
| self.ignore_index = ignore_index | |
| self.bce_fn = nn.BCEWithLogitsLoss(weight=self.weight) | |
| def forward(self, preds, labels): | |
| if self.ignore_index is not None: | |
| mask = labels != self.ignore | |
| labels = labels[mask] | |
| preds = preds[mask] | |
| logpt = -self.bce_fn(preds, labels) | |
| pt = torch.exp(logpt) | |
| loss = -((1 - pt) ** self.gamma) * self.alpha * logpt | |
| return loss | |
| # https://kevinmusgrave.github.io/pytorch-metric-learning/losses/ | |
| class CombinedLoss(torch.nn.Module): | |
| def __init__(self, loss_name='ContrastiveLoss', embedding_size=1024, pos_margin=0.0, neg_margin=1.0, | |
| memory_size=None, use_miner=False, num_classes=2, tau=0.5): | |
| super(CombinedLoss, self).__init__() | |
| self.loss_name = loss_name | |
| self.embedding_size = embedding_size | |
| self.pos_margin = pos_margin | |
| self.neg_margin = neg_margin | |
| self.memory_size = memory_size | |
| self.use_miner = use_miner | |
| self.num_classes = num_classes | |
| if loss_name == 'TripletMarginLoss': | |
| self.loss_fn = losses.TripletMarginLoss(smooth_loss=True) | |
| elif loss_name == 'ArcFaceLoss': | |
| self.loss_fn = losses.ArcFaceLoss(num_classes=num_classes, embedding_size=embedding_size) | |
| elif loss_name == 'SubCenterArcFaceLoss': | |
| self.loss_fn = losses.SubCenterArcFaceLoss(num_classes=num_classes, embedding_size=embedding_size) | |
| elif loss_name == 'CircleLoss': | |
| self.loss_fn = losses.CircleLoss() | |
| elif loss_name == 'NTXentLoss': | |
| self.loss_fn = losses.NTXentLoss(temperature=tau) # The MoCo paper uses 0.07, while SimCLR uses 0.5. | |
| else: | |
| self.loss_fn = losses.ContrastiveLoss(pos_margin=pos_margin, neg_margin=neg_margin) | |
| miner = miners.MultiSimilarityMiner() if use_miner else None | |
| if memory_size is not None: | |
| self.loss_fn = losses.CrossBatchMemory(self.loss_fn, embedding_size=embedding_size, memory_size=memory_size, miner=miner) | |
| def forward(self, embeddings, labels): | |
| loss = self.loss_fn(embeddings, labels) | |
| return loss | |