init

models/CB_Loss.py

@@ -0,0 +1,41 @@
+import torch
+import torch.nn.functional as F
+import numpy as np
+class CBLoss(torch.nn.Module):
+    def __init__(self, samples_per_cls, no_of_classes, loss_type, beta=0.9999, gamma=2.0):
+        super(CBLoss, self).__init__()
+        self.samples_per_cls = samples_per_cls#samples_per_cls: 一个列表，表示每个类别的样本数量
+        self.no_of_classes = no_of_classes #no_of_classes: 类别数量
+        self.loss_type = loss_type #loss_type: 表示损失函数的类型，可以是 softmax、sigmoid 或 focal
+        self.beta = beta #beta: 参考论文中定义的 beta 参数，默认值是 0.9999
+        self.gamma = gamma #gamma: 如果损失函数类型是 focal，表示 gamma 参数，默认值是 2.0
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def forward(self, logits, labels):
+        #effective_num = 1.0 - np.power(self.beta, self.samples_per_cls)
+        #weights = (1.0 - self.beta) / effective_num
+        #weights = weights / torch.sum(weights) * self.no_of_classes
+        weights = np.array([1]) * self.no_of_classes
+        labels_one_hot = F.one_hot(labels, self.no_of_classes).float()
+        weights = torch.tensor(weights).float()
+
+        weights = weights.unsqueeze(0).to(self.device)
+        labels_one_hot = labels_one_hot.to(self.device)
+
+        weights = weights.repeat(labels_one_hot.shape[0], 1) * labels_one_hot
+        weights = weights.sum(1).unsqueeze(1)
+        weights = weights.repeat(1, self.no_of_classes)
+
+        if self.loss_type == "focal":
+            ce_loss = F.binary_cross_entropy_with_logits(input=logits, target=labels_one_hot, reduction="none")
+            pt = torch.exp(-ce_loss)
+            focal_loss = ((1 - pt) ** self.gamma * ce_loss).mean()
+            loss = focal_loss
+        elif self.loss_type == "sigmoid":
+            loss = F.binary_cross_entropy_with_logits(input=logits, target=labels_one_hot, weight=weights)
+        elif self.loss_type == "softmax":
+            # loss = F.cross_entropy(input=logits, target=labels, weight=weights)
+            pred = logits.softmax(dim=1)
+            cb_loss = F.binary_cross_entropy(input=pred, target=labels_one_hot, weight=weights)
+
+        return cb_loss

models/DomainClassifierSource.py

@@ -0,0 +1,48 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+
+def _assert_no_grad(variable):
+    assert not variable.requires_grad, \
+        "nn criterions don't compute the gradient w.r.t. targets - please " \
+        "mark these variables as volatile or not requiring gradients"
+
+
+class _Loss(nn.Module):
+    def __init__(self, size_average=True):
+        super(_Loss, self).__init__()
+        self.size_average = size_average
+
+
+class _WeightedLoss(_Loss):
+    def __init__(self, weight=None, size_average=True):
+        super(_WeightedLoss, self).__init__(size_average)
+        self.register_buffer('weight', weight)
+
+
+class DClassifierForSource(_WeightedLoss):
+
+    def __init__(self, weight=None, size_average=True, ignore_index=-100, reduce=True, nClass=10):
+        super(DClassifierForSource, self).__init__(weight, size_average)
+        self.nClass = nClass
+
+    def forward(self, input):
+        # _assert_no_grad(target)
+        batch_size = input.size(0)
+        prob = F.softmax(input, dim=1)
+        # prob = F.sigmoid(input)
+        c = prob.data[:, :self.nClass].sum(1)
+        d = (prob.data[:, :self.nClass].sum(1) == 0).sum()
+        if (prob.data[:, :self.nClass].sum(1) == 0).sum() != 0:  ########### in case of log(0)
+            soft_weight = torch.FloatTensor(batch_size).fill_(0)
+            soft_weight[prob[:, :self.nClass].sum(1).data.cpu() == 0] = 1e-6
+            soft_weight_var = Variable(soft_weight).cuda()
+            loss = -((prob[:, :self.nClass].sum(1) + soft_weight_var).log().mean())
+        else:
+            a = prob[:, :self.nClass].sum(1)  # 求数组每一行的和
+            b = a.log()
+            c = b.mean()
+            loss = -(prob[:, :self.nClass].sum(1).log().mean())
+        return loss

models/DomainClassifierTarget.py

@@ -0,0 +1,44 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+
+def _assert_no_grad(variable):
+    assert not variable.requires_grad, \
+        "nn criterions don't compute the gradient w.r.t. targets - please " \
+        "mark these variables as volatile or not requiring gradients"
+
+
+class _Loss(nn.Module):
+    def __init__(self, size_average=True):
+        super(_Loss, self).__init__()
+        self.size_average = size_average
+
+
+class _WeightedLoss(_Loss):
+    def __init__(self, weight=None, size_average=True):
+        super(_WeightedLoss, self).__init__(size_average)
+        self.register_buffer('weight', weight)
+
+
+class DClassifierForTarget(_WeightedLoss):
+
+    def __init__(self, weight=None, size_average=True, ignore_index=-100, reduce=True, nClass=10):
+        super(DClassifierForTarget, self).__init__(weight, size_average)
+        self.nClass = nClass
+
+    def forward(self, input):
+        # _assert_no_grad(target)
+        batch_size = input.size(0)
+
+        prob = F.softmax(input, dim=1)
+        # prob = F.sigmoid(input)
+        if (prob.data[:, self.nClass:].sum(1) == 0).sum() != 0:  ########### in case of log(0)
+            soft_weight = torch.FloatTensor(batch_size).fill_(0)
+            soft_weight[prob[:, self.nClass:].sum(1).data.cpu() == 0] = 1e-6
+            soft_weight_var = Variable(soft_weight).cuda()
+            loss = -((prob[:, self.nClass:].sum(1) + soft_weight_var).log().mean())
+        else:
+            loss = -(prob[:, self.nClass:].sum(1).log().mean())
+        return loss

models/EntropyMinimizationPrinciple.py

@@ -0,0 +1,46 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+
+def _assert_no_grad(variable):
+    assert not variable.requires_grad, \
+        "nn criterions don't compute the gradient w.r.t. targets - please " \
+        "mark these variables as volatile or not requiring gradients"
+
+
+class _Loss(nn.Module):
+    def __init__(self, size_average=True):
+        super(_Loss, self).__init__()
+        self.size_average = size_average
+
+
+class _WeightedLoss(_Loss):
+    def __init__(self, weight=None, size_average=True):
+        super(_WeightedLoss, self).__init__(size_average)
+        self.register_buffer('weight', weight)
+
+
+class EMLossForTarget(_WeightedLoss):
+
+    def __init__(self, weight=None, size_average=True, ignore_index=-100, reduce=True, nClass=10):
+        super(EMLossForTarget, self).__init__(weight, size_average)
+        self.nClass = nClass
+
+    def forward(self, input):
+        batch_size = input.size(0)
+        prob = F.softmax(input, dim=1)
+        # prob = F.sigmoid(input)
+        prob_source = prob[:, :self.nClass]
+        prob_target = prob[:, self.nClass:]
+        prob_sum = prob_target + prob_source
+        if (prob_sum.data.cpu() == 0).sum() != 0:
+            weight_sum = torch.FloatTensor(batch_size, self.nClass).fill_(0)
+            weight_sum[prob_sum.data.cpu() == 0] = 1e-6
+            weight_sum = Variable(weight_sum).cuda()
+            loss_sum = -(prob_sum + weight_sum).log().mul(prob_sum).sum(1).mean()
+        else:
+            loss_sum = -prob_sum.log().mul(prob_sum).sum(1).mean()
+
+        return loss_sum

models/SmoothCrossEntropy.py

@@ -0,0 +1,12 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+class SmoothCrossEntropy(nn.Module):
+    def __init__(self, epsilon: float = 0.):
+        super(SmoothCrossEntropy, self).__init__()
+        self.epsilon = float(epsilon)
+
+    def forward(self, logits: torch.Tensor, labels: torch.LongTensor) -> torch.Tensor:
+        target_probs = torch.full_like(logits, self.epsilon / (logits.shape[1] - 1))
+        target_probs.scatter_(1, labels.unsqueeze(1), 1 - self.epsilon)
+        return F.kl_div(torch.log_softmax(logits, 1), target_probs, reduction='none').sum(1)

models/resnet.py

@@ -0,0 +1,261 @@
+import torch.nn as nn
+import math
+import torch.utils.model_zoo as model_zoo
+import torch
+import ipdb
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152']
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    "3x3 convolution with padding"
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * 4)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.avgpool = nn.AvgPool2d(7)
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+
+
+def resnet18(args, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    if args.pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
+    # modify the structure of the model.
+    num_of_feature_map = model.fc.in_features
+    model.fc = nn.Linear(num_of_feature_map, args.num_classes)
+    model.fc.weight.data.normal_(0.0, 0.02)
+    model.fc.bias.data.normal_(0)
+    return model
+
+
+def resnet34(args, **kwargs):
+    """Constructs a ResNet-34 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if args.pretrained:
+        print('Load ImageNet pre-trained resnet model')
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
+    # modify the structure of the model.
+    num_of_feature_map = model.fc.in_features
+    model.fc = nn.Linear(num_of_feature_map, args.num_classes)
+
+    return model
+
+
+def resnet50(args, **kwargs):
+    """Constructs a ResNet-50 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+    if args.pretrained:
+        if args.pretrained_checkpoint:  ################### use self-pretrained model
+            # modify the structure of the model.
+            num_of_feature_map = model.fc.in_features
+            model.fc = nn.Linear(num_of_feature_map, args.num_classes * 2)
+            init_dict = model.state_dict()
+            pretrained_dict_temp = torch.load(args.pretrained_checkpoint)['state_dict']
+            pretrained_dict = {k.replace('module.', ''): v for k, v in pretrained_dict_temp.items()}
+            temp = init_dict['fc.weight'].clone()
+            temp[:args.num_classes, :] = pretrained_dict['fc.weight'].clone()
+            pretrained_dict['fc.weight'] = temp.clone()
+            temp = init_dict['fc.bias'].clone()
+            temp[:args.num_classes] = pretrained_dict['fc.bias'].clone()
+            pretrained_dict['fc.bias'] = temp.clone()
+            model.load_state_dict(pretrained_dict)
+        else:
+            model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))  ########## use imagenet pretrained model
+            # modify the structure of the model.
+            num_of_feature_map = model.fc.in_features
+            model.fc = nn.Linear(num_of_feature_map, args.num_classes * 2)
+    return model
+
+
+def resnet101(args, **kwargs):
+    """Constructs a ResNet-101 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    if args.pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
+    # modify the structure of the model.
+    num_of_feature_map = model.fc.in_features
+    model.fc = nn.Linear(num_of_feature_map, args.num_classes)
+    model.fc.weight.data.normal_(0.0, 0.02)
+    model.fc.bias.data.normal_(0)
+    return model
+
+
+def resnet152(args, **kwargs):
+    """Constructs a ResNet-152 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    if args.pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
+    # modify the structure of the model.
+    num_of_feature_map = model.fc.in_features
+    model.fc = nn.Linear(num_of_feature_map, args.num_classes)
+
+    return model
+
+
+def resnet(args, **kwargs):  ################ Only support ResNet-50 in this simple code.
+    print("==> creating model '{}' ".format(args.arch))
+    if args.arch == 'resnet18':
+        return resnet18(args)
+    elif args.arch == 'resnet34':
+        return resnet34(args)
+    elif args.arch == 'resnet50':
+        return resnet50(args)
+    elif args.arch == 'resnet101':
+        return resnet101(args)
+    elif args.arch == 'resnet152':
+        return resnet152(args)
+    else:
+        raise ValueError('Unrecognized model architecture', args.arch)