dnt 0.2.4__py3-none-any.whl → 0.3.1.8__py3-none-any.whl

dnt/third_party/fast-reid/fastreid/modeling/heads/embedding_head.py

@@ -0,0 +1,151 @@
+# encoding: utf-8
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from fastreid.config import configurable
+from fastreid.layers import *
+from fastreid.layers import pooling, any_softmax
+from fastreid.layers.weight_init import weights_init_kaiming
+from .build import REID_HEADS_REGISTRY
+
+
+@REID_HEADS_REGISTRY.register()
+class EmbeddingHead(nn.Module):
+    """
+    EmbeddingHead perform all feature aggregation in an embedding task, such as reid, image retrieval
+    and face recognition
+
+    It typically contains logic to
+
+    1. feature aggregation via global average pooling and generalized mean pooling
+    2. (optional) batchnorm, dimension reduction and etc.
+    2. (in training only) margin-based softmax logits computation
+    """
+
+    @configurable
+    def __init__(
+            self,
+            *,
+            feat_dim,
+            embedding_dim,
+            num_classes,
+            neck_feat,
+            pool_type,
+            cls_type,
+            scale,
+            margin,
+            with_bnneck,
+            norm_type
+    ):
+        """
+        NOTE: this interface is experimental.
+
+        Args:
+            feat_dim:
+            embedding_dim:
+            num_classes:
+            neck_feat:
+            pool_type:
+            cls_type:
+            scale:
+            margin:
+            with_bnneck:
+            norm_type:
+        """
+        super().__init__()
+
+        # Pooling layer
+        assert hasattr(pooling, pool_type), "Expected pool types are {}, " \
+                                            "but got {}".format(pooling.__all__, pool_type)
+        self.pool_layer = getattr(pooling, pool_type)()
+
+        self.neck_feat = neck_feat
+
+        neck = []
+        if embedding_dim > 0:
+            neck.append(nn.Conv2d(feat_dim, embedding_dim, 1, 1, bias=False))
+            feat_dim = embedding_dim
+
+        if with_bnneck:
+            neck.append(get_norm(norm_type, feat_dim, bias_freeze=True))
+
+        self.bottleneck = nn.Sequential(*neck)
+
+        # Classification head
+        assert hasattr(any_softmax, cls_type), "Expected cls types are {}, " \
+                                               "but got {}".format(any_softmax.__all__, cls_type)
+        self.weight = nn.Parameter(torch.Tensor(num_classes, feat_dim))
+        self.cls_layer = getattr(any_softmax, cls_type)(num_classes, scale, margin)
+
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        self.bottleneck.apply(weights_init_kaiming)
+        nn.init.normal_(self.weight, std=0.01)
+
+    @classmethod
+    def from_config(cls, cfg):
+        # fmt: off
+        feat_dim      = cfg.MODEL.BACKBONE.FEAT_DIM
+        embedding_dim = cfg.MODEL.HEADS.EMBEDDING_DIM
+        num_classes   = cfg.MODEL.HEADS.NUM_CLASSES
+        neck_feat     = cfg.MODEL.HEADS.NECK_FEAT
+        pool_type     = cfg.MODEL.HEADS.POOL_LAYER
+        cls_type      = cfg.MODEL.HEADS.CLS_LAYER
+        scale         = cfg.MODEL.HEADS.SCALE
+        margin        = cfg.MODEL.HEADS.MARGIN
+        with_bnneck   = cfg.MODEL.HEADS.WITH_BNNECK
+        norm_type     = cfg.MODEL.HEADS.NORM
+        # fmt: on
+        return {
+            'feat_dim': feat_dim,
+            'embedding_dim': embedding_dim,
+            'num_classes': num_classes,
+            'neck_feat': neck_feat,
+            'pool_type': pool_type,
+            'cls_type': cls_type,
+            'scale': scale,
+            'margin': margin,
+            'with_bnneck': with_bnneck,
+            'norm_type': norm_type
+        }
+
+    def forward(self, features, targets=None):
+        """
+        See :class:`ReIDHeads.forward`.
+        """
+        pool_feat = self.pool_layer(features)
+        neck_feat = self.bottleneck(pool_feat)
+        neck_feat = neck_feat[..., 0, 0]
+
+        # Evaluation
+        # fmt: off
+        if not self.training: return neck_feat
+        # fmt: on
+
+        # Training
+        if self.cls_layer.__class__.__name__ == 'Linear':
+            logits = F.linear(neck_feat, self.weight)
+        else:
+            logits = F.linear(F.normalize(neck_feat), F.normalize(self.weight))
+
+        # Pass logits.clone() into cls_layer, because there is in-place operations
+        cls_outputs = self.cls_layer(logits.clone(), targets)
+
+        # fmt: off
+        if self.neck_feat == 'before':  feat = pool_feat[..., 0, 0]
+        elif self.neck_feat == 'after': feat = neck_feat
+        else:                           raise KeyError(f"{self.neck_feat} is invalid for MODEL.HEADS.NECK_FEAT")
+        # fmt: on
+
+        return {
+            "cls_outputs": cls_outputs,
+            "pred_class_logits": logits.mul(self.cls_layer.s),
+            "features": feat,
+        }

dnt/third_party/fast-reid/fastreid/modeling/losses/__init__.py

@@ -0,0 +1,12 @@
+# encoding: utf-8
+"""
+@author:  l1aoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+
+from .circle_loss import *
+from .cross_entroy_loss import cross_entropy_loss, log_accuracy
+from .focal_loss import focal_loss
+from .triplet_loss import triplet_loss
+
+__all__ = [k for k in globals().keys() if not k.startswith("_")]

dnt/third_party/fast-reid/fastreid/modeling/losses/circle_loss.py

@@ -0,0 +1,71 @@
+# encoding: utf-8
+"""
+@author:  xingyu liao
+@contact: sherlockliao01@gmail.com
+"""
+
+import torch
+import torch.nn.functional as F
+
+__all__ = ["pairwise_circleloss", "pairwise_cosface"]
+
+
+def pairwise_circleloss(
+        embedding: torch.Tensor,
+        targets: torch.Tensor,
+        margin: float,
+        gamma: float, ) -> torch.Tensor:
+    embedding = F.normalize(embedding, dim=1)
+
+    dist_mat = torch.matmul(embedding, embedding.t())
+
+    N = dist_mat.size(0)
+
+    is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()
+    is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()
+
+    # Mask scores related to itself
+    is_pos = is_pos - torch.eye(N, N, device=is_pos.device)
+
+    s_p = dist_mat * is_pos
+    s_n = dist_mat * is_neg
+
+    alpha_p = torch.clamp_min(-s_p.detach() + 1 + margin, min=0.)
+    alpha_n = torch.clamp_min(s_n.detach() + margin, min=0.)
+    delta_p = 1 - margin
+    delta_n = margin
+
+    logit_p = - gamma * alpha_p * (s_p - delta_p) + (-99999999.) * (1 - is_pos)
+    logit_n = gamma * alpha_n * (s_n - delta_n) + (-99999999.) * (1 - is_neg)
+
+    loss = F.softplus(torch.logsumexp(logit_p, dim=1) + torch.logsumexp(logit_n, dim=1)).mean()
+
+    return loss
+
+
+def pairwise_cosface(
+        embedding: torch.Tensor,
+        targets: torch.Tensor,
+        margin: float,
+        gamma: float, ) -> torch.Tensor:
+    # Normalize embedding features
+    embedding = F.normalize(embedding, dim=1)
+
+    dist_mat = torch.matmul(embedding, embedding.t())
+
+    N = dist_mat.size(0)
+    is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()
+    is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()
+
+    # Mask scores related to itself
+    is_pos = is_pos - torch.eye(N, N, device=is_pos.device)
+
+    s_p = dist_mat * is_pos
+    s_n = dist_mat * is_neg
+
+    logit_p = -gamma * s_p + (-99999999.) * (1 - is_pos)
+    logit_n = gamma * (s_n + margin) + (-99999999.) * (1 - is_neg)
+
+    loss = F.softplus(torch.logsumexp(logit_p, dim=1) + torch.logsumexp(logit_n, dim=1)).mean()
+
+    return loss

dnt/third_party/fast-reid/fastreid/modeling/losses/cross_entroy_loss.py

@@ -0,0 +1,54 @@
+# encoding: utf-8
+"""
+@author:  l1aoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+import torch
+import torch.nn.functional as F
+
+from fastreid.utils.events import get_event_storage
+
+
+def log_accuracy(pred_class_logits, gt_classes, topk=(1,)):
+    """
+    Log the accuracy metrics to EventStorage.
+    """
+    bsz = pred_class_logits.size(0)
+    maxk = max(topk)
+    _, pred_class = pred_class_logits.topk(maxk, 1, True, True)
+    pred_class = pred_class.t()
+    correct = pred_class.eq(gt_classes.view(1, -1).expand_as(pred_class))
+
+    ret = []
+    for k in topk:
+        correct_k = correct[:k].view(-1).float().sum(dim=0, keepdim=True)
+        ret.append(correct_k.mul_(1. / bsz))
+
+    storage = get_event_storage()
+    storage.put_scalar("cls_accuracy", ret[0])
+
+
+def cross_entropy_loss(pred_class_outputs, gt_classes, eps, alpha=0.2):
+    num_classes = pred_class_outputs.size(1)
+
+    if eps >= 0:
+        smooth_param = eps
+    else:
+        # Adaptive label smooth regularization
+        soft_label = F.softmax(pred_class_outputs, dim=1)
+        smooth_param = alpha * soft_label[torch.arange(soft_label.size(0)), gt_classes].unsqueeze(1)
+
+    log_probs = F.log_softmax(pred_class_outputs, dim=1)
+    with torch.no_grad():
+        targets = torch.ones_like(log_probs)
+        targets *= smooth_param / (num_classes - 1)
+        targets.scatter_(1, gt_classes.data.unsqueeze(1), (1 - smooth_param))
+
+    loss = (-targets * log_probs).sum(dim=1)
+
+    with torch.no_grad():
+        non_zero_cnt = max(loss.nonzero(as_tuple=False).size(0), 1)
+
+    loss = loss.sum() / non_zero_cnt
+
+    return loss

dnt/third_party/fast-reid/fastreid/modeling/losses/focal_loss.py

@@ -0,0 +1,92 @@
+# encoding: utf-8
+"""
+@author:  xingyu liao
+@contact: sherlockliao01@gmail.com
+"""
+
+import torch
+import torch.nn.functional as F
+
+
+# based on:
+# https://github.com/kornia/kornia/blob/master/kornia/losses/focal.py
+
+def focal_loss(
+        input: torch.Tensor,
+        target: torch.Tensor,
+        alpha: float,
+        gamma: float = 2.0,
+        reduction: str = 'mean') -> torch.Tensor:
+    r"""Criterion that computes Focal loss.
+    See :class:`fastreid.modeling.losses.FocalLoss` for details.
+    According to [1], the Focal loss is computed as follows:
+    .. math::
+        \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t)
+    where:
+       - :math:`p_t` is the model's estimated probability for each class.
+    Arguments:
+        alpha (float): Weighting factor :math:`\alpha \in [0, 1]`.
+        gamma (float): Focusing parameter :math:`\gamma >= 0`.
+        reduction (str, optional): Specifies the reduction to apply to the
+         output: ‘none’ | ‘mean’ | ‘sum’. ‘none’: no reduction will be applied,
+         ‘mean’: the sum of the output will be divided by the number of elements
+         in the output, ‘sum’: the output will be summed. Default: ‘none’.
+    Shape:
+        - Input: :math:`(N, C, *)` where C = number of classes.
+        - Target: :math:`(N, *)` where each value is
+          :math:`0 ≤ targets[i] ≤ C−1`.
+    Examples:
+        >>> N = 5  # num_classes
+        >>> loss = FocalLoss(cfg)
+        >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+        >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+        >>> output = loss(input, target)
+        >>> output.backward()
+    References:
+        [1] https://arxiv.org/abs/1708.02002
+    """
+    if not torch.is_tensor(input):
+        raise TypeError("Input type is not a torch.Tensor. Got {}"
+                        .format(type(input)))
+
+    if not len(input.shape) >= 2:
+        raise ValueError("Invalid input shape, we expect BxCx*. Got: {}"
+                         .format(input.shape))
+
+    if input.size(0) != target.size(0):
+        raise ValueError('Expected input batch_size ({}) to match target batch_size ({}).'
+                         .format(input.size(0), target.size(0)))
+
+    n = input.size(0)
+    out_size = (n,) + input.size()[2:]
+    if target.size()[1:] != input.size()[2:]:
+        raise ValueError('Expected target size {}, got {}'.format(
+            out_size, target.size()))
+
+    if not input.device == target.device:
+        raise ValueError(
+            "input and target must be in the same device. Got: {}".format(
+                input.device, target.device))
+
+    # compute softmax over the classes axis
+    input_soft = F.softmax(input, dim=1)
+
+    # create the labels one hot tensor
+    target_one_hot = F.one_hot(target, num_classes=input.shape[1])
+
+    # compute the actual focal loss
+    weight = torch.pow(-input_soft + 1., gamma)
+
+    focal = -alpha * weight * torch.log(input_soft)
+    loss_tmp = torch.sum(target_one_hot * focal, dim=1)
+
+    if reduction == 'none':
+        loss = loss_tmp
+    elif reduction == 'mean':
+        loss = torch.mean(loss_tmp)
+    elif reduction == 'sum':
+        loss = torch.sum(loss_tmp)
+    else:
+        raise NotImplementedError("Invalid reduction mode: {}"
+                                  .format(reduction))
+    return loss

dnt/third_party/fast-reid/fastreid/modeling/losses/triplet_loss.py

@@ -0,0 +1,113 @@
+# encoding: utf-8
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+
+import torch
+import torch.nn.functional as F
+
+from .utils import euclidean_dist, cosine_dist
+
+
+def softmax_weights(dist, mask):
+    max_v = torch.max(dist * mask, dim=1, keepdim=True)[0]
+    diff = dist - max_v
+    Z = torch.sum(torch.exp(diff) * mask, dim=1, keepdim=True) + 1e-6  # avoid division by zero
+    W = torch.exp(diff) * mask / Z
+    return W
+
+
+def hard_example_mining(dist_mat, is_pos, is_neg):
+    """For each anchor, find the hardest positive and negative sample.
+    Args:
+      dist_mat: pair wise distance between samples, shape [N, M]
+      is_pos: positive index with shape [N, M]
+      is_neg: negative index with shape [N, M]
+    Returns:
+      dist_ap: pytorch Variable, distance(anchor, positive); shape [N]
+      dist_an: pytorch Variable, distance(anchor, negative); shape [N]
+      p_inds: pytorch LongTensor, with shape [N];
+        indices of selected hard positive samples; 0 <= p_inds[i] <= N - 1
+      n_inds: pytorch LongTensor, with shape [N];
+        indices of selected hard negative samples; 0 <= n_inds[i] <= N - 1
+    NOTE: Only consider the case in which all labels have same num of samples,
+      thus we can cope with all anchors in parallel.
+    """
+
+    assert len(dist_mat.size()) == 2
+
+    # `dist_ap` means distance(anchor, positive)
+    # both `dist_ap` and `relative_p_inds` with shape [N]
+    dist_ap, _ = torch.max(dist_mat * is_pos, dim=1)
+    # `dist_an` means distance(anchor, negative)
+    # both `dist_an` and `relative_n_inds` with shape [N]
+    dist_an, _ = torch.min(dist_mat * is_neg + is_pos * 1e9, dim=1)
+
+    return dist_ap, dist_an
+
+
+def weighted_example_mining(dist_mat, is_pos, is_neg):
+    """For each anchor, find the weighted positive and negative sample.
+    Args:
+      dist_mat: pytorch Variable, pair wise distance between samples, shape [N, N]
+      is_pos:
+      is_neg:
+    Returns:
+      dist_ap: pytorch Variable, distance(anchor, positive); shape [N]
+      dist_an: pytorch Variable, distance(anchor, negative); shape [N]
+    """
+    assert len(dist_mat.size()) == 2
+
+    is_pos = is_pos
+    is_neg = is_neg
+    dist_ap = dist_mat * is_pos
+    dist_an = dist_mat * is_neg
+
+    weights_ap = softmax_weights(dist_ap, is_pos)
+    weights_an = softmax_weights(-dist_an, is_neg)
+
+    dist_ap = torch.sum(dist_ap * weights_ap, dim=1)
+    dist_an = torch.sum(dist_an * weights_an, dim=1)
+
+    return dist_ap, dist_an
+
+
+def triplet_loss(embedding, targets, margin, norm_feat, hard_mining):
+    r"""Modified from Tong Xiao's open-reid (https://github.com/Cysu/open-reid).
+    Related Triplet Loss theory can be found in paper 'In Defense of the Triplet
+    Loss for Person Re-Identification'."""
+
+    if norm_feat:
+        dist_mat = cosine_dist(embedding, embedding)
+    else:
+        dist_mat = euclidean_dist(embedding, embedding)
+
+    # For distributed training, gather all features from different process.
+    # if comm.get_world_size() > 1:
+    #     all_embedding = torch.cat(GatherLayer.apply(embedding), dim=0)
+    #     all_targets = concat_all_gather(targets)
+    # else:
+    #     all_embedding = embedding
+    #     all_targets = targets
+
+    N = dist_mat.size(0)
+    is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()
+    is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()
+
+    if hard_mining:
+        dist_ap, dist_an = hard_example_mining(dist_mat, is_pos, is_neg)
+    else:
+        dist_ap, dist_an = weighted_example_mining(dist_mat, is_pos, is_neg)
+
+    y = dist_an.new().resize_as_(dist_an).fill_(1)
+
+    if margin > 0:
+        loss = F.margin_ranking_loss(dist_an, dist_ap, y, margin=margin)
+    else:
+        loss = F.soft_margin_loss(dist_an - dist_ap, y)
+        # fmt: off
+        if loss == float('Inf'): loss = F.margin_ranking_loss(dist_an, dist_ap, y, margin=0.3)
+        # fmt: on
+
+    return loss

dnt/third_party/fast-reid/fastreid/modeling/losses/utils.py

@@ -0,0 +1,48 @@
+# encoding: utf-8
+"""
+@author:  xingyu liao
+@contact: sherlockliao01@gmail.com
+"""
+
+import torch
+import torch.nn.functional as F
+
+
+def concat_all_gather(tensor):
+    """
+    Performs all_gather operation on the provided tensors.
+    *** Warning ***: torch.distributed.all_gather has no gradient.
+    """
+    tensors_gather = [torch.ones_like(tensor)
+                      for _ in range(torch.distributed.get_world_size())]
+    torch.distributed.all_gather(tensors_gather, tensor, async_op=False)
+
+    output = torch.cat(tensors_gather, dim=0)
+    return output
+
+
+def normalize(x, axis=-1):
+    """Normalizing to unit length along the specified dimension.
+    Args:
+      x: pytorch Variable
+    Returns:
+      x: pytorch Variable, same shape as input
+    """
+    x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)
+    return x
+
+
+def euclidean_dist(x, y):
+    m, n = x.size(0), y.size(0)
+    xx = torch.pow(x, 2).sum(1, keepdim=True).expand(m, n)
+    yy = torch.pow(y, 2).sum(1, keepdim=True).expand(n, m).t()
+    dist = xx + yy - 2 * torch.matmul(x, y.t())
+    dist = dist.clamp(min=1e-12).sqrt()  # for numerical stability
+    return dist
+
+
+def cosine_dist(x, y):
+    x = F.normalize(x, dim=1)
+    y = F.normalize(y, dim=1)
+    dist = 2 - 2 * torch.mm(x, y.t())
+    return dist

dnt/third_party/fast-reid/fastreid/modeling/meta_arch/__init__.py

@@ -0,0 +1,14 @@
+# encoding: utf-8
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+
+from .build import META_ARCH_REGISTRY, build_model
+
+
+# import all the meta_arch, so they will be registered
+from .baseline import Baseline
+from .mgn import MGN
+from .moco import MoCo
+from .distiller import Distiller