class AdversarialDomainAdaptation(nn.Module):
def __init__(self, input_dim, cnn_hidden_dim, filter_width,
lstm_hidden_dim, Lambda, use_cuda):
super(AdversarialDomainAdaptation, self).__init__()
self.question_encoder_cnn = CNNEncoder(input_dim,
cnn_hidden_dim,
filter_width,
use_cuda=use_cuda)
self.question_encoder_lstm = LSTMEncoder(input_dim,
lstm_hidden_dim,
use_cuda=use_cuda)
self.gradient_reversal = GradientReversalLayer(Lambda, use_cuda)
self.domain_classifier_cnn = DomainClassifier(input_dim=cnn_hidden_dim,
use_cuda=use_cuda)
self.domain_classifier_lstm = DomainClassifier(
input_dim=lstm_hidden_dim, use_cuda=use_cuda)
if use_cuda:
self.cuda()
def forward(self,
title,
body,
title_mask,
body_mask,
use_cnn=True,
use_domain_classifier=True,
return_average=True):
"""
Runs one forward pass on the input.
Return two things:
- the embedding, so that we can feed it into the loss function for label
prediction (only if the input came from source not target dataset)
- the predicted domain label from softmax, so that we can feed it into
the loss function for domain classification
"""
title_embedding = None
body_embedding = None
if use_cnn:
title_embedding = self.question_encoder_cnn.run_all(
title, title_mask)
body_embedding = self.question_encoder_cnn.run_all(body, body_mask)
else:
title_embedding = self.question_encoder_lstm.run_all(
title, title_mask)
body_embedding = self.question_encoder_lstm.run_all(
body, body_mask)
embedding = (title_embedding + body_embedding) / 2
domain_label = None
if use_domain_classifier:
reverse = self.gradient_reversal(embedding)
if use_cnn:
domain_label = self.domain_classifier_cnn(reverse)
else:
domain_label = self.domain_classifier_lstm(reverse)
return embedding, domain_label
def change_lambda(self, Lambda):
self.gradient_reversal.change_lambda(Lambda)
def __init__(self, n_domains, n_classes, arch='resnet152'):
super(MDANet, self).__init__()
if arch == 'resnet152':
resnet_layers = dict(
models.resnet152(pretrained=True).named_children())
else: # resnet101
resnet_layers = dict(
models.resnet101(pretrained=True).named_children())
self.feat_ext = nn.Sequential(
OrderedDict([(key, resnet_layers[key]) for key in [
'conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3'
]]))
self.task_class = nn.Sequential(
OrderedDict([(key, resnet_layers[key])
for key in ['layer4', 'avgpool']] +
[('flatten',
Flatten()), ('fc', nn.Linear(2048, n_classes))]))
self.domain_class = nn.ModuleList([])
for _ in range(n_domains):
self.domain_class.append(
nn.Sequential(
OrderedDict([(key, deepcopy(resnet_layers[key]))
for key in ['layer4', 'avgpool']] +
[('flatten',
Flatten()), ('fc', nn.Linear(2048, 2))])))
self.grad_reverse = nn.ModuleList(
[GradientReversalLayer() for _ in range(n_domains)])
def __init__(self, input_dim, cnn_hidden_dim, filter_width,
lstm_hidden_dim, Lambda, use_cuda):
super(AdversarialDomainAdaptation, self).__init__()
self.question_encoder_cnn = CNNEncoder(input_dim,
cnn_hidden_dim,
filter_width,
use_cuda=use_cuda)
self.question_encoder_lstm = LSTMEncoder(input_dim,
lstm_hidden_dim,
use_cuda=use_cuda)
self.gradient_reversal = GradientReversalLayer(Lambda, use_cuda)
self.domain_classifier_cnn = DomainClassifier(input_dim=cnn_hidden_dim,
use_cuda=use_cuda)
self.domain_classifier_lstm = DomainClassifier(
input_dim=lstm_hidden_dim, use_cuda=use_cuda)
if use_cuda:
self.cuda()
def __init__(self, n_domains, n_classes, arch='resnet50'):
super(MDANet, self).__init__()
if arch == 'resnet50':
resnet_layers = dict(models.resnet50(pretrained=True).named_children())
self.feat_ext = nn.Sequential(OrderedDict(
[(key, resnet_layers[key])
for key in ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3']]))
self.task_class = nn.Sequential(
OrderedDict(
[(key, resnet_layers[key])
for key in ['layer4', 'avgpool']]
+[('flatten', Flatten()), ('fc', nn.Linear(2048, n_classes))]))
self.domain_class = nn.ModuleList([])
for _ in range(n_domains):
resnet_layers = dict(models.resnet50(pretrained=True).named_children())
self.domain_class.append(nn.Sequential(
OrderedDict(
[(key, resnet_layers[key])
for key in ['layer4', 'avgpool']]
+[('flatten', Flatten()), ('fc', nn.Linear(2048, 2))])))
else: # alexnet
alexnet_layers = dict(models.alexnet(pretrained=True).named_children())
self.feat_ext = nn.Sequential(OrderedDict(
[(key, alexnet_layers[key])
for key in ['features', 'avgpool']]
+[('flatten', Flatten()),
('fc', nn.Sequential(
nn.Dropout(0.5),
nn.Linear(9216, 4096),
nn.ReLU(inplace=True),
nn.Dropout(0.5),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),))]))
self.task_class = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, n_classes))
self.domain_class = nn.ModuleList([])
for _ in range(n_domains):
self.domain_class.append(nn.Sequential(
nn.Dropout(0.5),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, n_classes)))
self.grad_reverse = nn.ModuleList([GradientReversalLayer() for _ in range(n_domains)])
def __init__(self, input_dim, n_classes, dropout_rate=0.):
super(MixMDANet, self).__init__()
self.feat_ext = nn.Sequential(
OrderedDict([
('Dropout1', nn.Dropout(dropout_rate)),
('Linear1', nn.Linear(input_dim, 1000)),
('ReLU1', nn.ReLU()),
('Dropout2', nn.Dropout(dropout_rate)),
('Linear2', nn.Linear(1000, 500)),
('ReLU2', nn.ReLU()),
('Linear3', nn.Linear(500, 100)),
('ReLU3', nn.ReLU()),
('Dropout3', nn.Dropout(dropout_rate)),
]))
self.task_class = nn.Linear(100, n_classes)
self.grad_reverse = GradientReversalLayer()
self.domain_class = nn.Linear(100, 2)
def __init__(self, n_domains):
super(MDANet, self).__init__()
self.feat_ext = nn.Sequential(
OrderedDict([
('Conv1', nn.Conv2d(3, 64, kernel_size=3, padding=1)),
('ReLU1', nn.ReLU()),
('MaxPool1', nn.MaxPool2d(2)),
('Conv2', nn.Conv2d(64, 128, kernel_size=3, padding=1)),
('ReLU2', nn.ReLU()),
('MaxPool2', nn.MaxPool2d(2)),
('Conv3', nn.Conv2d(128, 256, kernel_size=3, padding=1)),
('ReLU3', nn.ReLU()),
]))
self.task_class = nn.Sequential(
OrderedDict([
('MaxPool3', nn.MaxPool2d(2)),
('Conv4', nn.Conv2d(256, 256, kernel_size=3, padding=1)),
('ReLU4', nn.ReLU()),
('Flatten', Flatten()),
('FC1', nn.Linear(4096, 2048)), # 4096 = (256*32*32)/(2^3*2^3)
('ReLU5', nn.ReLU()),
('FC2', nn.Linear(2048, 1024)),
('ReLU6', nn.ReLU()),
('FC3', nn.Linear(1024, 10)),
]))
self.grad_reverse = nn.ModuleList(
[GradientReversalLayer() for _ in range(n_domains)])
self.domain_class = nn.ModuleList([
nn.Sequential(
nn.MaxPool2d(2),
Flatten(),
nn.Linear(4096, 2048), # 4096 = (256*32*32)/(2^3*2^3)
nn.ReLU(),
nn.Linear(2048, 2048),
nn.ReLU(),
nn.Linear(2048, 2),
) for _ in range(n_domains)
])