def visualizePerformance(feature_extractor, class_classifier,
domain_classifier, src_test_dataloader,
tgt_test_dataloader):
"""
Evaluate the performance of dann and source only by visualization.
:param feature_extractor: network used to extract feature from target samples
:param class_classifier: network used to predict labels
:param domain_classifier: network used to predict domain
:param source_dataloader: test dataloader of source domain
:param target_dataloader: test dataloader of target domain
:return:
"""
# Setup the network
feature_extractor.eval()
class_classifier.eval()
domain_classifier.eval()
# Randomly select samples from source domain and target domain.
dataiter = iter(src_test_dataloader)
s_images, s_labels = dataiter.next()
if params.use_gpu:
s_images = Variable(s_images.cuda())
else:
s_images = Variable(s_images)
s_tags = Variable(torch.zeros((s_labels.size()[0])).type(torch.LongTensor))
dataiter = iter(tgt_test_dataloader)
t_images, t_labels = dataiter.next()
if params.use_gpu:
t_images = Variable(t_images.cuda())
else:
t_images, t_labels = Variable(t_images), Variable(t_labels)
t_tags = Variable(torch.ones((t_labels.size()[0])).type(torch.LongTensor))
# Compute the embedding of target domain.
embedding1 = feature_extractor(s_images)
embedding2 = feature_extractor(t_images)
tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=3000)
if params.use_gpu:
dann_tsne = tsne.fit_transform(
np.concatenate((embedding1.cpu().detach().numpy(),
embedding2.cpu().detach().numpy())))
else:
dann_tsne = tsne.fit_transform(
np.concatenate(
(embedding1.detach().numpy(), embedding2.detach().numpy())))
# utils.plot_embedding(source_only_tsne, combined_test_labels.argmax(1), combined_test_domain.argmax(1), 'Source only')
utils.plot_embedding(dann_tsne, np.concatenate((s_labels, t_labels)),
np.concatenate((s_tags, t_tags)), 'Domain Adaptation')
def visualizePerformance(feature_extractor,
class_classifier,
domain_classifier,
src_test_dataloader,
tgt_test_dataloader,
num_of_samples=None,
imgName=None):
"""
Evaluate the performance of dann and source only by visualization.
:param feature_extractor: network used to extract feature from target samples
:param class_classifier: network used to predict labels
:param domain_classifier: network used to predict domain
:param source_dataloader: test dataloader of source domain
:param target_dataloader: test dataloader of target domain
:param num_of_samples: the number of samples (from train and test respectively) for t-sne
:param imgName: the name of saving image
:return:
"""
# Setup the network
feature_extractor.eval()
class_classifier.eval()
domain_classifier.eval()
# Randomly select samples from source domain and target domain.
if num_of_samples is None:
num_of_samples = params.batch_size
else:
assert len(src_test_dataloader) * num_of_samples, \
'The number of samples can not bigger than dataset.' # NOT PRECISELY COMPUTATION
# Collect source data.
s_images, s_labels, s_tags = [], [], []
for batch in src_test_dataloader:
images, labels = batch
if params.use_gpu:
s_images.append(images.cuda())
else:
s_images.append(images)
s_labels.append(labels)
s_tags.append(torch.zeros((labels.size()[0])).type(torch.LongTensor))
if len(s_images * params.batch_size) > num_of_samples:
break
s_images, s_labels, s_tags = torch.cat(s_images)[:num_of_samples], \
torch.cat(s_labels)[:num_of_samples], torch.cat(s_tags)[:num_of_samples]
# Collect test data.
t_images, t_labels, t_tags = [], [], []
for batch in tgt_test_dataloader:
images, labels = batch
if params.use_gpu:
t_images.append(images.cuda())
else:
t_images.append(images)
t_labels.append(labels)
t_tags.append(torch.ones((labels.size()[0])).type(torch.LongTensor))
if len(t_images * params.batch_size) > num_of_samples:
break
t_images, t_labels, t_tags = torch.cat(t_images)[:num_of_samples], \
torch.cat(t_labels)[:num_of_samples], torch.cat(t_tags)[:num_of_samples]
# Compute the embedding of target domain.
embedding1 = feature_extractor(s_images)
embedding2 = feature_extractor(t_images)
tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=3000)
if params.use_gpu:
dann_tsne = tsne.fit_transform(
np.concatenate((embedding1.cpu().detach().numpy(),
embedding2.cpu().detach().numpy())))
else:
dann_tsne = tsne.fit_transform(
np.concatenate(
(embedding1.detach().numpy(), embedding2.detach().numpy())))
utils.plot_embedding(dann_tsne, np.concatenate((s_labels, t_labels)),
np.concatenate((s_tags, t_tags)), 'Domain Adaptation',
imgName)