Upload 2 files

utils.py

@@ -0,0 +1,387 @@
+import os
+import time
+import shutil
+
+import torch
+import numpy as np
+from torch.optim import SGD, Adam, AdamW
+from tensorboardX import SummaryWriter
+
+import sod_metric
+class Averager():
+
+    def __init__(self):
+        self.n = 0.0
+        self.v = 0.0
+
+    def add(self, v, n=1.0):
+        self.v = (self.v * self.n + v * n) / (self.n + n)
+        self.n += n
+
+    def item(self):
+        return self.v
+
+
+class Timer():
+
+    def __init__(self):
+        self.v = time.time()
+
+    def s(self):
+        self.v = time.time()
+
+    def t(self):
+        return time.time() - self.v
+
+
+def time_text(t):
+    if t >= 3600:
+        return '{:.1f}h'.format(t / 3600)
+    elif t >= 60:
+        return '{:.1f}m'.format(t / 60)
+    else:
+        return '{:.1f}s'.format(t)
+
+
+_log_path = None
+
+
+def set_log_path(path):
+    global _log_path
+    _log_path = path
+
+
+def log(obj, filename='log.txt'):
+    print(obj)
+    if _log_path is not None:
+        with open(os.path.join(_log_path, filename), 'a') as f:
+            print(obj, file=f)
+
+
+def ensure_path(path, remove=True):
+    basename = os.path.basename(path.rstrip('/'))
+    if os.path.exists(path):
+        if remove and (basename.startswith('_')
+                or input('{} exists, remove? (y/[n]): '.format(path)) == 'y'):
+            shutil.rmtree(path)
+            os.makedirs(path, exist_ok=True)
+    else:
+        os.makedirs(path, exist_ok=True)
+
+
+def set_save_path(save_path, remove=True):
+    ensure_path(save_path, remove=remove)
+    set_log_path(save_path)
+    writer = SummaryWriter(os.path.join(save_path, 'tensorboard'))
+    return log, writer
+
+
+def compute_num_params(model, text=False):
+    tot = int(sum([np.prod(p.shape) for p in model.parameters()]))
+    if text:
+        if tot >= 1e6:
+            return '{:.1f}M'.format(tot / 1e6)
+        else:
+            return '{:.1f}K'.format(tot / 1e3)
+    else:
+        return tot
+
+
+def make_optimizer(param_list, optimizer_spec, load_sd=False):
+    Optimizer = {
+        'sgd': SGD,
+        'adam': Adam,
+        'adamw': AdamW
+    }[optimizer_spec['name']]
+    optimizer = Optimizer(param_list, **optimizer_spec['args'])
+    if load_sd:
+        optimizer.load_state_dict(optimizer_spec['sd'])
+    return optimizer
+
+
+def make_coord(shape, ranges=None, flatten=True):
+    """ Make coordinates at grid centers.
+    """
+    coord_seqs = []
+    for i, n in enumerate(shape):
+        if ranges is None:
+            v0, v1 = -1, 1
+        else:
+            v0, v1 = ranges[i]
+        r = (v1 - v0) / (2 * n)
+        seq = v0 + r + (2 * r) * torch.arange(n).float()
+        coord_seqs.append(seq)
+    ret = torch.stack(torch.meshgrid(*coord_seqs), dim=-1)
+    # if flatten:
+    #     ret = ret.view(-1, ret.shape[-1])
+
+    return ret
+
+
+
+def calc_cod(y_pred, y_true):
+    batchsize = y_true.shape[0]
+
+    metric_FM = sod_metric.Fmeasure()
+    metric_WFM = sod_metric.WeightedFmeasure()
+    metric_SM = sod_metric.Smeasure()
+    metric_EM = sod_metric.Emeasure()
+    metric_MAE = sod_metric.MAE()
+    with torch.no_grad():
+        assert y_pred.shape == y_true.shape
+
+        for i in range(batchsize):
+            true, pred = \
+                y_true[i, 0].cpu().data.numpy() * 255, y_pred[i, 0].cpu().data.numpy() * 255
+
+            metric_FM.step(pred=pred, gt=true)
+            metric_WFM.step(pred=pred, gt=true)
+            metric_SM.step(pred=pred, gt=true)
+            metric_EM.step(pred=pred, gt=true)
+            metric_MAE.step(pred=pred, gt=true)
+
+        fm = metric_FM.get_results()["fm"]
+        wfm = metric_WFM.get_results()["wfm"]
+        sm = metric_SM.get_results()["sm"]
+        em = metric_EM.get_results()["em"]["curve"].mean()
+        mae = metric_MAE.get_results()["mae"]
+
+    return sm, em, wfm, mae
+
+
+from sklearn.metrics import precision_recall_curve
+
+
+def calc_f1(y_pred,y_true):
+    batchsize = y_true.shape[0]
+    with torch.no_grad():
+        print(y_pred.shape)
+        print(y_true.shape)
+        assert y_pred.shape == y_true.shape
+        f1, auc = 0, 0
+        y_true = y_true.cpu().numpy()
+        y_pred = y_pred.cpu().numpy()
+        for i in range(batchsize):
+            true = y_true[i].flatten()
+            true = true.astype(np.int)
+            pred = y_pred[i].flatten()
+
+            precision, recall, thresholds = precision_recall_curve(true, pred)
+
+            # auc
+            auc += roc_auc_score(true, pred)
+            # auc += roc_auc_score(np.array(true>0).astype(np.int), pred)
+            f1 += max([(2 * p * r) / (p + r+1e-10) for p, r in zip(precision, recall)])
+
+    return f1/batchsize, auc/batchsize, np.array(0), np.array(0)
+
+def calc_fmeasure(y_pred,y_true):
+    batchsize = y_true.shape[0]
+
+    mae, preds, gts = [], [], []
+    with torch.no_grad():
+        for i in range(batchsize):
+            gt_float, pred_float = \
+                y_true[i, 0].cpu().data.numpy(), y_pred[i, 0].cpu().data.numpy()
+
+            # # MAE
+            mae.append(np.sum(cv2.absdiff(gt_float.astype(float), pred_float.astype(float))) / (
+                        pred_float.shape[1] * pred_float.shape[0]))
+            # mae.append(np.mean(np.abs(pred_float - gt_float)))
+            #
+            pred = np.uint8(pred_float * 255)
+            gt = np.uint8(gt_float * 255)
+
+            pred_float_ = np.where(pred > min(1.5 * np.mean(pred), 255), np.ones_like(pred_float),
+                                   np.zeros_like(pred_float))
+            gt_float_ = np.where(gt > min(1.5 * np.mean(gt), 255), np.ones_like(pred_float),
+                                 np.zeros_like(pred_float))
+
+            preds.extend(pred_float_.ravel())
+            gts.extend(gt_float_.ravel())
+
+        RECALL = recall_score(gts, preds)
+        PERC = precision_score(gts, preds)
+
+        fmeasure = (1 + 0.3) * PERC * RECALL / (0.3 * PERC + RECALL)
+        MAE = np.mean(mae)
+
+    return fmeasure, MAE, np.array(0), np.array(0)
+
+from sklearn.metrics import roc_auc_score,recall_score,precision_score
+import cv2
+def calc_ber(y_pred, y_true):
+    batchsize = y_true.shape[0]
+    y_pred, y_true = y_pred.permute(0, 2, 3, 1).squeeze(-1), y_true.permute(0, 2, 3, 1).squeeze(-1)
+    with torch.no_grad():
+        assert y_pred.shape == y_true.shape
+        pos_err, neg_err, ber = 0, 0, 0
+        y_true = y_true.cpu().numpy()
+        y_pred = y_pred.cpu().numpy()
+        for i in range(batchsize):
+            true = y_true[i].flatten()
+            pred = y_pred[i].flatten()
+
+            TP, TN, FP, FN, BER, ACC = get_binary_classification_metrics(pred * 255,
+                                                                         true * 255, 125)
+            pos_err += (1 - TP / (TP + FN)) * 100
+            neg_err += (1 - TN / (TN + FP)) * 100
+
+    return pos_err / batchsize, neg_err / batchsize, (pos_err + neg_err) / 2 / batchsize, np.array(0)
+
+def get_binary_classification_metrics(pred, gt, threshold=None):
+    if threshold is not None:
+        gt = (gt > threshold)
+        pred = (pred > threshold)
+    TP = np.logical_and(gt, pred).sum()
+    TN = np.logical_and(np.logical_not(gt), np.logical_not(pred)).sum()
+    FN = np.logical_and(gt, np.logical_not(pred)).sum()
+    FP = np.logical_and(np.logical_not(gt), pred).sum()
+    BER = cal_ber(TN, TP, FN, FP)
+    ACC = cal_acc(TN, TP, FN, FP)
+    return TP, TN, FP, FN, BER, ACC
+
+def cal_ber(tn, tp, fn, fp):
+    return  0.5*(fp/(tn+fp) + fn/(fn+tp))
+
+def cal_acc(tn, tp, fn, fp):
+    return (tp + tn) / (tp + tn + fp + fn)
+
+def _sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+
+def _eval_pr(y_pred, y, num):
+    prec, recall = torch.zeros(num), torch.zeros(num)
+    thlist = torch.linspace(0, 1 - 1e-10, num)
+    for i in range(num):
+        y_temp = (y_pred >= thlist[i]).float()
+        tp = (y_temp * y).sum()
+        prec[i], recall[i] = tp / (y_temp.sum() + 1e-20), tp / (y.sum() +
+                                                                1e-20)
+    return prec, recall
+
+def _S_object(pred, gt):
+    fg = torch.where(gt == 0, torch.zeros_like(pred), pred)
+    bg = torch.where(gt == 1, torch.zeros_like(pred), 1 - pred)
+    o_fg = _object(fg, gt)
+    o_bg = _object(bg, 1 - gt)
+    u = gt.mean()
+    Q = u * o_fg + (1 - u) * o_bg
+    return Q
+
+def _object(pred, gt):
+    temp = pred[gt == 1]
+    x = temp.mean()
+    sigma_x = temp.std()
+    score = 2.0 * x / (x * x + 1.0 + sigma_x + 1e-20)
+
+    return score
+
+def _S_region(pred, gt):
+    X, Y = _centroid(gt)
+    gt1, gt2, gt3, gt4, w1, w2, w3, w4 = _divideGT(gt, X, Y)
+    p1, p2, p3, p4 = _dividePrediction(pred, X, Y)
+    Q1 = _ssim(p1, gt1)
+    Q2 = _ssim(p2, gt2)
+    Q3 = _ssim(p3, gt3)
+    Q4 = _ssim(p4, gt4)
+    Q = w1 * Q1 + w2 * Q2 + w3 * Q3 + w4 * Q4
+    return Q
+
+def _centroid(gt):
+    rows, cols = gt.size()[-2:]
+    gt = gt.view(rows, cols)
+    if gt.sum() == 0:
+        X = torch.eye(1) * round(cols / 2)
+        Y = torch.eye(1) * round(rows / 2)
+    else:
+        total = gt.sum()
+        i = torch.from_numpy(np.arange(0, cols)).float().cuda()
+        j = torch.from_numpy(np.arange(0, rows)).float().cuda()
+        X = torch.round((gt.sum(dim=0) * i).sum() / total + 1e-20)
+        Y = torch.round((gt.sum(dim=1) * j).sum() / total + 1e-20)
+    return X.long(), Y.long()
+
+
+def _divideGT(gt, X, Y):
+    h, w = gt.size()[-2:]
+    area = h * w
+    gt = gt.view(h, w)
+    LT = gt[:Y, :X]
+    RT = gt[:Y, X:w]
+    LB = gt[Y:h, :X]
+    RB = gt[Y:h, X:w]
+    X = X.float()
+    Y = Y.float()
+    w1 = X * Y / area
+    w2 = (w - X) * Y / area
+    w3 = X * (h - Y) / area
+    w4 = 1 - w1 - w2 - w3
+    return LT, RT, LB, RB, w1, w2, w3, w4
+
+
+def _dividePrediction(pred, X, Y):
+    h, w = pred.size()[-2:]
+    pred = pred.view(h, w)
+    LT = pred[:Y, :X]
+    RT = pred[:Y, X:w]
+    LB = pred[Y:h, :X]
+    RB = pred[Y:h, X:w]
+    return LT, RT, LB, RB
+
+
+def _ssim(pred, gt):
+    gt = gt.float()
+    h, w = pred.size()[-2:]
+    N = h * w
+    x = pred.mean()
+    y = gt.mean()
+    sigma_x2 = ((pred - x) * (pred - x)).sum() / (N - 1 + 1e-20)
+    sigma_y2 = ((gt - y) * (gt - y)).sum() / (N - 1 + 1e-20)
+    sigma_xy = ((pred - x) * (gt - y)).sum() / (N - 1 + 1e-20)
+
+    aplha = 4 * x * y * sigma_xy
+    beta = (x * x + y * y) * (sigma_x2 + sigma_y2)
+
+    if aplha != 0:
+        Q = aplha / (beta + 1e-20)
+    elif aplha == 0 and beta == 0:
+        Q = 1.0
+    else:
+        Q = 0
+    return Q
+
+def _eval_e(y_pred, y, num):
+    score = torch.zeros(num)
+    thlist = torch.linspace(0, 1 - 1e-10, num)
+    for i in range(num):
+        y_pred_th = (y_pred >= thlist[i]).float()
+        fm = y_pred_th - y_pred_th.mean()
+        gt = y - y.mean()
+        align_matrix = 2 * gt * fm / (gt * gt + fm * fm + 1e-20)
+        enhanced = ((align_matrix + 1) * (align_matrix + 1)) / 4
+        score[i] = torch.sum(enhanced) / (y.numel() - 1 + 1e-20)
+    return score
+
+
+def calc_Semantic_Segmentation(y_pred,y_true):
+    batchsize = y_true.shape[0]
+    with torch.no_grad():
+        assert y_pred.shape == y_true.shape
+        f1, auc = 0, 0
+        y_true = y_true.cpu().numpy()
+        y_pred = y_pred.cpu().numpy()
+        for i in range(batchsize):
+            true = y_true[i].flatten()
+            true = true.astype(np.int)
+            pred = y_pred[i].flatten()
+
+            precision, recall, thresholds = precision_recall_curve(true, pred)
+
+            # auc
+            auc += roc_auc_score(true, pred)
+            # auc += roc_auc_score(np.array(true>0).astype(np.int), pred)
+            f1 += max([(2 * p * r) / (p + r+1e-10) for p, r in zip(precision, recall)])
+
+    return f1/batchsize, auc/batchsize, np.array(0), np.array(0)

visual_utils.py

@@ -0,0 +1,435 @@
+from torchvision.transforms.functional import normalize
+import torch.nn as nn
+import numpy as np
+
+
+def denormalize(tensor, mean, std):
+    mean = np.array(mean)
+    std = np.array(std)
+
+    _mean = -mean/std
+    _std = 1/std
+    return normalize(tensor, _mean, _std)
+
+
+class Denormalize(object):
+    def __init__(self, mean, std):
+        mean = np.array(mean)
+        std = np.array(std)
+        self._mean = -mean/std
+        self._std = 1/std
+
+    def __call__(self, tensor):
+        if isinstance(tensor, np.ndarray):
+            return (tensor - self._mean.reshape(-1,1,1)) / self._std.reshape(-1,1,1)
+        return normalize(tensor, self._mean, self._std)
+
+
+def fix_bn(model):
+    for m in model.modules():
+        if isinstance(m, nn.BatchNorm2d):
+            m.eval()
+            m.weight.requires_grad = False
+            m.bias.requires_grad = False
+
+
+def color_map(dataset):
+    if dataset=='voc':
+        return voc_cmap()
+    elif dataset=='cityscapes':
+        return cityscapes_cmap()
+    elif dataset=='ade':
+        return ade_cmap()
+    elif dataset =='isaid':
+        return isaid_cmap()
+    elif dataset =='SAR2020':
+        return SAR2020_cmap()
+    elif dataset =='Unify_single':
+        return unify_single_cmap()
+    elif dataset == 'Unify_double':
+        return unify_cmap()
+    elif dataset == 'Unify_YIJISAR':
+        return unify_YIJISAR_cmap()
+    elif dataset == 'Unify_Vai':
+        return unify_Vai_cmap()
+
+def unify_Vai_cmap():
+    cmap = np.zeros((255, 3), dtype=np.uint8)
+    colors = [
+        [0, 0, 0],#0
+        [0, 255, 0],
+        [0, 0, 255],
+        [0, 0, 255],
+        [0, 0, 0],
+        [159,129,183],
+        [0, 255, 255], #6
+        [255,195,128],
+        [0, 0, 0],
+        [255,255,0],
+        [0, 0, 0], #10
+        [0, 0, 0],
+        [0,0,0],#12
+        [0, 0, 0],
+        [255,0,0], #14
+
+    ]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+def cityscapes_cmap():
+    return np.array([(128, 64,128), (244, 35,232), ( 70, 70, 70), (102,102,156), (190,153,153), (153,153,153), (250,170, 30), 
+                         (220,220,  0), (107,142, 35), (152,251,152), ( 70,130,180), (220, 20, 60), (255,  0,  0), (  0,  0,142), 
+                         (  0,  0, 70), (  0, 60,100), (  0, 80,100), (  0,  0,230), (119, 11, 32), (  0,  0,  0)], 
+                         dtype=np.uint8)
+
+def SAR2020_cmap():
+    cmap = np.zeros((256, 3), dtype=np.uint8)
+    colors = [[255,255,255], [255,255,0], [0,0,255], [0, 255,0], [255,0,0], [0,255,255]]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+
+def isaid_cmap():
+    cmap = np.zeros((255, 3), dtype=np.uint8)
+    colors = [[0, 0, 0],
+              [0,63,0],
+              [0,63,191],
+              [0, 127, 63],
+              [0, 63, 255],
+              [0,100,155],
+              [0, 0, 191], [0, 127, 127],
+              [0, 127, 255], [0, 191, 127], [0, 0, 63], [0, 191, 127], [0, 127, 191],[0, 63, 63], [0 ,0 ,255], [0,63,127]]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+
+
+def unify_cmap():
+    cmap = np.zeros((255, 3), dtype=np.uint8)
+    colors = [
+    [0, 0, 0],
+    [0, 127, 255],
+    # [0, 0, 191],
+    [0, 63, 0],
+    [0, 127, 63],
+    [0, 63, 255],
+    [0, 127, 127],
+    # [0, 0, 127],
+    [0, 0, 63],
+    [0, 63, 127],
+    [0, 63, 191],
+    [0, 63, 63],
+    [0, 127, 191],
+    [0, 191, 127],
+    [0, 100, 155],
+    [0, 0, 255],
+        # [255, 255, 255], #0
+        #       [0,63,0],  #1
+        #       [0,127,63],#2
+        #       [0, 63, 255],#3
+        #       [0, 127, 127],#4
+        #       [0,128,0], #5,
+        #       [0, 0, 63],#6
+        #       [0,63,127],#7
+        #       [0, 63, 191],#8
+        #       [0, 63, 63],#9
+        #       [0, 127, 191], #10
+        #       [0, 191, 127],#11
+        #       [0,100,155], #12
+        #       [0, 0, 255], #13
+              [0,255,0], #14
+              [0,153,204], #15
+              [204,204,68], #16
+              [255, 204, 51], #17
+              [255, 255, 204], #18
+              [0, 255, 255],
+              [255,102,102], #20
+              [0,255,0] ,#21
+              [255,255,0],#22
+              [255,0,0],#23
+              [255,195,128],#24
+              [153,102,153]
+    ]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+def unify_YIJISAR_cmap():
+    cmap = np.zeros((255, 3), dtype=np.uint8)
+    colors = [
+    [255, 255, 0],#0
+    [0, 255, 0],
+    [0, 63, 0],
+    [0, 0, 255],
+    [0, 63, 255],
+    [255, 0, 0],
+    [0, 0, 63],
+    [0, 63, 127],
+    [0, 63, 191],
+    [0,255, 255],
+    [0, 127, 191],
+    [0, 191, 127],
+    [0,0,0],#12
+    [0, 0, 255],
+              [0,255,0], #14
+              [0,153,204], #15
+              [204,204,68], #16
+              [255, 204, 51], #17
+              [255, 255, 204], #18
+              [0, 255, 255],
+              [255,102,102], #20
+              [0,255,0] ,#21
+              [255,255,0],#22
+              [255,0,0],#23
+              [255,195,128],#24
+              [153,102,153]
+    ]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+
+def unify_single_cmap():
+    cmap = np.zeros((255, 3), dtype=np.uint8)
+    colors = [
+    [0, 127, 255],#0
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0], #3
+    [0, 0, 0], #4
+    [0,255,0], #5
+    [0, 0, 0],
+    [0, 0, 0],  # 7
+    [0, 0, 0],  # 8
+    [0, 0, 0],
+    [0, 0, 0],  # 10
+    [0, 0, 0],  # 11
+    [0, 0, 0],
+    [0, 0, 0],  # 13
+    [0, 0, 0],  # 14
+    [0, 0, 0], #15
+      [159,129,183], #16
+      [0, 0, 0], #17
+      [255, 195, 128], #18
+      [0, 0, 0],
+    [255, 0, 0],#20
+    [255,255,0],
+    [0,0,255], #22
+      [0, 0, 0],
+      [0, 0, 0],
+    [0,0,0]
+    ]
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+def ade_cmap():
+    cmap = np.zeros((256, 3), dtype=np.uint8)
+    colors = [
+        [0, 0, 0],
+        [120, 120, 120],
+        [180, 120, 120],
+        [6, 230, 230],
+        [80, 50, 50],
+        [4, 200, 3],
+        [120, 120, 80],
+        [140, 140, 140],
+        [204, 5, 255],
+        [230, 230, 230],
+        [4, 250, 7],
+        [224, 5, 255],
+        [235, 255, 7],
+        [150, 5, 61],
+        [120, 120, 70],
+        [8, 255, 51],
+        [255, 6, 82],
+        [143, 255, 140],
+        [204, 255, 4],
+        [255, 51, 7],
+        [204, 70, 3],
+        [0, 102, 200],
+        [61, 230, 250],
+        [255, 6, 51],
+        [11, 102, 255],
+        [255, 7, 71],
+        [255, 9, 224],
+        [9, 7, 230],
+        [220, 220, 220],
+        [255, 9, 92],
+        [112, 9, 255],
+        [8, 255, 214],
+        [7, 255, 224],
+        [255, 184, 6],
+        [10, 255, 71],
+        [255, 41, 10],
+        [7, 255, 255],
+        [224, 255, 8],
+        [102, 8, 255],
+        [255, 61, 6],
+        [255, 194, 7],
+        [255, 122, 8],
+        [0, 255, 20],
+        [255, 8, 41],
+        [255, 5, 153],
+        [6, 51, 255],
+        [235, 12, 255],
+        [160, 150, 20],
+        [0, 163, 255],
+        [140, 140, 140],
+        [250, 10, 15],
+        [20, 255, 0],
+        [31, 255, 0],
+        [255, 31, 0],
+        [255, 224, 0],
+        [153, 255, 0],
+        [0, 0, 255],
+        [255, 71, 0],
+        [0, 235, 255],
+        [0, 173, 255],
+        [31, 0, 255],
+        [11, 200, 200],
+        [255, 82, 0],
+        [0, 255, 245],
+        [0, 61, 255],
+        [0, 255, 112],
+        [0, 255, 133],
+        [255, 0, 0],
+        [255, 163, 0],
+        [255, 102, 0],
+        [194, 255, 0],
+        [0, 143, 255],
+        [51, 255, 0],
+        [0, 82, 255],
+        [0, 255, 41],
+        [0, 255, 173],
+        [10, 0, 255],
+        [173, 255, 0],
+        [0, 255, 153],
+        [255, 92, 0],
+        [255, 0, 255],
+        [255, 0, 245],
+        [255, 0, 102],
+        [255, 173, 0],
+        [255, 0, 20],
+        [255, 184, 184],
+        [0, 31, 255],
+        [0, 255, 61],
+        [0, 71, 255],
+        [255, 0, 204],
+        [0, 255, 194],
+        [0, 255, 82],
+        [0, 10, 255],
+        [0, 112, 255],
+        [51, 0, 255],
+        [0, 194, 255],
+        [0, 122, 255],
+        [0, 255, 163],
+        [255, 153, 0],
+        [0, 255, 10],
+        [255, 112, 0],
+        [143, 255, 0],
+        [82, 0, 255],
+        [163, 255, 0],
+        [255, 235, 0],
+        [8, 184, 170],
+        [133, 0, 255],
+        [0, 255, 92],
+        [184, 0, 255],
+        [255, 0, 31],
+        [0, 184, 255],
+        [0, 214, 255],
+        [255, 0, 112],
+        [92, 255, 0],
+        [0, 224, 255],
+        [112, 224, 255],
+        [70, 184, 160],
+        [163, 0, 255],
+        [153, 0, 255],
+        [71, 255, 0],
+        [255, 0, 163],
+        [255, 204, 0],
+        [255, 0, 143],
+        [0, 255, 235],
+        [133, 255, 0],
+        [255, 0, 235],
+        [245, 0, 255],
+        [255, 0, 122],
+        [255, 245, 0],
+        [10, 190, 212],
+        [214, 255, 0],
+        [0, 204, 255],
+        [20, 0, 255],
+        [255, 255, 0],
+        [0, 153, 255],
+        [0, 41, 255],
+        [0, 255, 204],
+        [41, 0, 255],
+        [41, 255, 0],
+        [173, 0, 255],
+        [0, 245, 255],
+        [71, 0, 255],
+        [122, 0, 255],
+        [0, 255, 184],
+        [0, 92, 255],
+        [184, 255, 0],
+        [0, 133, 255],
+        [255, 214, 0],
+        [25, 194, 194],
+        [102, 255, 0],
+        [92, 0, 255]
+    ]
+
+    for i in range(len(colors)):
+        cmap[i] = colors[i]
+
+    return cmap.astype(np.uint8)
+
+
+def voc_cmap(N=256, normalized=False):
+    def bitget(byteval, idx):
+        return ((byteval & (1 << idx)) != 0)
+
+    dtype = 'float32' if normalized else 'uint8'
+    cmap = np.zeros((N, 3), dtype=dtype)
+    for i in range(N):
+        r = g = b = 0
+        c = i
+        for j in range(8):
+            r = r | (bitget(c, 0) << 7-j)
+            g = g | (bitget(c, 1) << 7-j)
+            b = b | (bitget(c, 2) << 7-j)
+            c = c >> 3
+
+        cmap[i] = np.array([r, g, b])
+
+    cmap = cmap/255 if normalized else cmap
+    return cmap
+
+
+class Label2Color(object):
+    def __init__(self, cmap):
+        self.cmap = cmap
+
+    def __call__(self, lbls):
+        return self.cmap[lbls]
+
+
+def convert_bn2gn(module):
+    mod = module
+    if isinstance(module, nn.modules.batchnorm._BatchNorm):
+        num_features = module.num_features
+        num_groups = num_features//16
+        mod = nn.GroupNorm(num_groups=num_groups, num_channels=num_features)
+    for name, child in module.named_children():
+        mod.add_module(name, convert_bn2gn(child))
+    del module
+    return mod