def __init__(self, input_shape, num_classes, num_domains, hparams):
super(SagNet, self).__init__(input_shape, num_classes, num_domains,
hparams)
# featurizer network
self.network_f = networks.Featurizer(input_shape, self.hparams)
# content network
self.network_c = networks.Classifier(
self.network_f.n_outputs,
num_classes,
self.hparams['nonlinear_classifier'])
# style network
self.network_s = networks.Classifier(
self.network_f.n_outputs,
num_classes,
self.hparams['nonlinear_classifier'])
# # This commented block of code implements something closer to the
# # original paper, but is specific to ResNet and puts in disadvantage
# # the other algorithms.
# resnet_c = networks.Featurizer(input_shape, self.hparams)
# resnet_s = networks.Featurizer(input_shape, self.hparams)
# # featurizer network
# self.network_f = torch.nn.Sequential(
# resnet_c.network.conv1,
# resnet_c.network.bn1,
# resnet_c.network.relu,
# resnet_c.network.maxpool,
# resnet_c.network.layer1,
# resnet_c.network.layer2,
# resnet_c.network.layer3)
# # content network
# self.network_c = torch.nn.Sequential(
# resnet_c.network.layer4,
# resnet_c.network.avgpool,
# networks.Flatten(),
# resnet_c.network.fc)
# # style network
# self.network_s = torch.nn.Sequential(
# resnet_s.network.layer4,
# resnet_s.network.avgpool,
# networks.Flatten(),
# resnet_s.network.fc)
def opt(p):
return torch.optim.Adam(p, lr=hparams["lr"],
weight_decay=hparams["weight_decay"])
self.optimizer_f = opt(self.network_f.parameters())
self.optimizer_c = opt(self.network_c.parameters())
self.optimizer_s = opt(self.network_s.parameters())
self.weight_adv = hparams["sag_w_adv"]
def __init__(self, input_shape, num_classes, num_domains,
hparams, conditional, class_balance):
super(AbstractDANN, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.register_buffer('update_count', torch.tensor([0]))
self.conditional = conditional
self.class_balance = class_balance
# Algorithms
self.featurizer = networks.Featurizer(input_shape, self.hparams)
self.classifier = networks.Classifier(
self.featurizer.n_outputs,
num_classes,
self.hparams['nonlinear_classifier'])
self.discriminator = networks.MLP(self.featurizer.n_outputs,
num_domains, self.hparams)
self.class_embeddings = nn.Embedding(num_classes,
self.featurizer.n_outputs)
# Optimizers
self.disc_opt = torch.optim.Adam(
(list(self.discriminator.parameters()) +
list(self.class_embeddings.parameters())),
lr=self.hparams["lr_d"],
weight_decay=self.hparams['weight_decay_d'],
betas=(self.hparams['beta1'], 0.9))
self.gen_opt = torch.optim.Adam(
(list(self.featurizer.parameters()) +
list(self.classifier.parameters())),
lr=self.hparams["lr_g"],
weight_decay=self.hparams['weight_decay_g'],
betas=(self.hparams['beta1'], 0.9))
def __init__(self, input_shape, num_classes, num_domains, hparams):
super(MULDENS, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.num_models = hparams['MULDENS_num_models']
self.num_classes = num_classes
self.classifiers = torch.nn.ModuleList([
networks.Classifier(self.featurizer.n_outputs, self.num_classes,
self.hparams['nonlinear_classifier'])
for _ in range(self.num_models)
])
# verify that they are different
self.MULDENS_networks= torch.nn.ModuleList([nn.Sequential(copy.deepcopy(self.featurizer),classifier_i) \
for classifier_i in self.classifiers])
self.MULDENS_network_optimizers = [
torch.optim.Adam(network_i.parameters(),
lr=self.hparams["lr_MULDENS"],
weight_decay=self.hparams['weight_decay'])
for network_i in self.MULDENS_networks
]
del self.network
self.compute_train_beta = hparams['COMPUTE_BETA_TRAIN']
self.random_beta = False
self.beta_from_loss = False
self.use_all_batches_for_all_models = False
def __init__(self, input_shape, num_classes, num_domains, hparams):
super(ERM, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.featurizer = networks.Featurizer(input_shape, self.hparams)
self.classifier = networks.Classifier(
self.featurizer.n_outputs, num_classes,
self.hparams['nonlinear_classifier'])
self.network = nn.Sequential(self.featurizer, self.classifier)
self.optimizer = torch.optim.Adam(
self.network.parameters(),
lr=self.hparams["lr"],
weight_decay=self.hparams['weight_decay'])
def __init__(self, input_shape, num_classes, num_domains, hparams):
super(MTL, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.featurizer = networks.Featurizer(input_shape, self.hparams)
self.classifier = networks.Classifier(
self.featurizer.n_outputs * 2, num_classes,
self.hparams["nonlinear_classifier"])
self.optimizer = torch.optim.Adam(
list(self.featurizer.parameters()) +
list(self.classifier.parameters()),
lr=self.hparams["lr"],
weight_decay=self.hparams["weight_decay"],
)
self.register_buffer(
"embeddings", torch.zeros(num_domains, self.featurizer.n_outputs))
self.ema = self.hparams["mtl_ema"]
def __init__(self, input_shape, num_classes, num_domains, hparams):
super(ERM, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.featurizer = networks.DTI_Encoder()
self.classifier = networks.Classifier(
self.featurizer.n_outputs, num_classes,
self.hparams['nonlinear_classifier'])
self.network = mySequential(self.featurizer, self.classifier)
self.optimizer = torch.optim.Adam(
self.network.parameters(),
lr=self.hparams["lr"],
weight_decay=self.hparams['weight_decay'])
from tdc import Evaluator
self.evaluator = Evaluator(name='PCC')
self.loss_fct = torch.nn.MSELoss()
def __init__(self, input_shape, num_classes, num_domains, hparams):
super(MTL, self).__init__(input_shape, num_classes, num_domains,
hparams)
self.featurizer = networks.DTI_Encoder()
self.classifier = networks.Classifier(
self.featurizer.n_outputs * 2, num_classes,
self.hparams['nonlinear_classifier'])
self.optimizer = torch.optim.Adam(
list(self.featurizer.parameters()) +\
list(self.classifier.parameters()),
lr=self.hparams["lr"],
weight_decay=self.hparams['weight_decay']
)
self.register_buffer(
'embeddings', torch.zeros(num_domains, self.featurizer.n_outputs))
self.ema = self.hparams['mtl_ema']
self.loss_fct = torch.nn.MSELoss()
from tdc import Evaluator
self.evaluator = Evaluator(name='PCC')
