first commit

Dcl/util/Asoftmax_loss.py

@@ -0,0 +1,47 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import torch.nn.functional as F
+from torch.nn import Parameter
+import math
+
+import pdb
+
+class AngleLoss(nn.Module):
+    def __init__(self, gamma=0):
+        super(AngleLoss, self).__init__()
+        self.gamma   = gamma
+        self.it = 0
+        self.LambdaMin = 50.0
+        self.LambdaMax = 1500.0
+        self.lamb = 1500.0
+
+    def forward(self, input, target, decay=None):
+        self.it += 1
+        cos_theta,phi_theta = input
+        target = target.view(-1,1) #size=(B,1)
+
+        index = cos_theta.data * 0.0 #size=(B,Classnum)
+        index.scatter_(1,target.data.view(-1,1),1)
+        index = index.byte()
+        index = Variable(index)
+
+        if decay is None:
+            self.lamb = max(self.LambdaMin,self.LambdaMax/(1+0.1*self.it ))
+        else:
+            self.LambdaMax *= decay 
+            self.lamb = max(self.LambdaMin, self.LambdaMax) 
+        output = cos_theta * 1.0 #size=(B,Classnum)
+        output[index] -= cos_theta[index]*(1.0+0)/(1+self.lamb)
+        output[index] += phi_theta[index]*(1.0+0)/(1+self.lamb)
+
+        logpt = F.log_softmax(output, 1)
+        logpt = logpt.gather(1,target)
+        logpt = logpt.view(-1)
+        pt = Variable(logpt.data.exp())
+
+        loss = -1 * (1-pt)**self.gamma * logpt
+        loss = loss.mean()
+
+        return loss
+

Dcl/util/autoaugment.py

@@ -0,0 +1,232 @@
+from PIL import Image, ImageEnhance, ImageOps
+import numpy as np
+import random
+
+
+class ImageNetPolicy(object):
+    """ Randomly choose one of the best 24 Sub-policies on ImageNet.
+        Example:
+        >>> policy = ImageNetPolicy()
+        >>> transformed = policy(image)
+        Example as a PyTorch Transform:
+        >>> transform=transforms.Compose([
+        >>>     transforms.Resize(256),
+        >>>     ImageNetPolicy(),
+        >>>     transforms.ToTensor()])
+    """
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.policies = [
+            SubPolicy(0.4, "posterize", 8, 0.6, "rotate", 9, fillcolor),
+            SubPolicy(0.6, "solarize", 5, 0.6, "autocontrast", 5, fillcolor),
+            SubPolicy(0.8, "equalize", 8, 0.6, "equalize", 3, fillcolor),
+            SubPolicy(0.6, "posterize", 7, 0.6, "posterize", 6, fillcolor),
+            SubPolicy(0.4, "equalize", 7, 0.2, "solarize", 4, fillcolor),
+
+            SubPolicy(0.4, "equalize", 4, 0.8, "rotate", 8, fillcolor),
+            SubPolicy(0.6, "solarize", 3, 0.6, "equalize", 7, fillcolor),
+            SubPolicy(0.8, "posterize", 5, 1.0, "equalize", 2, fillcolor),
+            SubPolicy(0.2, "rotate", 3, 0.6, "solarize", 8, fillcolor),
+            SubPolicy(0.6, "equalize", 8, 0.4, "posterize", 6, fillcolor),
+
+            SubPolicy(0.8, "rotate", 8, 0.4, "color", 0, fillcolor),
+            SubPolicy(0.4, "rotate", 9, 0.6, "equalize", 2, fillcolor),
+            SubPolicy(0.0, "equalize", 7, 0.8, "equalize", 8, fillcolor),
+            SubPolicy(0.6, "invert", 4, 1.0, "equalize", 8, fillcolor),
+            SubPolicy(0.6, "color", 4, 1.0, "contrast", 8, fillcolor),
+
+            SubPolicy(0.8, "rotate", 8, 1.0, "color", 2, fillcolor),
+            SubPolicy(0.8, "color", 8, 0.8, "solarize", 7, fillcolor),
+            SubPolicy(0.4, "sharpness", 7, 0.6, "invert", 8, fillcolor),
+            SubPolicy(0.6, "shearX", 5, 1.0, "equalize", 9, fillcolor),
+            SubPolicy(0.4, "color", 0, 0.6, "equalize", 3, fillcolor),
+
+            SubPolicy(0.4, "equalize", 7, 0.2, "solarize", 4, fillcolor),
+            SubPolicy(0.6, "solarize", 5, 0.6, "autocontrast", 5, fillcolor),
+            SubPolicy(0.6, "invert", 4, 1.0, "equalize", 8, fillcolor),
+            SubPolicy(0.6, "color", 4, 1.0, "contrast", 8, fillcolor),
+            SubPolicy(0.8, "equalize", 8, 0.6, "equalize", 3, fillcolor)
+        ]
+
+
+    def __call__(self, img):
+        policy_idx = random.randint(0, len(self.policies) - 1)
+        return self.policies[policy_idx](img)
+
+    def __repr__(self):
+        return "AutoAugment ImageNet Policy"
+
+
+class CIFAR10Policy(object):
+    """ Randomly choose one of the best 25 Sub-policies on CIFAR10.
+        Example:
+        >>> policy = CIFAR10Policy()
+        >>> transformed = policy(image)
+        Example as a PyTorch Transform:
+        >>> transform=transforms.Compose([
+        >>>     transforms.Resize(256),
+        >>>     CIFAR10Policy(),
+        >>>     transforms.ToTensor()])
+    """
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.policies = [
+            SubPolicy(0.1, "invert", 7, 0.2, "contrast", 6, fillcolor),
+            SubPolicy(0.7, "rotate", 2, 0.3, "translateX", 9, fillcolor),
+            SubPolicy(0.8, "sharpness", 1, 0.9, "sharpness", 3, fillcolor),
+            SubPolicy(0.5, "shearY", 8, 0.7, "translateY", 9, fillcolor),
+            SubPolicy(0.5, "autocontrast", 8, 0.9, "equalize", 2, fillcolor),
+
+            SubPolicy(0.2, "shearY", 7, 0.3, "posterize", 7, fillcolor),
+            SubPolicy(0.4, "color", 3, 0.6, "brightness", 7, fillcolor),
+            SubPolicy(0.3, "sharpness", 9, 0.7, "brightness", 9, fillcolor),
+            SubPolicy(0.6, "equalize", 5, 0.5, "equalize", 1, fillcolor),
+            SubPolicy(0.6, "contrast", 7, 0.6, "sharpness", 5, fillcolor),
+
+            SubPolicy(0.7, "color", 7, 0.5, "translateX", 8, fillcolor),
+            SubPolicy(0.3, "equalize", 7, 0.4, "autocontrast", 8, fillcolor),
+            SubPolicy(0.4, "translateY", 3, 0.2, "sharpness", 6, fillcolor),
+            SubPolicy(0.9, "brightness", 6, 0.2, "color", 8, fillcolor),
+            SubPolicy(0.5, "solarize", 2, 0.0, "invert", 3, fillcolor),
+
+            SubPolicy(0.2, "equalize", 0, 0.6, "autocontrast", 0, fillcolor),
+            SubPolicy(0.2, "equalize", 8, 0.8, "equalize", 4, fillcolor),
+            SubPolicy(0.9, "color", 9, 0.6, "equalize", 6, fillcolor),
+            SubPolicy(0.8, "autocontrast", 4, 0.2, "solarize", 8, fillcolor),
+            SubPolicy(0.1, "brightness", 3, 0.7, "color", 0, fillcolor),
+
+            SubPolicy(0.4, "solarize", 5, 0.9, "autocontrast", 3, fillcolor),
+            SubPolicy(0.9, "translateY", 9, 0.7, "translateY", 9, fillcolor),
+            SubPolicy(0.9, "autocontrast", 2, 0.8, "solarize", 3, fillcolor),
+            SubPolicy(0.8, "equalize", 8, 0.1, "invert", 3, fillcolor),
+            SubPolicy(0.7, "translateY", 9, 0.9, "autocontrast", 1, fillcolor)
+        ]
+
+
+    def __call__(self, img):
+        policy_idx = random.randint(0, len(self.policies) - 1)
+        return self.policies[policy_idx](img)
+
+    def __repr__(self):
+        return "AutoAugment CIFAR10 Policy"
+
+
+class SVHNPolicy(object):
+    """ Randomly choose one of the best 25 Sub-policies on SVHN.
+        Example:
+        >>> policy = SVHNPolicy()
+        >>> transformed = policy(image)
+        Example as a PyTorch Transform:
+        >>> transform=transforms.Compose([
+        >>>     transforms.Resize(256),
+        >>>     SVHNPolicy(),
+        >>>     transforms.ToTensor()])
+    """
+    def __init__(self, fillcolor=(128, 128, 128)):
+        self.policies = [
+            SubPolicy(0.9, "shearX", 4, 0.2, "invert", 3, fillcolor),
+            SubPolicy(0.9, "shearY", 8, 0.7, "invert", 5, fillcolor),
+            SubPolicy(0.6, "equalize", 5, 0.6, "solarize", 6, fillcolor),
+            SubPolicy(0.9, "invert", 3, 0.6, "equalize", 3, fillcolor),
+            SubPolicy(0.6, "equalize", 1, 0.9, "rotate", 3, fillcolor),
+
+            SubPolicy(0.9, "shearX", 4, 0.8, "autocontrast", 3, fillcolor),
+            SubPolicy(0.9, "shearY", 8, 0.4, "invert", 5, fillcolor),
+            SubPolicy(0.9, "shearY", 5, 0.2, "solarize", 6, fillcolor),
+            SubPolicy(0.9, "invert", 6, 0.8, "autocontrast", 1, fillcolor),
+            SubPolicy(0.6, "equalize", 3, 0.9, "rotate", 3, fillcolor),
+
+            SubPolicy(0.9, "shearX", 4, 0.3, "solarize", 3, fillcolor),
+            SubPolicy(0.8, "shearY", 8, 0.7, "invert", 4, fillcolor),
+            SubPolicy(0.9, "equalize", 5, 0.6, "translateY", 6, fillcolor),
+            SubPolicy(0.9, "invert", 4, 0.6, "equalize", 7, fillcolor),
+            SubPolicy(0.3, "contrast", 3, 0.8, "rotate", 4, fillcolor),
+
+            SubPolicy(0.8, "invert", 5, 0.0, "translateY", 2, fillcolor),
+            SubPolicy(0.7, "shearY", 6, 0.4, "solarize", 8, fillcolor),
+            SubPolicy(0.6, "invert", 4, 0.8, "rotate", 4, fillcolor),
+            SubPolicy(0.3, "shearY", 7, 0.9, "translateX", 3, fillcolor),
+            SubPolicy(0.1, "shearX", 6, 0.6, "invert", 5, fillcolor),
+
+            SubPolicy(0.7, "solarize", 2, 0.6, "translateY", 7, fillcolor),
+            SubPolicy(0.8, "shearY", 4, 0.8, "invert", 8, fillcolor),
+            SubPolicy(0.7, "shearX", 9, 0.8, "translateY", 3, fillcolor),
+            SubPolicy(0.8, "shearY", 5, 0.7, "autocontrast", 3, fillcolor),
+            SubPolicy(0.7, "shearX", 2, 0.1, "invert", 5, fillcolor)
+        ]
+
+
+    def __call__(self, img):
+        policy_idx = random.randint(0, len(self.policies) - 1)
+        return self.policies[policy_idx](img)
+
+    def __repr__(self):
+        return "AutoAugment SVHN Policy"
+
+
+class SubPolicy(object):
+    def __init__(self, p1, operation1, magnitude_idx1, p2, operation2, magnitude_idx2, fillcolor=(128, 128, 128)):
+        ranges = {
+            "shearX": np.linspace(0, 0.3, 10),
+            "shearY": np.linspace(0, 0.3, 10),
+            "translateX": np.linspace(0, 150 / 331, 10),
+            "translateY": np.linspace(0, 150 / 331, 10),
+            "rotate": np.linspace(0, 30, 10),
+            "color": np.linspace(0.0, 0.9, 10),
+            "posterize": np.round(np.linspace(8, 4, 10), 0).astype(np.int),
+            "solarize": np.linspace(256, 0, 10),
+            "contrast": np.linspace(0.0, 0.9, 10),
+            "sharpness": np.linspace(0.0, 0.9, 10),
+            "brightness": np.linspace(0.0, 0.9, 10),
+            "autocontrast": [0] * 10,
+            "equalize": [0] * 10,
+            "invert": [0] * 10
+        }
+
+        # from https://stackoverflow.com/questions/5252170/specify-image-filling-color-when-rotating-in-python-with-pil-and-setting-expand
+        def rotate_with_fill(img, magnitude):
+            rot = img.convert("RGBA").rotate(magnitude)
+            return Image.composite(rot, Image.new("RGBA", rot.size, (128,) * 4), rot).convert(img.mode)
+
+        func = {
+            "shearX": lambda img, magnitude: img.transform(
+                img.size, Image.AFFINE, (1, magnitude * random.choice([-1, 1]), 0, 0, 1, 0),
+                Image.BICUBIC, fillcolor=fillcolor),
+            "shearY": lambda img, magnitude: img.transform(
+                img.size, Image.AFFINE, (1, 0, 0, magnitude * random.choice([-1, 1]), 1, 0),
+                Image.BICUBIC, fillcolor=fillcolor),
+            "translateX": lambda img, magnitude: img.transform(
+                img.size, Image.AFFINE, (1, 0, magnitude * img.size[0] * random.choice([-1, 1]), 0, 1, 0),
+                fillcolor=fillcolor),
+            "translateY": lambda img, magnitude: img.transform(
+                img.size, Image.AFFINE, (1, 0, 0, 0, 1, magnitude * img.size[1] * random.choice([-1, 1])),
+                fillcolor=fillcolor),
+            "rotate": lambda img, magnitude: rotate_with_fill(img, magnitude),
+            # "rotate": lambda img, magnitude: img.rotate(magnitude * random.choice([-1, 1])),
+            "color": lambda img, magnitude: ImageEnhance.Color(img).enhance(1 + magnitude * random.choice([-1, 1])),
+            "posterize": lambda img, magnitude: ImageOps.posterize(img, magnitude),
+            "solarize": lambda img, magnitude: ImageOps.solarize(img, magnitude),
+            "contrast": lambda img, magnitude: ImageEnhance.Contrast(img).enhance(
+                1 + magnitude * random.choice([-1, 1])),
+            "sharpness": lambda img, magnitude: ImageEnhance.Sharpness(img).enhance(
+                1 + magnitude * random.choice([-1, 1])),
+            "brightness": lambda img, magnitude: ImageEnhance.Brightness(img).enhance(
+                1 + magnitude * random.choice([-1, 1])),
+            "autocontrast": lambda img, magnitude: ImageOps.autocontrast(img),
+            "equalize": lambda img, magnitude: ImageOps.equalize(img),
+            "invert": lambda img, magnitude: ImageOps.invert(img)
+        }
+
+        # self.name = "{}_{:.2f}_and_{}_{:.2f}".format(
+        #     operation1, ranges[operation1][magnitude_idx1],
+        #     operation2, ranges[operation2][magnitude_idx2])
+        self.p1 = p1
+        self.operation1 = func[operation1]
+        self.magnitude1 = ranges[operation1][magnitude_idx1]
+        self.p2 = p2
+        self.operation2 = func[operation2]
+        self.magnitude2 = ranges[operation2][magnitude_idx2]
+
+
+    def __call__(self, img):
+        if random.random() < self.p1: img = self.operation1(img, self.magnitude1)
+        if random.random() < self.p2: img = self.operation2(img, self.magnitude2)
+        return img

Dcl/util/dataset_DCL.py

@@ -0,0 +1,183 @@
+# coding=utf8
+from __future__ import division
+import os
+import torch
+import torch.utils.data as data
+import pandas
+import random
+import PIL.Image as Image
+from PIL import ImageStat
+
+import pdb
+
+def random_sample(img_names, labels):
+    anno_dict = {}
+    img_list = []
+    anno_list = []
+    for img, anno in zip(img_names, labels):
+        if not anno in anno_dict:
+            anno_dict[anno] = [img]
+        else:
+            anno_dict[anno].append(img)
+
+    for anno in anno_dict.keys():
+        anno_len = len(anno_dict[anno])
+        fetch_keys = random.sample(list(range(anno_len)), anno_len//10)
+        img_list.extend([anno_dict[anno][x] for x in fetch_keys])
+        anno_list.extend([anno for x in fetch_keys])
+    return img_list, anno_list
+
+
+
+class dataset(data.Dataset):
+    def __init__(self, Config, anno, swap_size=[7,7], common_aug=None, swap=None, totensor=None, train=False, train_val=False, test=False):
+        self.root_path = Config.rawdata_root
+        self.numcls = Config.numcls
+        self.dataset = Config.dataset
+        self.use_cls_2 = Config.cls_2
+        self.use_cls_mul = Config.cls_2xmul
+        if isinstance(anno, pandas.core.frame.DataFrame): # 判断类型
+            self.paths = anno['ImageName'].tolist()
+            self.labels = anno['label'].tolist()
+        elif isinstance(anno, dict):
+            self.paths = anno['img_name']
+            self.labels = anno['label']
+
+        if train_val:
+            self.paths, self.labels = random_sample(self.paths, self.labels)
+        self.common_aug = common_aug
+        self.swap = swap
+        self.totensor = totensor
+        self.cfg = Config
+        self.train = train
+        self.swap_size = swap_size
+        self.test = test
+
+    def __len__(self):
+        return len(self.paths)
+
+    def __getitem__(self, item):
+        img_path = os.path.join(self.root_path, self.paths[item])
+        img = self.pil_loader(img_path)
+        if self.test:
+            img = self.totensor(img)
+            label = self.labels[item]
+            return img, label, self.paths[item]
+        img_unswap = self.common_aug(img) if not self.common_aug is None else img # 原图数据
+
+        image_unswap_list = self.crop_image(img_unswap, self.swap_size)
+
+        swap_range = self.swap_size[0] * self.swap_size[1]
+        swap_law1 = [(i-(swap_range//2))/swap_range for i in range(swap_range)]
+        # 在训练的时候 self.train是true
+        if self.train:
+            img_swap = self.swap(img_unswap) # RCM机制处理后的照片
+            image_swap_list = self.crop_image(img_swap, self.swap_size)
+            unswap_stats = [sum(ImageStat.Stat(im).mean) for im in image_unswap_list]
+            swap_stats = [sum(ImageStat.Stat(im).mean) for im in image_swap_list]
+            swap_law2 = []
+            for swap_im in swap_stats:
+                distance = [abs(swap_im - unswap_im) for unswap_im in unswap_stats]
+                index = distance.index(min(distance))
+                swap_law2.append((index-(swap_range//2))/swap_range)
+            img_swap = self.totensor(img_swap)
+            label = self.labels[item]
+            if self.use_cls_mul:
+                label_swap = label + self.numcls
+            if self.use_cls_2:
+                label_swap = -1
+            img_unswap = self.totensor(img_unswap)
+            return img_unswap, img_swap, label, label_swap, swap_law1, swap_law2, self.paths[item]
+        else:
+            label = self.labels[item]
+            swap_law2 = [(i-(swap_range//2))/swap_range for i in range(swap_range)]
+            label_swap = label
+            img_unswap = self.totensor(img_unswap)
+            return img_unswap, label, label_swap, swap_law1, swap_law2, self.paths[item]
+#inputs, labels, labels_swap, swap_law, img_names
+    def pil_loader(self,imgpath):
+        with open(imgpath, 'rb') as f:
+            with Image.open(f) as img:
+                return img.convert('RGB')
+
+    def crop_image(self, image, cropnum):
+        width, high = image.size
+        crop_x = [int((width / cropnum[0]) * i) for i in range(cropnum[0] + 1)]
+        crop_y = [int((high / cropnum[1]) * i) for i in range(cropnum[1] + 1)]
+        im_list = []
+        for j in range(len(crop_y) - 1):
+            for i in range(len(crop_x) - 1):
+                im_list.append(image.crop((crop_x[i], crop_y[j], min(crop_x[i + 1], width), min(crop_y[j + 1], high))))
+        return im_list
+
+
+    def get_weighted_sampler(self):
+        img_nums = len(self.labels)
+        weights = [self.labels.count(x) for x in range(self.numcls)]
+        return torch.utils.data.sampler.WeightedRandomSampler(weights, num_samples=img_nums)
+
+
+def collate_fn4train(batch):
+    imgs = []
+    label = []
+    label_swap = []
+    law_swap = []
+    img_name = []
+    for sample in batch:
+        imgs.append(sample[0]) # 原始图片
+        imgs.append(sample[1]) # RCM混淆机制打乱后的图片
+        label.append(sample[2])# 类别标签
+        label.append(sample[2])
+        # 给每张图片贴上标签以区分是否被破坏过
+        if sample[3] == -1:
+            label_swap.append(1)
+            label_swap.append(0)
+        else:
+            label_swap.append(sample[2])
+            label_swap.append(sample[3])
+        law_swap.append(sample[4]) # 未打乱时每个小块的位置
+        law_swap.append(sample[5]) # 打乱后每个小块的的位置
+        img_name.append(sample[-1])# 图片名字
+
+    return torch.stack(imgs, 0), label, label_swap, law_swap, img_name # 张量0维度扩展
+
+def collate_fn4val(batch):
+    imgs = []
+    label = []
+    label_swap = []
+    law_swap = []
+    img_name = []
+    for sample in batch:
+        imgs.append(sample[0])
+        label.append(sample[1])
+        if sample[3] == -1:
+            label_swap.append(1)
+        else:
+            label_swap.append(sample[2])
+        law_swap.append(sample[3])
+        img_name.append(sample[-1])
+    return torch.stack(imgs, 0), label, label_swap, law_swap, img_name
+
+def collate_fn4backbone(batch):
+    imgs = []
+    label = []
+    img_name = []
+    for sample in batch:
+        imgs.append(sample[0])
+        if len(sample) == 7:
+            label.append(sample[2])
+        else:
+            label.append(sample[1])
+        img_name.append(sample[-1])
+    return torch.stack(imgs, 0), label, img_name
+
+
+def collate_fn4test(batch):
+    imgs = []
+    label = []
+    img_name = []
+    for sample in batch:
+        imgs.append(sample[0])
+        label.append(sample[1])
+        img_name.append(sample[-1])
+    return torch.stack(imgs, 0), label, img_name

Dcl/util/eval_model.py

@@ -0,0 +1,81 @@
+#coding=utf8
+from __future__ import print_function, division
+import os,time,datetime
+import numpy as np
+import datetime
+from math import ceil
+
+import torch
+from torch import nn
+from torch.autograd import Variable
+import torch.nn.functional as F
+
+from util.utils import LossRecord
+
+import pdb
+
+def dt():
+    return datetime.datetime.now().strftime("%Y-%m-%d-%H_%M_%S")
+
+def eval_turn(Config, model, data_loader, val_version, epoch_num, log_file):
+
+    model.train(False)
+
+    val_corrects1 = 0
+    val_corrects2 = 0
+    val_corrects3 = 0
+    val_size = data_loader.__len__()
+    item_count = data_loader.total_item_len
+    t0 = time.time()
+    get_l1_loss = nn.L1Loss()
+    get_ce_loss = nn.CrossEntropyLoss()
+
+    val_batch_size = data_loader.batch_size
+    val_epoch_step = data_loader.__len__()
+    num_cls = data_loader.num_cls
+
+    val_loss_recorder = LossRecord(val_batch_size)
+    val_celoss_recorder = LossRecord(val_batch_size)
+    print('evaluating %s ...'%val_version, flush=True)
+    with torch.no_grad():
+        for batch_cnt_val, data_val in enumerate(data_loader):
+            inputs = Variable(data_val[0].cuda())
+            labels = Variable(torch.from_numpy(np.array(data_val[1])).long().cuda())
+            outputs = model(inputs)
+            loss = 0
+            # 前向预测的时候只做分类
+            ce_loss = get_ce_loss(outputs[0], labels).item() # 获取tensor的值不包括类型
+            loss += ce_loss
+
+            val_loss_recorder.update(loss)
+            val_celoss_recorder.update(ce_loss)
+
+            if Config.use_dcl and Config.cls_2xmul:
+                outputs_pred = outputs[0] + outputs[1][:,0:num_cls] + outputs[1][:,num_cls:2*num_cls]
+            else:
+                outputs_pred = outputs[0]
+            top3_val, top3_pos = torch.topk(outputs_pred, 3) # 获取某一维度上 的前k个最大值（张量 k的值）
+
+            print('{:s} eval_batch: {:-6d} / {:d} loss: {:8.4f}'.format(val_version, batch_cnt_val, val_epoch_step, loss), flush=True)
+
+            batch_corrects1 = torch.sum((top3_pos[:, 0] == labels)).data.item() # .data返回的是tensor
+            val_corrects1 += batch_corrects1
+            batch_corrects2 = torch.sum((top3_pos[:, 1] == labels)).data.item()
+            val_corrects2 += (batch_corrects2 + batch_corrects1)
+            batch_corrects3 = torch.sum((top3_pos[:, 2] == labels)).data.item()
+            val_corrects3 += (batch_corrects3 + batch_corrects2 + batch_corrects1)
+
+        val_acc1 = val_corrects1 / item_count
+        val_acc2 = val_corrects2 / item_count
+        val_acc3 = val_corrects3 / item_count
+
+        log_file.write(val_version  + '\t' +str(val_loss_recorder.get_val())+'\t' + str(val_celoss_recorder.get_val()) + '\t' + str(val_acc1) + '\t' + str(val_acc3) + '\n')
+
+        t1 = time.time()
+        since = t1-t0
+        print('--'*30, flush=True)
+        print('% 3d %s %s %s-loss: %.4f ||%s-acc@1: %.4f %s-acc@2: %.4f %s-acc@3: %.4f ||time: %d' % (epoch_num, val_version, dt(), val_version, val_loss_recorder.get_val(init=True), val_version, val_acc1,val_version, val_acc2, val_version, val_acc3, since), flush=True)
+        print('--' * 30, flush=True)
+
+    return val_acc1, val_acc2, val_acc3
+

Dcl/util/test_tool.py

@@ -0,0 +1,99 @@
+import os
+import math
+import numpy as np
+import cv2
+import datetime
+
+import torch
+from torchvision.utils import save_image, make_grid
+
+import pdb
+
+def dt():
+    return datetime.datetime.now().strftime("%Y-%m-%d-%H_%M_%S")
+
+def set_text(text, img):
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    if isinstance(text, str):
+        cont = text
+        cv2.putText(img, cont, (20, 50), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+    if isinstance(text, float):
+        cont = '%.4f'%text
+        cv2.putText(img, cont, (20, 50), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+    if isinstance(text, list):
+        for count in range(len(img)):
+            cv2.putText(img[count], text[count], (20, 50), font, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+    return img
+
+def save_multi_img(img_list, text_list, grid_size=[5,5], sub_size=200, save_dir='./', save_name=None):
+    if len(img_list) > grid_size[0]*grid_size[1]:
+        merge_height = math.ceil(len(img_list) / grid_size[0]) * sub_size
+    else:
+        merge_height = grid_size[1]*sub_size
+    merged_img = np.zeros((merge_height, grid_size[0]*sub_size, 3))
+
+    if isinstance(img_list[0], str):
+        img_name_list = img_list
+        img_list = []
+        for img_name in img_name_list:
+            img_list.append(cv2.imread(img_name))
+
+    img_counter = 0
+    for img, txt in zip(img_list, text_list):
+        img = cv2.resize(img, (sub_size, sub_size))
+        img = set_text(txt, img)
+        pos = [img_counter // grid_size[1], img_counter % grid_size[1]]
+        sub_pos = [pos[0]*sub_size, (pos[0]+1)*sub_size,
+                   pos[1]*sub_size, (pos[1]+1)*sub_size]
+        merged_img[sub_pos[0]:sub_pos[1], sub_pos[2]:sub_pos[3], :] = img
+        img_counter += 1
+
+    if save_name is None:
+        img_save_path = os.path.join(save_dir, dt()+'.png')
+    else:
+        img_save_path = os.path.join(save_dir, save_name+'.png')
+    cv2.imwrite(img_save_path,  merged_img)
+    print('saved img in %s ...'%img_save_path)
+
+
+def cls_base_acc(result_gather):
+    top1_acc = {}
+    top3_acc = {}
+    cls_count = {}
+    for img_item in result_gather.keys():
+        acc_case = result_gather[img_item]
+
+        if acc_case['label'] in cls_count:
+            cls_count[acc_case['label']] += 1
+            if acc_case['top1_cat'] == acc_case['label']:
+                top1_acc[acc_case['label']] += 1
+            if acc_case['label'] in [acc_case['top1_cat'], acc_case['top2_cat'], acc_case['top3_cat']]:
+                top3_acc[acc_case['label']] += 1
+        else:
+            cls_count[acc_case['label']] = 1
+            if acc_case['top1_cat'] == acc_case['label']:
+                top1_acc[acc_case['label']] = 1
+            else:
+                top1_acc[acc_case['label']] = 0
+
+            if acc_case['label'] in [acc_case['top1_cat'], acc_case['top2_cat'], acc_case['top3_cat']]:
+                top3_acc[acc_case['label']] = 1
+            else:
+                top3_acc[acc_case['label']] = 0
+
+    for label_item in cls_count:
+        top1_acc[label_item] /= max(1.0*cls_count[label_item], 0.001)
+        top3_acc[label_item] /= max(1.0*cls_count[label_item], 0.001)
+
+    print('top1_acc:', top1_acc)
+    print('top3_acc:', top3_acc)
+    print('cls_count', cls_count)
+
+    return top1_acc, top3_acc, cls_count
+
+
+
+
+
+
+

Dcl/util/train_model.py

@@ -0,0 +1,164 @@
+#coding=utf8
+from __future__ import print_function, division
+
+import os,time,datetime
+import numpy as np
+from math import ceil
+import datetime
+
+import torch
+from torch import nn
+from torch.autograd import Variable
+#from torchvision.utils import make_grid, save_image
+
+from util.utils import LossRecord, clip_gradient
+from models.focal_loss import FocalLoss
+from util.eval_model import eval_turn
+from util.Asoftmax_loss import AngleLoss
+
+import pdb
+
+def dt():
+    return datetime.datetime.now().strftime("%Y-%m-%d-%H_%M_%S")
+
+
+def train(Config,
+          model,
+          epoch_num,
+          start_epoch,
+          optimizer,
+          exp_lr_scheduler,
+          data_loader,
+          save_dir,
+          data_size=448,
+          savepoint=500,
+          checkpoint=1000
+          ):
+    # savepoint: save without evalution
+    # checkpoint: save with evaluation
+    # print(epoch_num, start_epoch) # 360  0
+    step = 0
+    eval_train_flag = False
+    rec_loss = []
+    checkpoint_list = []
+
+    train_batch_size = data_loader['train'].batch_size
+    train_epoch_step = data_loader['train'].__len__()
+    train_loss_recorder = LossRecord(train_batch_size)
+    if savepoint > train_epoch_step:
+        savepoint = 1*train_epoch_step
+        checkpoint = savepoint
+
+    date_suffix = dt()
+    log_file = open(os.path.join(Config.log_folder, 'formal_log_r50_dcl_%s_%s.log'%(str(data_size), date_suffix)), 'a')
+
+    add_loss = nn.L1Loss()
+    get_ce_loss = nn.CrossEntropyLoss()
+    get_focal_loss = FocalLoss()
+    get_angle_loss = AngleLoss()
+
+    for epoch in range(start_epoch,epoch_num-1):
+        exp_lr_scheduler.step(epoch)
+        model.train(True)
+
+        save_grad = []
+        step = 0
+        for batch_cnt, data in enumerate(data_loader['train']):
+            step += 1
+            loss = 0
+            model.train(True)
+            if Config.use_backbone:
+                inputs, labels, img_names = data
+
+                inputs = Variable(inputs.cuda())
+                labels = Variable(torch.from_numpy(np.array(labels)).cuda())
+
+            if Config.use_dcl:
+                inputs, labels, labels_swap, swap_law, img_names = data
+                inputs = Variable(inputs.cuda())
+                labels = Variable(torch.from_numpy(np.array(labels)).long().cuda())
+                labels_swap = Variable(torch.from_numpy(np.array(labels_swap)).long().cuda())
+                swap_law = Variable(torch.from_numpy(np.array(swap_law)).float().cuda())
+            optimizer.zero_grad()
+            # print(inputs.size())
+            if inputs.size(0) < 2*train_batch_size:
+                outputs = model(inputs, inputs[0:-1:2])
+            else:
+                outputs = model(inputs, None)
+            if Config.use_focal_loss:
+                ce_loss = get_focal_loss(outputs[0], labels)
+            else:
+                ce_loss = get_ce_loss(outputs[0], labels) #交叉熵损失函数 用来分类
+
+            # if Config.use_Asoftmax:
+            #     fetch_batch = labels.size(0)
+            #     if batch_cnt % (train_epoch_step // 5) == 0:
+            #         angle_loss = get_angle_loss(outputs[3], labels[0:fetch_batch:2], decay=0.9)
+            #     else:
+            #         angle_loss = get_angle_loss(outputs[3], labels[0:fetch_batch:2])
+            #     loss += angle_loss
+
+            loss += ce_loss
+            alpha_ = 1
+            beta_ = 1
+            gamma_ = 0.01 if Config.dataset == 'STCAR' or Config.dataset == 'AIR' else 1
+            if Config.use_dcl:
+                swap_loss = get_ce_loss(outputs[1], labels_swap) * beta_ # 对抗学习
+                loss += swap_loss
+                law_loss = add_loss(outputs[2], swap_law) * gamma_ # 重建学习损失
+                loss += law_loss
+
+            loss.backward()
+            torch.cuda.synchronize() #统计时间
+
+            optimizer.step()
+            torch.cuda.synchronize()
+
+            if Config.use_dcl:
+                # 8d不足就右对齐 加上-左对齐
+                print('epoch: {} step: {:-8d} / {:d} loss=ce_loss+swap_loss+law_loss: {:6.4f} = {:6.4f} + {:6.4f} + {:6.4f} '.format(epoch, step, train_epoch_step, loss.detach().item(), ce_loss.detach().item(), swap_loss.detach().item(), law_loss.detach().item()), flush=True)
+                # print(savepoint)
+            if Config.use_backbone:
+                print('step: {:-8d} / {:d} loss=ce_loss+swap_loss+law_loss: {:6.4f} = {:6.4f} '.format(step, train_epoch_step, loss.detach().item(), ce_loss.detach().item()), flush=True)
+            rec_loss.append(loss.detach().item())# 对loss进行叠加的时候一定要加detach，返回的是叶子节点，不然会进行计算图的叠加，
+
+            train_loss_recorder.update(loss.detach().item())
+            # evaluation & save
+            # checkpoint = 5000
+            if step % checkpoint == 0:
+                rec_loss = []
+                print(32*'-', flush=True)
+                print('step: {:d} / {:d} global_step: {:8.2f} train_epoch: {:04d} rec_train_loss: {:6.4f}'.format(step, train_epoch_step, 1.0*step/train_epoch_step, epoch, train_loss_recorder.get_val()), flush=True)
+                print('current lr:%s' % exp_lr_scheduler.get_lr(), flush=True)
+                if eval_train_flag:
+                    trainval_acc1, trainval_acc2, trainval_acc3 = eval_turn(Config, model, data_loader['trainval'], 'trainval', epoch, log_file)
+                    if abs(trainval_acc1 - trainval_acc3) < 0.01:
+                        eval_train_flag = False
+
+                val_acc1, val_acc2, val_acc3 = eval_turn(Config, model, data_loader['val'], 'val', epoch, log_file)
+
+                save_path = os.path.join(save_dir, 'weights_%d_%d_%.4f_%.4f.pth'%(epoch, batch_cnt, val_acc1, val_acc3))
+                torch.cuda.synchronize()
+                torch.save(model.state_dict(), save_path)
+                print('saved model to %s' % (save_path), flush=True)
+                torch.cuda.empty_cache()
+
+            # save only
+            # elif step % savepoint == 0:
+            #     print('step')
+            #     train_loss_recorder.update(rec_loss)
+            #     rec_loss = []
+            #     save_path = os.path.join(save_dir, 'savepoint_weights-%d-%s.pth'%(step, dt()))
+            #
+            #     checkpoint_list.append(save_path)
+            #     if len(checkpoint_list) == 6:
+            #         os.remove(checkpoint_list[0])
+            #         del checkpoint_list[0]
+            #     torch.save(model.state_dict(), save_path)
+            #     torch.cuda.empty_cache()
+
+
+    log_file.close()
+
+
+

Dcl/util/utils.py

@@ -0,0 +1,124 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+import pdb
+
+
+class LossRecord(object):
+    def __init__(self, batch_size):
+        self.rec_loss = 0
+        self.count = 0
+        self.batch_size = batch_size
+
+    def update(self, loss):
+        if isinstance(loss, list):
+            avg_loss = sum(loss)
+            avg_loss /= (len(loss)*self.batch_size)
+            self.rec_loss += avg_loss
+            self.count += 1
+        if isinstance(loss, float):
+            self.rec_loss += loss/self.batch_size
+            self.count += 1
+
+    def get_val(self, init=False):
+        pop_loss = self.rec_loss / self.count
+        if init:
+            self.rec_loss = 0
+            self.count = 0
+        return pop_loss
+
+
+def weights_normal_init(model, dev=0.01):
+    if isinstance(model, list):
+        for m in model:
+            weights_normal_init(m, dev)
+    else:
+        for m in model.modules():
+            if isinstance(m, nn.Conv2d):
+                m.weight.data.normal_(0.0, dev)
+            elif isinstance(m, nn.Linear):
+                m.weight.data.normal_(0.0, dev)
+
+
+def clip_gradient(model, clip_norm):
+    """Computes a gradient clipping coefficient based on gradient norm."""
+    totalnorm = 0
+    for p in model.parameters():
+        if p.requires_grad:
+            modulenorm = p.grad.data.norm()
+            totalnorm += modulenorm ** 2
+    totalnorm = torch.sqrt(totalnorm).item()
+    norm = (clip_norm / max(totalnorm, clip_norm))
+    for p in model.parameters():
+        if p.requires_grad:
+            p.grad.mul_(norm)
+
+
+def Linear(in_features, out_features, bias=True):
+    """Weight-normalized Linear layer (input: N x T x C)"""
+    m = nn.Linear(in_features, out_features, bias=bias)
+    m.weight.data.uniform_(-0.1, 0.1)
+    if bias:
+        m.bias.data.uniform_(-0.1, 0.1)
+    return m
+
+
+class convolution(nn.Module):
+    def __init__(self, k, inp_dim, out_dim, stride=1, with_bn=True):
+        super(convolution, self).__init__()
+
+        pad = (k - 1) // 2
+        self.conv = nn.Conv2d(inp_dim, out_dim, (k, k), padding=(pad, pad), stride=(stride, stride), bias=not with_bn)
+        self.bn   = nn.BatchNorm2d(out_dim) if with_bn else nn.Sequential()
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        conv = self.conv(x)
+        bn   = self.bn(conv)
+        relu = self.relu(bn)
+        return relu
+
+class fully_connected(nn.Module):
+    def __init__(self, inp_dim, out_dim, with_bn=True):
+        super(fully_connected, self).__init__()
+        self.with_bn = with_bn
+
+        self.linear = nn.Linear(inp_dim, out_dim)
+        if self.with_bn:
+            self.bn = nn.BatchNorm1d(out_dim)
+        self.relu   = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        linear = self.linear(x)
+        bn     = self.bn(linear) if self.with_bn else linear
+        relu   = self.relu(bn)
+        return relu
+
+class residual(nn.Module):
+    def __init__(self, k, inp_dim, out_dim, stride=1, with_bn=True):
+        super(residual, self).__init__()
+
+        self.conv1 = nn.Conv2d(inp_dim, out_dim, (3, 3), padding=(1, 1), stride=(stride, stride), bias=False)
+        self.bn1   = nn.BatchNorm2d(out_dim)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(out_dim, out_dim, (3, 3), padding=(1, 1), bias=False)
+        self.bn2   = nn.BatchNorm2d(out_dim)
+
+        self.skip  = nn.Sequential(
+            nn.Conv2d(inp_dim, out_dim, (1, 1), stride=(stride, stride), bias=False),
+            nn.BatchNorm2d(out_dim)
+        ) if stride != 1 or inp_dim != out_dim else nn.Sequential()
+        self.relu  = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        conv1 = self.conv1(x)
+        bn1   = self.bn1(conv1)
+        relu1 = self.relu1(bn1)
+
+        conv2 = self.conv2(relu1)
+        bn2   = self.bn2(conv2)
+
+        skip  = self.skip(x)
+        return self.relu(bn2 + skip)