Upload folder using huggingface_hub

__init__.py

@@ -0,0 +1,7 @@
+from .focal import FocalLoss
+from .dice import DiceLoss
+from .contrastive import ContrastiveLoss
+from .triplet import TripletLoss
+from .cosine import CosineEmbeddingLoss
+from .huber import HuberLoss
+from .kldiv import KLDivLoss

contrastive.py

@@ -0,0 +1,14 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ContrastiveLoss(nn.Module):
+    """Contrastive Loss for Siamese networks"""
+    def __init__(self, margin=1.0):
+        super().__init__()
+        self.margin = margin
+
+    def forward(self, x1, x2, label):
+        dist = F.pairwise_distance(x1, x2)
+        loss = (1 - label) * torch.pow(dist, 2) + label * torch.pow(torch.clamp(self.margin - dist, min=0.0), 2)
+        return loss.mean()

cosine.py

@@ -0,0 +1,9 @@
+import torch.nn.functional as F
+
+class CosineEmbeddingLoss:
+    """Cosine Embedding Loss for similarity learning"""
+    def __init__(self, margin=0.0):
+        self.margin = margin
+
+    def __call__(self, x1, x2, label):
+        return F.cosine_embedding_loss(x1, x2, label, margin=self.margin)

dice.py

@@ -0,0 +1,15 @@
+import torch
+import torch.nn as nn
+
+class DiceLoss(nn.Module):
+    """Dice Loss for segmentation"""
+    def __init__(self, smooth=1.0):
+        super().__init__()
+        self.smooth = smooth
+
+    def forward(self, inputs, targets):
+        inputs = torch.sigmoid(inputs).view(-1)
+        targets = targets.view(-1).float()
+        intersection = (inputs * targets).sum()
+        dice = (2. * intersection + self.smooth) / (inputs.sum() + targets.sum() + self.smooth)
+        return 1 - dice

focal.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class FocalLoss(nn.Module):
+    """Focal Loss for imbalanced classification"""
+    def __init__(self, alpha=1.0, gamma=2.0, reduction='mean'):
+        super().__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+
+    def forward(self, inputs, targets):
+        ce_loss = F.cross_entropy(inputs, targets, reduction='none')
+        pt = torch.exp(-ce_loss)
+        loss = self.alpha * (1 - pt) ** self.gamma * ce_loss
+        return loss.mean() if self.reduction == 'mean' else loss.sum()

huber.py

@@ -0,0 +1,14 @@
+import torch
+import torch.nn as nn
+
+class HuberLoss(nn.Module):
+    """Huber Loss (a.k.a. Smooth L1)"""
+    def __init__(self, delta=1.0, reduction='mean'):
+        super().__init__()
+        self.delta = delta
+        self.reduction = reduction
+
+    def forward(self, inputs, targets):
+        diff = torch.abs(inputs - targets)
+        loss = torch.where(diff < self.delta, 0.5 * diff**2, self.delta * (diff - 0.5 * self.delta))
+        return loss.mean() if self.reduction == 'mean' else loss.sum()

kldiv.py

@@ -0,0 +1,11 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+class KLDivLoss(nn.Module):
+    """Kullback-Leibler Divergence Loss"""
+    def __init__(self, reduction='batchmean'):
+        super().__init__()
+        self.reduction = reduction
+
+    def forward(self, inputs, targets):
+        return F.kl_div(inputs, targets, reduction=self.reduction)

setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="torchlosses",
+    version="0.1.0",
+    description="A collection of advanced PyTorch loss functions (Focal, Dice, Contrastive, Triplet, Cosine, Huber, KLDiv).",
+    author="Naga Adithya Kaushik (GenAIDevTOProd)",
+    author_email="[email protected]",
+    url="https://huggingface.co/GenAIDevTOProd",
+    packages=find_packages(),
+    install_requires=["torch>=1.10"],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

triplet.py

@@ -0,0 +1,9 @@
+import torch.nn.functional as F
+
+class TripletLoss:
+    """Triplet Margin Loss"""
+    def __init__(self, margin=1.0):
+        self.margin = margin
+
+    def __call__(self, anchor, positive, negative):
+        return F.triplet_margin_loss(anchor, positive, negative, margin=self.margin, reduction='mean')