Upload folder using huggingface_hub

ASDA/utils/__init__.py

@@ -0,0 +1 @@
+

ASDA/utils/checkpoint.py

@@ -0,0 +1,102 @@
+import os
+import shutil
+import torch
+
+def save_checkpoint(state, is_best, args, filename='default'):
+    if filename=='default':
+        filename = 'mcn_%s_batch%d'%(args.dataset,args.samples_per_gpu)
+    print("=> saving checkpoint '{}'".format(filename))
+    if not os.path.exists('./saved_models'):
+        os.makedirs('./saved_models')
+    checkpoint_name = './saved_models/%s_checkpoint.pth.tar'%(filename)
+    best_name = './saved_models/%s_model_best.pth.tar'%(filename)
+    torch.save(state, checkpoint_name)
+    if is_best:
+        print("=> saving best model '{}'".format(best_name))
+        shutil.copyfile(checkpoint_name, best_name)
+
+def load_pretrain(model, args, logging, rank):
+    if os.path.isfile(args.pretrain):
+        checkpoint = torch.load(args.pretrain)
+        pretrained_dict = checkpoint['state_dict']
+        if hasattr(model, 'module'):
+            model_dict = model.module.state_dict()
+        else:
+            model_dict = model.state_dict()
+        pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
+        assert (len([k for k, v in pretrained_dict.items()])!=0)
+        model_dict.update(pretrained_dict)
+        if hasattr(model, 'module'):
+            model.module.load_state_dict(model_dict)
+        else:
+            model.load_state_dict(model_dict)
+        print("=> loaded pretrain model at {}"
+              .format(args.pretrain))
+        if rank == 0:
+            logging.info("=> loaded pretrain model at {}"
+                .format(args.pretrain))
+        del checkpoint  # dereference seems crucial
+        torch.cuda.empty_cache()
+    else:
+        print(("=> no pretrained file found at '{}'".format(args.pretrain)))
+        if rank == 0:
+            logging.info("=> no pretrained file found at '{}'".format(args.pretrain))
+    return model
+
+def load_pretrain_ddp(model, args):
+    if os.path.isfile(args.pretrain):
+        checkpoint = torch.load(args.pretrain)
+        pretrained_dict = checkpoint['state_dict']
+        model_dict = model.state_dict()
+        pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
+        assert (len([k for k, v in pretrained_dict.items()])!=0)
+        model_dict.update(pretrained_dict)
+        if hasattr(model, 'module'):
+            state_dict = model.module.state_dict()
+            model.module.load_state_dict(model_dict)
+        else:
+            state_dict = model.state_dict()
+            model.load_state_dict(model_dict)
+        print("load ")
+        print("=> loaded pretrain model at {}"
+              .format(args.pretrain))
+        del checkpoint  # dereference seems crucial
+        torch.cuda.empty_cache()
+    else:
+        print(("=> no pretrained file found at '{}'".format(args.pretrain)))
+    return model
+
+
+def load_resume(model, optimizer, args, logging, rank):
+    if os.path.isfile(args.resume):
+        print(("=> loading checkpoint '{}'".format(args.resume)))
+        if rank == 0:
+            logging.info("=> loading checkpoint '{}'".format(args.resume))
+        checkpoint = torch.load(args.resume, map_location='cpu')
+        args.start_epoch = checkpoint['epoch']
+        print("epoch: ", args.start_epoch)
+        args.best_iou = checkpoint['best_iou']
+        print("best iou: ", args.best_iou)
+        state_dict = checkpoint['state_dict']
+
+        if hasattr(model, 'module'):
+            model_dict = model.module.state_dict()
+        else:
+            model_dict = model.state_dict()
+        new_state_dict = {k:v for k,v in state_dict.items() if k in model_dict}
+        model_dict.update(new_state_dict)
+
+        
+        if hasattr(model, 'module'):
+            model.module.load_state_dict(model_dict)
+        else:
+            model.load_state_dict(model_dict)
+        optimizer.load_state_dict(checkpoint['optimizer'])
+        del checkpoint  # dereference seems crucial
+        torch.cuda.empty_cache()
+        print("load successfully!")
+    else:
+        print(("=> no checkpoint found at '{}'".format(args.resume)))
+        if rank == 0:
+            logging.info(("=> no checkpoint found at '{}'".format(args.resume)))
+    return model

ASDA/utils/logger.py

@@ -0,0 +1,94 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import functools
+import logging
+import os
+import sys
+from termcolor import colored
+
+class _ColorfulFormatter(logging.Formatter):
+    def __init__(self, *args, **kwargs):
+        self._root_name = kwargs.pop("root_name") + "."
+        self._abbrev_name = kwargs.pop("abbrev_name", "")
+        if len(self._abbrev_name):
+            self._abbrev_name = self._abbrev_name + "."
+        super(_ColorfulFormatter, self).__init__(*args, **kwargs)
+
+    def formatMessage(self, record):
+        record.name = record.name.replace(self._root_name, self._abbrev_name)
+        log = super(_ColorfulFormatter, self).formatMessage(record)
+        if record.levelno == logging.WARNING:
+            prefix = colored("WARNING", "red", attrs=["blink"])
+        elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
+            prefix = colored("ERROR", "red", attrs=["blink", "underline"])
+        else:
+            return log
+        return prefix + " " + log
+
+
+# so that calling setup_logger multiple times won't add many handlers
+@functools.lru_cache()
+def setup_logger(
+    output=None, distributed_rank=0, *, color=True, name="imagenet", abbrev_name=None
+):
+    """
+    Initialize the detectron2 logger and set its verbosity level to "INFO".
+
+    Args:
+        output (str): a file name or a directory to save log. If None, will not save log file.
+            If ends with ".txt" or ".log", assumed to be a file name.
+            Otherwise, logs will be saved to `output/log.txt`.
+        name (str): the root module name of this logger
+
+    Returns:
+        logging.Logger: a logger
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+
+    if abbrev_name is None:
+        abbrev_name = name
+
+    plain_formatter = logging.Formatter(
+        '[%(asctime)s.%(msecs)03d]: %(message)s',
+        datefmt='%m/%d %H:%M:%S'
+    )
+    # stdout logging: master only
+    if distributed_rank == 0:
+        ch = logging.StreamHandler(stream=sys.stdout)
+        ch.setLevel(logging.DEBUG)
+        if color:
+            formatter = _ColorfulFormatter(
+                colored("[%(asctime)s.%(msecs)03d]: ", "green") + "%(message)s",
+                datefmt="%m/%d %H:%M:%S",
+                root_name=name,
+                abbrev_name=str(abbrev_name),
+            )
+        else:
+            formatter = plain_formatter
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    # file logging: all workers
+    if output is not None:
+        if output.endswith(".txt") or output.endswith(".log"):
+            filename = output
+        else:
+            filename = os.path.join(output, "log.txt")
+        if distributed_rank > 0:
+            filename = filename + f".rank{distributed_rank}"
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+        fh = logging.StreamHandler(_cached_log_stream(filename))
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(plain_formatter)
+        logger.addHandler(fh)
+
+    return logger
+
+
+# cache the opened file object, so that different calls to `setup_logger`
+# with the same file name can safely write to the same file.
+@functools.lru_cache(maxsize=None)
+def _cached_log_stream(filename):
+    return open(filename, "a")

ASDA/utils/losses.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+
+"""
+Custom loss function definitions.
+"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+from utils.utils import *
+
+class IoULoss(nn.Module):
+    """
+    Creates a criterion that computes the Intersection over Union (IoU)
+    between a segmentation mask and its ground truth.
+
+    Rahman, M.A. and Wang, Y:
+    Optimizing Intersection-Over-Union in Deep Neural Networks for
+    Image Segmentation. International Symposium on Visual Computing (2016)
+    http://www.cs.umanitoba.ca/~ywang/papers/isvc16.pdf
+    """
+
+    def __init__(self, size_average=True):
+        super().__init__()
+        self.size_average = size_average
+
+    def forward(self, input, target):
+        input = F.sigmoid(input)
+        intersection = (input * target).sum()
+        union = ((input + target) - (input * target)).sum()
+        iou = intersection / union
+        iou_dual = input.size(0) - iou
+        if self.size_average:
+            iou_dual = iou_dual / input.size(0)
+        return iou_dual
+
+
+def yolo_loss(input, target, gi, gj, best_n_list, w_coord=5.):
+    mseloss = torch.nn.MSELoss(size_average=True)
+    celoss = torch.nn.CrossEntropyLoss(size_average=True)
+    batch = input.size(0)
+
+    pred_bbox = Variable(torch.zeros(batch,4).cuda())
+    gt_bbox = Variable(torch.zeros(batch,4).cuda())
+    for ii in range(batch):
+        pred_bbox[ii, 0:2] = F.sigmoid(input[ii,best_n_list[ii],0:2,gj[ii],gi[ii]])
+        pred_bbox[ii, 2:4] = input[ii,best_n_list[ii],2:4,gj[ii],gi[ii]]
+        gt_bbox[ii, :] = target[ii,best_n_list[ii],:4,gj[ii],gi[ii]]
+    loss_x = mseloss(pred_bbox[:,0], gt_bbox[:,0])
+    loss_y = mseloss(pred_bbox[:,1], gt_bbox[:,1])
+    loss_w = mseloss(pred_bbox[:,2], gt_bbox[:,2])
+    loss_h = mseloss(pred_bbox[:,3], gt_bbox[:,3])
+
+    pred_conf_list, gt_conf_list = [], []
+    pred_conf_list.append(input[:,:,4,:,:].contiguous().view(batch,-1))
+    gt_conf_list.append(target[:,:,4,:,:].contiguous().view(batch,-1))
+    pred_conf = torch.cat(pred_conf_list, dim=1)
+    gt_conf = torch.cat(gt_conf_list, dim=1)
+    loss_conf = celoss(pred_conf, gt_conf.max(1)[1])
+    return (loss_x+loss_y+loss_w+loss_h)*w_coord + loss_conf
+
+def build_target(raw_coord, anchors, args):
+    coord = Variable(torch.zeros(raw_coord.size(0), raw_coord.size(1)).cuda())
+    batch, grid = raw_coord.size(0), args.size//args.gsize
+    coord[:,0] = (raw_coord[:,0] + raw_coord[:,2])/(2*args.size) # x 相对原图归一化
+    coord[:,1] = (raw_coord[:,1] + raw_coord[:,3])/(2*args.size) # y
+    coord[:,2] = (raw_coord[:,2] - raw_coord[:,0])/(args.size) # w
+    coord[:,3] = (raw_coord[:,3] - raw_coord[:,1])/(args.size) # h
+    coord = coord * grid
+    bbox=torch.zeros(coord.size(0),len(anchors),5,grid,grid)
+    
+    best_n_list, best_gi, best_gj = [],[],[]
+
+    for ii in range(batch):
+        gi = coord[ii,0].long()
+        gj = coord[ii,1].long()
+        tx = coord[ii,0] - gi.float()
+        ty = coord[ii,1] - gj.float()
+        gw = coord[ii,2]
+        gh = coord[ii,3]
+
+        scaled_anchors = [ (x[0] / (args.anchor_imsize/grid), \
+            x[1] / (args.anchor_imsize/grid)) for x in anchors]
+
+        ## Get shape of gt box
+        gt_box = torch.FloatTensor(np.array([0, 0, gw, gh],dtype=np.float32)).unsqueeze(0) #[1,4]
+        ## Get shape of anchor box
+        anchor_shapes = torch.FloatTensor(np.concatenate((np.zeros((len(scaled_anchors), 2)), np.array(scaled_anchors)), 1))
+        ## Calculate iou between gt and anchor shapes
+        anch_ious = list(bbox_iou(gt_box, anchor_shapes,x1y1x2y2=False))
+        ## Find the best matching anchor box
+        best_n = np.argmax(np.array(anch_ious))
+
+        tw = torch.log(gw / scaled_anchors[best_n][0] + 1e-16)
+        th = torch.log(gh / scaled_anchors[best_n][1] + 1e-16)
+
+        bbox[ii, best_n, :, gj, gi] = torch.stack([tx, ty, tw, th, torch.ones(1).cuda().squeeze()])
+        best_n_list.append(int(best_n))
+        best_gi.append(gi)
+        best_gj.append(gj)
+    bbox = Variable(bbox.cuda())
+    return bbox, best_gi, best_gj, best_n_list
+
+def adjust_learning_rate(args, optimizer, i_iter):
+    # print(optimizer.param_groups[0]['lr'], optimizer.param_groups[1]['lr'])
+    if i_iter in args.steps:
+        #lr = args.lr * args.power
+        lr = args.lr * args.power ** (args.steps.index(i_iter) + 1)
+        optimizer.param_groups[0]['lr'] = lr
+        if len(optimizer.param_groups) > 1:
+            optimizer.param_groups[1]['lr'] = lr / 10
+        if len(optimizer.param_groups) > 2:
+            optimizer.param_groups[2]['lr'] = lr / 10
+
+def cem_loss(co_energy):
+    loss = -1.0 * torch.log(co_energy+1e-6).sum()
+    return loss
+
+class FocalLoss(nn.Module):
+    def __init__(self, alpha=0.25, gamma=2, logits=True, reduce=False):
+        super(FocalLoss, self).__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.logits = logits
+        self.reduce = reduce
+
+    def forward(self, inputs, targets):
+        if self.logits:
+            BCE_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduce=False)
+        else:
+            BCE_loss = F.binary_cross_entropy(inputs, targets, reduce=False)
+        pt = torch.exp(-BCE_loss)
+        F_loss = self.alpha * (1-pt)**self.gamma * BCE_loss
+        if self.reduce:
+            return torch.mean(F_loss)
+        else:
+            return torch.sum(F_loss)

ASDA/utils/misc_utils.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+"""
+Misc download and visualization helper functions and class wrappers.
+"""
+
+import sys
+import time
+import torch
+from visdom import Visdom
+
+
+def reporthook(count, block_size, total_size):
+    global start_time
+    if count == 0:
+        start_time = time.time()
+        return
+    duration = time.time() - start_time
+    progress_size = int(count * block_size)
+    speed = int(progress_size / (1024 * duration))
+    percent = min(int(count * block_size * 100 / total_size), 100)
+    sys.stdout.write("\r...%d%%, %d MB, %d KB/s, %d seconds passed" %
+                     (percent, progress_size / (1024 * 1024), speed, duration))
+    sys.stdout.flush()
+
+
+class VisdomWrapper(Visdom):
+    def __init__(self, *args, env=None, **kwargs):
+        Visdom.__init__(self, *args, **kwargs)
+        self.env = env
+        self.plots = {}
+
+    def init_line_plot(self, name,
+                       X=torch.zeros((1,)).cpu(),
+                       Y=torch.zeros((1,)).cpu(), **opts):
+        self.plots[name] = self.line(X=X, Y=Y, env=self.env, opts=opts)
+
+    def plot_line(self, name, **kwargs):
+        self.line(win=self.plots[name], env=self.env, **kwargs)

ASDA/utils/parsing_metrics.py

@@ -0,0 +1,106 @@
+import torch
+import numpy as np
+
+def _fast_hist(label_true, label_pred, n_class):
+    mask = (label_true >= 0) & (label_true < n_class)
+    hist = np.bincount(
+        n_class * label_true[mask].astype(int) +
+        label_pred[mask], minlength=n_class ** 2).reshape(n_class, n_class)
+    return hist
+
+def label_accuracy_score(label_trues, label_preds, n_class, bg_thre=200):
+    """Returns accuracy score evaluation result.
+      - overall accuracy
+      - mean accuracy
+      - mean IU
+      - fwavacc
+    """
+    hist = np.zeros((n_class, n_class))
+    for lt, lp in zip(label_trues, label_preds):
+        # hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)
+        hist += _fast_hist(lt[lt<bg_thre].flatten(), lp[lt<bg_thre].flatten(), n_class)
+    acc = np.diag(hist).sum() / hist.sum()
+    acc_cls = np.diag(hist) / hist.sum(axis=1)
+    acc_cls = np.nanmean(acc_cls)
+    iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))
+    mean_iu = np.nanmean(iu)
+    freq = hist.sum(axis=1) / hist.sum()
+    fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()
+    return acc, acc_cls, mean_iu, fwavacc
+
+def label_confusion_matrix(label_trues, label_preds, n_class, bg_thre=200):
+    # eps=1e-20
+    hist=np.zeros((n_class,n_class),dtype=float)
+    """ (8,256,256), (256,256) """
+    for lt,lp in zip(label_trues, label_preds):
+        # hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)
+        hist += _fast_hist(lt[lt<bg_thre].flatten(), lp[lt<bg_thre].flatten(), n_class)
+    iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))
+    # for i in range(n_class):
+    # 	hist[i,:]=(hist[i,:]+eps)/sum(hist[i,:]+eps)
+    return hist, iu
+
+def body_region_confusion_matrix(label_trues, label_preds, n_class, boxes, counter):
+    ## pred: [bb,region_index,c,h,w] (pred score)
+    ## gt: [bb,region_index,h,w] (0-nclass score)
+    label_trues = label_trues.data.cpu().numpy()
+    label_preds = label_preds.data.cpu().numpy()
+    hist=np.zeros((label_trues.shape[1],n_class,n_class),dtype=float)
+    for body_i in range(label_trues.shape[1]):
+        for bb in range(label_trues.shape[0]):
+            if body_i != label_trues.shape[1]-1 and \
+                torch.equal(boxes[bb,body_i,:], torch.Tensor([0.,0.,1.,1.])):
+                counter+=1
+                continue
+            else:
+                hist[body_i,:,:] += label_confusion_matrix(label_trues[bb,body_i,:,:], \
+                        np.argmax(label_preds[bb,body_i,:,:,:], axis=0), n_class)[0]
+    return hist
+
+def hist_based_accu_cal(hist):
+    acc = np.diag(hist).sum() / hist.sum()
+    acc_cls = np.diag(hist) / hist.sum(axis=1)
+    acc_cls = np.nanmean(acc_cls)
+    iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))
+    mean_iu = np.nanmean(iu)
+    freq = hist.sum(axis=1) / hist.sum()
+    fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()
+    return acc, acc_cls, mean_iu, fwavacc, iu
+
+def cal_seg_iou_loss(gt,pred,trsh=0.5):
+    t=np.array(pred>trsh)
+    p=np.array(gt>0.)
+    intersection = np.logical_and(t, p)
+    union = np.logical_or(t, p)
+    iou = (np.sum(intersection > 0 , axis=(2,3)) + 1e-10 )/ (np.sum(union > 0, axis=(2,3)) + 1e-10)
+    return iou
+
+def cal_seg_iou(gt,pred,trsh=0.5):
+    #(gt.shape) [1 428 640]
+    #(pred.shape)  [428 640]
+    t=np.array(pred>trsh)
+    p=np.array(gt>0.)
+    intersection = np.logical_and(t, p)
+    union = np.logical_or(t, p)
+    iou = (np.sum(intersection > 0) + 1e-10 )/ (np.sum(union > 0) + 1e-10)
+    
+    prec=dict()
+    thresholds = np.arange(0.5, 1, 0.05)
+    for thresh in thresholds:
+        prec[thresh]= float(iou > thresh)
+    return iou,prec
+
+def cal_seg_iou2(gt,pred,trsh=0.5):
+    #(gt.shape) [1 428 640]
+    #(pred.shape)  [428 640]
+    t=np.array(pred>trsh)
+    p=np.array(gt>0.)
+    intersection = np.logical_and(t, p)
+    union = np.logical_or(t, p)
+    iou = (np.sum(intersection > 0) + 1e-10 )/ (np.sum(union > 0) + 1e-10)
+    
+    prec=dict()
+    thresholds = np.arange(0.5, 1, 0.05)
+    for thresh in thresholds:
+        prec[thresh]= float(iou > thresh)
+    return iou, prec, np.sum(intersection > 0), np.sum(union > 0)

ASDA/utils/transforms.py

@@ -0,0 +1,374 @@
+# -*- coding: utf-8 -*-
+
+"""
+Generic Image Transform utillities.
+"""
+
+import cv2
+import random, math
+import numpy as np
+from collections.abc import Iterable
+from torch import rand
+
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+
+class ResizePad:
+    """
+    Resize and pad an image to given size.
+    """
+
+    def __init__(self, size):
+        if not isinstance(size, (int, Iterable)):
+            raise TypeError('Got inappropriate size arg: {}'.format(size))
+
+        self.h, self.w = size
+
+    def __call__(self, img):
+        h, w = img.shape[:2]
+        scale = min(self.h / h, self.w / w)
+        resized_h = int(np.round(h * scale))
+        resized_w = int(np.round(w * scale))
+        pad_h = int(np.floor(self.h - resized_h) / 2)
+        pad_w = int(np.floor(self.w - resized_w) / 2)
+
+        resized_img = cv2.resize(img, (resized_w, resized_h))
+
+        # if img.ndim > 2:
+        if img.ndim > 2:
+            new_img = np.zeros(
+                (self.h, self.w, img.shape[-1]), dtype=resized_img.dtype)
+        else:
+            resized_img = np.expand_dims(resized_img, -1)
+            new_img = np.zeros((self.h, self.w, 1), dtype=resized_img.dtype)
+        new_img[pad_h: pad_h + resized_h,
+                pad_w: pad_w + resized_w, ...] = resized_img
+        return new_img
+
+
+class CropResize:
+    """Remove padding and resize image to its original size."""
+
+    def __call__(self, img, size):
+        if not isinstance(size, (int, Iterable)):
+            raise TypeError('Got inappropriate size arg: {}'.format(size))
+        im_h, im_w = img.data.shape[:2]
+        input_h, input_w = size
+        scale = max(input_h / im_h, input_w / im_w)
+        # scale = torch.Tensor([[input_h / im_h, input_w / im_w]]).max()
+        resized_h = int(np.round(im_h * scale))
+        # resized_h = torch.round(im_h * scale)
+        resized_w = int(np.round(im_w * scale))
+        # resized_w = torch.round(im_w * scale)
+        crop_h = int(np.floor(resized_h - input_h) / 2)
+        # crop_h = torch.floor(resized_h - input_h) // 2
+        crop_w = int(np.floor(resized_w - input_w) / 2)
+        # crop_w = torch.floor(resized_w - input_w) // 2
+        # resized_img = cv2.resize(img, (resized_w, resized_h))
+        resized_img = F.upsample(
+            img.unsqueeze(0).unsqueeze(0), size=(resized_h, resized_w),
+            mode='bilinear')
+
+        resized_img = resized_img.squeeze().unsqueeze(0)
+
+        return resized_img[0, crop_h: crop_h + input_h,
+                           crop_w: crop_w + input_w]
+
+
+class ResizeImage:
+    """Resize the largest of the sides of the image to a given size"""
+    def __init__(self, size):
+        if not isinstance(size, (int, Iterable)):
+            raise TypeError('Got inappropriate size arg: {}'.format(size))
+
+        self.size = size
+
+    def __call__(self, img):
+        im_h, im_w = img.shape[-2:]
+        scale = min(self.size / im_h, self.size / im_w)
+        resized_h = int(np.round(im_h * scale))
+        resized_w = int(np.round(im_w * scale))
+        out = F.upsample(
+            Variable(img).unsqueeze(0), size=(resized_h, resized_w),
+            mode='bilinear').squeeze().data
+        return out
+
+
+class ResizeAnnotation:
+    """Resize the largest of the sides of the annotation to a given size"""
+    def __init__(self, size):
+        if not isinstance(size, (int, Iterable)):
+            raise TypeError('Got inappropriate size arg: {}'.format(size))
+
+        self.size = size
+
+    def __call__(self, img):
+        im_h, im_w = img.shape[-2:]
+        scale = min(self.size / im_h, self.size / im_w)
+        resized_h = int(np.round(im_h * scale))
+        resized_w = int(np.round(im_w * scale))
+        out = F.upsample(
+            Variable(img).unsqueeze(0).unsqueeze(0),
+            size=(resized_h, resized_w),
+            mode='bilinear').squeeze().data
+        return out
+
+
+class ToNumpy:
+    """Transform an torch.*Tensor to an numpy ndarray."""
+
+    def __call__(self, x):
+        return x.numpy()
+
+def letterbox(img, mask, height, color=(123.7, 116.3, 103.5)):  # resize a rectangular image to a padded square
+    shape = img.shape[:2]  # shape = [height, width]
+    ratio = float(height) / max(shape)  # ratio  = old / new
+    new_shape = (round(shape[1] * ratio), round(shape[0] * ratio))
+    dw = (height - new_shape[0]) / 2  # width padding
+    dh = (height - new_shape[1]) / 2  # height padding
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    img = cv2.resize(img, new_shape, interpolation=cv2.INTER_AREA)  # resized, no border
+    img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # padded square
+    if mask is not None:
+        mask = cv2.resize(mask, new_shape, interpolation=cv2.INTER_NEAREST)  # resized, no border
+        mask = cv2.copyMakeBorder(mask, top, bottom, left, right, cv2.BORDER_CONSTANT, value=0)  # padded square
+    return img, mask, ratio, dw, dh
+
+
+def random_affine(img, mask, targets, degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-2, 2),
+                  borderValue=(123.7, 116.3, 103.5), all_bbox=None):
+    border = 0  # width of added border (optional)
+    height = max(img.shape[0], img.shape[1]) + border * 2
+
+    # Rotation and Scale
+    R = np.eye(3)
+    a = random.random() * (degrees[1] - degrees[0]) + degrees[0]
+    # a += random.choice([-180, -90, 0, 90])  # 90deg rotations added to small rotations
+    s = random.random() * (scale[1] - scale[0]) + scale[0]
+    R[:2] = cv2.getRotationMatrix2D(angle=a, center=(img.shape[1] / 2, img.shape[0] / 2), scale=s)
+
+    # Translation
+    T = np.eye(3)
+    T[0, 2] = (random.random() * 2 - 1) * translate[0] * img.shape[0] + border  # x translation (pixels)
+    T[1, 2] = (random.random() * 2 - 1) * translate[1] * img.shape[1] + border  # y translation (pixels)
+
+    # Shear
+    S = np.eye(3)
+    S[0, 1] = math.tan((random.random() * (shear[1] - shear[0]) + shear[0]) * math.pi / 180)  # x shear (deg)
+    S[1, 0] = math.tan((random.random() * (shear[1] - shear[0]) + shear[0]) * math.pi / 180)  # y shear (deg)
+
+    M = S @ T @ R  # Combined rotation matrix. ORDER IS IMPORTANT HERE!!
+    imw = cv2.warpPerspective(img, M, dsize=(height, height), flags=cv2.INTER_LINEAR,
+                              borderValue=borderValue)  # BGR order borderValue
+    if mask is not None:
+        maskw = cv2.warpPerspective(mask, M, dsize=(height, height), flags=cv2.INTER_NEAREST,
+                                  borderValue=0)  # BGR order borderValue
+    else:
+        maskw = None
+
+    # Return warped points also
+    if type(targets)==type([1]):
+        targetlist=[]
+        for bbox in targets:
+            targetlist.append(wrap_points(bbox, M, height, a))
+        return imw, maskw, targetlist, M
+    elif all_bbox is not None:
+        targets = wrap_points(targets, M, height, a)
+        for ii in range(all_bbox.shape[0]):
+            all_bbox[ii,:] = wrap_points(all_bbox[ii,:], M, height, a)
+        return imw, maskw, targets, all_bbox, M
+    elif targets is not None:   ## previous main
+        targets = wrap_points(targets, M, height, a)
+        return imw, maskw, targets, M
+    else:
+        return imw
+
+def wrap_points(targets, M, height, a):
+    # n = targets.shape[0]
+    # points = targets[:, 1:5].copy()
+    points = targets.copy()
+    # area0 = (points[:, 2] - points[:, 0]) * (points[:, 3] - points[:, 1])
+    area0 = (points[2] - points[0]) * (points[3] - points[1])
+
+    # warp points
+    xy = np.ones((4, 3))
+    xy[:, :2] = points[[0, 1, 2, 3, 0, 3, 2, 1]].reshape(4, 2)  # x1y1, x2y2, x1y2, x2y1
+    xy = (xy @ M.T)[:, :2].reshape(1, 8)
+
+    # create new boxes
+    x = xy[:, [0, 2, 4, 6]]
+    y = xy[:, [1, 3, 5, 7]]
+    xy = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, 1).T
+
+    # apply angle-based reduction
+    radians = a * math.pi / 180
+    reduction = max(abs(math.sin(radians)), abs(math.cos(radians))) ** 0.5
+    x = (xy[:, 2] + xy[:, 0]) / 2
+    y = (xy[:, 3] + xy[:, 1]) / 2
+    w = (xy[:, 2] - xy[:, 0]) * reduction
+    h = (xy[:, 3] - xy[:, 1]) * reduction
+    xy = np.concatenate((x - w / 2, y - h / 2, x + w / 2, y + h / 2)).reshape(4, 1).T
+
+    # reject warped points outside of image
+    np.clip(xy, 0, height, out=xy)
+    w = xy[:, 2] - xy[:, 0]
+    h = xy[:, 3] - xy[:, 1]
+    area = w * h
+    ar = np.maximum(w / (h + 1e-16), h / (w + 1e-16))
+    i = (w > 4) & (h > 4) & (area / (area0 + 1e-16) > 0.1) & (ar < 10)
+
+    ## print(targets, xy)
+    ## [ 56  36 108 210] [[ 47.80464857  15.6096533  106.30993434 196.71267693]]
+    # targets = targets[i]
+    # targets[:, 1:5] = xy[i]
+    targets = xy[0]
+    return targets
+
+
+def random_crop(img, seg, pad, h, w):
+    if random.random() < 0.5:
+        return img, seg
+
+    img = cv2.copyMakeBorder(img, pad, pad, pad, pad, cv2.BORDER_CONSTANT, value=(123.7, 116.3, 103.5))
+    seg = cv2.copyMakeBorder(seg, pad, pad, pad, pad, cv2.BORDER_CONSTANT, value=(0, 0, 0))
+
+    Left = random.randint(0, pad * 2)
+    Top = random.randint(0, pad * 2)
+
+    seg_pixel = seg.sum()
+
+    for _ in range(100):
+        if seg[Top: Top + h, Left: Left + w].sum() / seg_pixel > 0.95 and seg[Top: Top + h, Left: Left + w].sum() > 0:
+            img = img[Top: Top + h, Left: Left + w, :]
+            seg = seg[Top: Top + h, Left: Left + w]
+
+            return img, seg
+
+        Left = random.randint(0, pad * 2)
+        Top = random.randint(0, pad * 2)
+
+    return img, seg
+
+
+def random_copy(img, seg, phrase, bbox):
+    if 'left' in phrase or 'right' in phrase or \
+       'center' in phrase or 'middle' in phrase or \
+       'front' in phrase or 'back' in phrase:
+        return img, seg, phrase, bbox
+
+    if random.random() < 0.75:
+        return img, seg, phrase, bbox
+
+    h, w = img.shape[0], img.shape[1]
+
+    # x1, y1, x2, y2 = w, h, 0, 0
+    # for j in range(h):
+    #     for i in range(w):
+    #         if seg[j, i] > 0:
+    #             if i < x1: x1 = i
+    #             if j < y1: y1 = j
+    #             if i > x2: x2 = i
+    #             if j > y2: y2 = j
+    # x2 = x2 + 1
+    # y2 = y2 + 1
+
+    # contours, hierarchy = cv2.findContours(seg.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    # c = max(contours, key = cv2.contourArea)
+    x, y, bboxw, bboxh = cv2.boundingRect(seg.astype(np.uint8))
+    x1 = x
+    y1 = y
+    x2 = x + bboxw 
+    y2 = y + bboxh 
+
+    if x1 - (x2 - x1) < 0 or w - (x2 - x1) < x2:
+        return img, seg, phrase, bbox
+
+    # tmp = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    # color_mask = np.array([0, 255, 0], dtype=np.uint8)
+    # mask = seg.astype(np.bool)
+    # tmp[mask] = tmp[mask] * 0.5 + color_mask * 0.5
+    # cv2.imwrite('./{}.png'.format(phrase.replace(' ', '_')), tmp)
+
+    if random.random() < 0.5:
+        new_x1 = random.randint(0, x1 - (x2 - x1))
+        phrase += ' on left'
+    else:
+        new_x1 = random.randint(x2, w - (x2 - x1))
+        phrase += ' on right'
+
+    new_x2 = new_x1 + (x2 - x1)
+
+    delta_y = random.randint((y1 - y2), y2 - y1)
+    
+    while y2 + delta_y > h or y1 + delta_y < 0:
+        delta_y = random.randint((y1 - y2), y2 - y1)
+
+    new_y1 = y1 + delta_y
+    new_y2 = y2 + delta_y
+
+    new_seg = np.zeros_like(seg)
+    new_seg[new_y1: new_y2, new_x1: new_x2] = seg[y1: y2, x1: x2]
+
+    # tmp = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    # color_mask = np.array([0, 255, 0], dtype=np.uint8)
+    # mask = new_seg.astype(np.bool)
+    # tmp[mask] = tmp[mask] * 0.5 + color_mask * 0.5
+    # cv2.imwrite('./{}.png'.format(phrase.replace(' ', '_')), tmp)
+
+    img[new_seg.astype(np.bool)] = img[seg.astype(np.bool)]
+    # bbox = [new_x1, new_y1, new_x2 - 1, new_y2 - 1]
+    seg = new_seg
+
+    # tmp = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    # color_mask = np.array([0, 255, 0], dtype=np.uint8)
+    # mask = seg.astype(np.bool)
+    # tmp[mask] = tmp[mask] * 0.5 + color_mask * 0.5
+    # cv2.imwrite('./{}.png'.format(phrase.replace(' ', '_')), tmp)
+
+    # exit()
+
+    return img, seg, phrase, bbox
+        
+
+def random_erase(img, seg):
+    if random.random() < 0.5:
+        return img, seg
+
+    x, y, bboxw, bboxh = cv2.boundingRect(seg.astype(np.uint8))
+
+    area = bboxw * bboxh * 0.5
+
+    for attempt in range(100):
+        target_area = random.uniform(0.02, 0.4)
+        aspect_ratio = random.uniform(0.3, 1/0.3)
+
+        h = int(round(math.sqrt(target_area * aspect_ratio)))
+        w = int(round(math.sqrt(target_area / aspect_ratio)))
+
+        if w < bboxw and h < bboxh:
+            x1 = random.randint(0, bboxw - w)
+            y1 = random.randint(0, bboxh - h)
+
+            new_seg = seg.copy()
+            new_seg[y+y1: y+y1+h, x+x1: x+x1+w] = 0
+
+            if new_seg.sum() / seg.sum() > 0.75:
+                continue
+
+            seg[y+y1: y+y1+h, x+x1: x+x1+w] = 0
+
+            img[y+y1: y+y1+h, x+x1: x+x1+w, 0] = 123.7
+            img[y+y1: y+y1+h, x+x1: x+x1+w, 1] = 116.3
+            img[y+y1: y+y1+h, x+x1: x+x1+w, 2] = 103.5
+
+            # tmp = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            # color_mask = np.array([0, 255, 0], dtype=np.uint8)
+            # mask = seg.astype(np.bool)
+            # tmp[mask] = tmp[mask] * 0.5 + color_mask * 0.5
+            # cv2.imwrite('./erase.png', tmp)
+
+            return img, seg
+
+    return img, seg

ASDA/utils/utils.py

@@ -0,0 +1,262 @@
+import math
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import optim
+from torch.optim import Optimizer
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+def xyxy2xywh(x):  # Convert bounding box format from [x1, y1, x2, y2] to [x, y, w, h]
+    y = torch.zeros(x.shape) if x.dtype is torch.float32 else np.zeros(x.shape)
+    y[:, 0] = (x[:, 0] + x[:, 2]) / 2
+    y[:, 1] = (x[:, 1] + x[:, 3]) / 2
+    y[:, 2] = x[:, 2] - x[:, 0]
+    y[:, 3] = x[:, 3] - x[:, 1]
+    return y
+
+
+def xywh2xyxy(x):  # Convert bounding box format from [x, y, w, h] to [x1, y1, x2, y2]
+    y = torch.zeros(x.shape) if x.dtype is torch.float32 else np.zeros(x.shape)
+    y[:, 0] = (x[:, 0] - x[:, 2] / 2)
+    y[:, 1] = (x[:, 1] - x[:, 3] / 2)
+    y[:, 2] = (x[:, 0] + x[:, 2] / 2)
+    y[:, 3] = (x[:, 1] + x[:, 3] / 2)
+    return y
+    
+def bbox_iou_numpy(box1, box2):
+    """Computes IoU between bounding boxes.
+    Parameters
+    ----------
+    box1 : ndarray
+        (N, 4) shaped array with bboxes
+    box2 : ndarray
+        (M, 4) shaped array with bboxes
+    Returns
+    -------
+    : ndarray
+        (N, M) shaped array with IoUs
+    """
+    area = (box2[:, 2] - box2[:, 0]) * (box2[:, 3] - box2[:, 1])
+
+    iw = np.minimum(np.expand_dims(box1[:, 2], axis=1), box2[:, 2]) - np.maximum(
+        np.expand_dims(box1[:, 0], 1), box2[:, 0]
+    )
+    ih = np.minimum(np.expand_dims(box1[:, 3], axis=1), box2[:, 3]) - np.maximum(
+        np.expand_dims(box1[:, 1], 1), box2[:, 1]
+    )
+
+    iw = np.maximum(iw, 0)
+    ih = np.maximum(ih, 0)
+
+    ua = np.expand_dims((box1[:, 2] - box1[:, 0]) * (box1[:, 3] - box1[:, 1]), axis=1) + area - iw * ih
+
+    ua = np.maximum(ua, np.finfo(float).eps)
+
+    intersection = iw * ih
+
+    return intersection / ua
+
+
+def bbox_iou(box1, box2, x1y1x2y2=True):
+    """
+    Returns the IoU of two bounding boxes
+    """
+    if x1y1x2y2:
+        # Get the coordinates of bounding boxes
+        b1_x1, b1_y1, b1_x2, b1_y2 = box1[:, 0], box1[:, 1], box1[:, 2], box1[:, 3]
+        b2_x1, b2_y1, b2_x2, b2_y2 = box2[:, 0], box2[:, 1], box2[:, 2], box2[:, 3]
+    else:
+        # Transform from center and width to exact coordinates
+        b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2
+        b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2
+        b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2
+        b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2
+
+    # get the coordinates of the intersection rectangle
+    inter_rect_x1 = torch.max(b1_x1, b2_x1)
+    inter_rect_y1 = torch.max(b1_y1, b2_y1)
+    inter_rect_x2 = torch.min(b1_x2, b2_x2)
+    inter_rect_y2 = torch.min(b1_y2, b2_y2)
+    # Intersection area
+    inter_area = torch.clamp(inter_rect_x2 - inter_rect_x1, 0) * torch.clamp(inter_rect_y2 - inter_rect_y1, 0)
+    # Union Area
+    b1_area = (b1_x2 - b1_x1) * (b1_y2 - b1_y1)
+    b2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1)
+
+    # print(box1, box1.shape)
+    # print(box2, box2.shape)
+    return inter_area / (b1_area + b2_area - inter_area + 1e-16)
+
+def multiclass_metrics(pred, gt):
+  """
+  check precision and recall for predictions.
+  Output: overall = {precision, recall, f1}
+  """
+  eps=1e-6
+  overall = {'precision': -1, 'recall': -1, 'f1': -1}
+  NP, NR, NC = 0, 0, 0  # num of pred, num of recall, num of correct
+  for ii in range(pred.shape[0]):
+    pred_ind = np.array(pred[ii]>0.5, dtype=int)
+    gt_ind = np.array(gt[ii]>0.5, dtype=int)
+    inter = pred_ind * gt_ind
+    # add to overall
+    NC += np.sum(inter)
+    NP += np.sum(pred_ind)
+    NR += np.sum(gt_ind)
+  if NP > 0:
+    overall['precision'] = float(NC)/NP
+  if NR > 0:
+    overall['recall'] = float(NC)/NR
+  if NP > 0 and NR > 0:
+    overall['f1'] = 2*overall['precision']*overall['recall']/(overall['precision']+overall['recall']+eps)
+  return overall
+
+def compute_ap(recall, precision):
+    """ Compute the average precision, given the recall and precision curves.
+    Code originally from https://github.com/rbgirshick/py-faster-rcnn.
+    # Arguments
+        recall:    The recall curve (list).
+        precision: The precision curve (list).
+    # Returns
+        The average precision as computed in py-faster-rcnn.
+    """
+    # correct AP calculation
+    # first append sentinel values at the end
+    mrec = np.concatenate(([0.0], recall, [1.0]))
+    mpre = np.concatenate(([0.0], precision, [0.0]))
+
+    # compute the precision envelope
+    for i in range(mpre.size - 1, 0, -1):
+        mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+    # to calculate area under PR curve, look for points
+    # where X axis (recall) changes value
+    i = np.where(mrec[1:] != mrec[:-1])[0]
+
+    # and sum (\Delta recall) * prec
+    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+    return ap
+
+def concat_coord(x):
+    ins_feat = x  # [bt, c, h, w] [512, 26, 26]
+    batch_size, c, h, w = x.size()
+
+    float_h = float(h)
+    float_w = float(w)
+
+    y_range = torch.arange(0., float_h, dtype=torch.float32)     # [h, ]
+    y_range = 2.0 * y_range / (float_h - 1.0) - 1.0
+    x_range = torch.arange(0., float_w, dtype=torch.float32)     # [w, ]
+    x_range = 2.0 * x_range / (float_w - 1.0) - 1.0
+    x_range = x_range[None, :]   # [1, w]
+    y_range = y_range[:, None]   # [h, 1]
+    x = x_range.repeat(h, 1)     # [h, w]
+    y = y_range.repeat(1, w)     # [h, w]
+
+    x = x[None, None, :, :]   # [1, 1, h, w]
+    y = y[None, None, :, :]   # [1, 1, h, w]
+    x = x.repeat(batch_size, 1, 1, 1)   # [N, 1, h, w]
+    y = y.repeat(batch_size, 1, 1, 1)   # [N, 1, h, w]
+    x = x.cuda()
+    y = y.cuda()
+
+    ins_feat_out = torch.cat((ins_feat, x, x, x, y, y, y), 1) # [N, c+6, h, w]
+
+    return ins_feat_out
+
+
+def get_cosine_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int,
+    num_cycles: float = 0.5, last_epoch: int = -1):
+    """
+        Implementation by Huggingface:
+        https://github.com/huggingface/transformers/blob/v4.16.2/src/transformers/optimization.py
+
+        Create a schedule with a learning rate that decreases following the values
+        of the cosine function between the initial lr set in the optimizer to 0,
+        after a warmup period during which it increases linearly between 0 and the
+        initial lr set in the optimizer.
+        Args:
+        optimizer ([`~torch.optim.Optimizer`]):
+        The optimizer for which to schedule the learning rate.
+        num_warmup_steps (`int`):
+        The number of steps for the warmup phase.
+        num_training_steps (`int`):
+        The total number of training steps.
+        num_cycles (`float`, *optional*, defaults to 0.5):
+        The number of waves in the cosine schedule (the defaults is to just
+        decrease from the max value to 0 following a half-cosine).
+        last_epoch (`int`, *optional*, defaults to -1):
+        The index of the last epoch when resuming training.
+        Return:
+        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
+    """
+
+    def lr_lambda(current_step):
+        if current_step < num_warmup_steps:
+            return max(1e-6, float(current_step) / float(max(1, num_warmup_steps)))
+        progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
+        return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress)))
+
+    return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch)
+
+def dice_loss(inputs, targets):
+    """
+    Compute the DICE loss, similar to generalized IOU for masks
+    Args:
+        inputs: A float tensor of arbitrary shape.
+                The predictions for each example.
+        targets: A float tensor with the same shape as inputs. Stores the binary
+                 classification label for each element in inputs
+                (0 for the negative class and 1 for the positive class).
+    """
+
+    inputs = inputs.sigmoid()
+    inputs = inputs.flatten(1)
+    targets = targets.flatten(1)
+    numerator = 2 * (inputs * targets).sum(1)
+    denominator = inputs.sum(-1) + targets.sum(-1)
+    loss = 1 - (numerator + 1) / (denominator + 1)
+    return loss.mean()
+
+def sigmoid_focal_loss(inputs, targets, alpha: float = -1, gamma: float = 0):
+    """
+    Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.
+    Args:
+        inputs: A float tensor of arbitrary shape.
+                The predictions for each example.
+        targets: A float tensor with the same shape as inputs. Stores the binary
+                 classification label for each element in inputs
+                (0 for the negative class and 1 for the positive class).
+        alpha: (optional) Weighting factor in range (0,1) to balance
+                positive vs negative examples. Default = -1 (no weighting).
+        gamma: Exponent of the modulating factor (1 - p_t) to
+               balance easy vs hard examples.
+    Returns:
+        Loss tensor
+    """
+
+    prob = inputs.sigmoid()
+    ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none")
+    p_t = prob * targets + (1 - prob) * (1 - targets)
+    loss = ce_loss * ((1 - p_t) ** gamma)
+
+    if alpha >= 0:
+        alpha_t = alpha * targets + (1 - alpha) * (1 - targets)
+        loss = alpha_t * loss
+    return loss.mean()