def _prepare_sample(self, sample, volatile, cuda):
"""
Args:
sample: dict of list
self._sample:
dict:
feature: [Var(LongTensor)]
position: [Var(LongTensor)]
target: Var(LongTensor)
tree: [Tree]
"""
def helper(k):
sample[k] = [
make_variable(item, cuda=cuda, volatile=volatile)
for item in sample[k]
]
self._sample = {}
self._sample['feature'] = [
make_variable(item, cuda=cuda, volatile=volatile)
for item in sample['feature']
]
self._sample['position'] = [
make_variable(item, cuda=cuda, volatile=volatile)
for item in sample['position']
]
self._sample['target'] = make_variable(sample['target'],
cuda=cuda,
volatile=volatile).view(-1)
self._sample['tree'] = sample['tree']
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
acc = 0
tot_loss = 0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
epoch_stat = []
with torch.no_grad():
for (images, labels) in data_loader:
images = make_variable(images)
labels = make_variable(labels).squeeze_()
preds = classifier(encoder(images))
loss = criterion(preds, labels).item()
tot_loss += loss
_, pred_cls = torch.max(preds, 1)
#pred_cls = preds.item.max(1)[1]
#acc = pred_cls.eq(labels.data).cpu().sum()
acc += (pred_cls == labels).sum().float()
tot_loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(tot_loss, acc))
return tot_loss, acc
def eval_src( source_encoder, source_classifier, data_loader ):
loss = 0
accuracy = 0
source_encoder.eval()
source_classifier.eval()
criterion = nn.CrossEntropyLoss()
correct = 0
total = 0
for (images, labels) in data_loader:
images = make_variable( images, volatile = True )
labels = make_variable( labels )
preds = source_classifier( source_encoder( images ) )
loss += criterion( preds, labels ).item()
_, predicted = torch.max(preds.data,1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
# pred_cls = preds.data.max(1)[1]
# print(pred_cls.eq(labels.data).cpu().sum())
# accuracy += pred_cls.eq(labels.data).cpu().sum() / len(labels)
loss /= len(data_loader)
# accuracy /= len( data_loader )
accuracy = correct/total
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, accuracy))
def train_src(encoder, classifier, data_loader):
"""Train classifier for source domain."""
####################
# 1. setup network #
####################
# set train state for Dropout and BN layers
encoder.train()
classifier.train()
# setup criterion and optimizer
optimizer = optim.Adam(list(encoder.parameters()) +
list(classifier.parameters()),
lr=params.c_learning_rate,
betas=(params.beta1, params.beta2))
criterion = nn.CrossEntropyLoss()
####################
# 2. train network #
####################
for epoch in range(params.num_epochs_pre):
for step, (images, labels) in enumerate(data_loader):
# make images and labels variable
images = make_variable(images)
labels = make_variable(labels.squeeze_())
# zero gradients for optimizer
optimizer.zero_grad()
# compute loss for critic
preds = classifier(encoder(images))
loss = criterion(preds, labels)
# optimize source classifier
loss.backward()
optimizer.step()
# print step info
if ((step + 1) % params.log_step_pre == 0):
print("Epoch [{}/{}] Step [{}/{}]: loss={}".format(
epoch + 1, params.num_epochs_pre, step + 1,
len(data_loader), loss.data[0]))
# eval model on test set
if ((epoch + 1) % params.eval_step_pre == 0):
eval_src(encoder, classifier, data_loader)
pdb.set_trace()
# save model parameters
if ((epoch + 1) % params.save_step_pre == 0):
save_model(encoder, "ADDA-source-encoder-{}.pt".format(epoch + 1))
save_model(classifier,
"ADDA-source-classifier-{}.pt".format(epoch + 1))
# # save final model
save_model(encoder, "ADDA-source-encoder-final.pt")
save_model(classifier, "ADDA-source-classifier-final.pt")
return encoder, classifier
def eval_on_source_dset(encoder, classifier, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
# No grad neede
with torch.no_grad():
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images)
labels = make_variable(labels)
preds = classifier(encoder(images))
loss += criterion(preds, labels).item()
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).to("cpu").sum()
loss = loss / len(data_loader)
acc = acc.item() / len(data_loader.dataset)
print("=====================================================================")
print("Evaluating Model on the Source Dataset")
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, acc))
print("=====================================================================")
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
# set loss function
criterion = nn.CrossEntropyLoss()
correct = 0
total = 0
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels).squeeze_()
preds = classifier(encoder(images))
loss += criterion(preds, labels).item()
_, predicted = torch.max(preds.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
# pred_cls = preds.data.max(1)[1]
# acc += pred_cls.eq(labels.data).cpu().sum()
loss /= len(data_loader)
# acc /= len(data_loader.dataset)
acc = correct / total
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, acc))
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
acc = np.zeros(13)
total = np.zeros(13)
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels).squeeze_()
preds = classifier(encoder(images))
pred_cls = preds.data.max(1)[1]
total[12] += len(labels)
acc[12] += pred_cls.eq(labels.data.to(dtype=torch.int64)).cpu().sum()
for i in range(12):
temp = (labels == i)
total[i]+= int(sum(temp))
temp_labels = labels.to(dtype=torch.int64) + 100*(1-temp.to(dtype=torch.int64))
acc[i] += (pred_cls.eq(temp_labels.data.to(dtype=torch.int64)).cpu()).sum()
acc = acc/total *100
acc = np.round(acc,1)
print(acc)
def eval_ood(src_classifier, src_data_loader, tgt_data_loader_eval):
mean, inv, m_mean, m_std = get_distribution(src_data_loader)
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
src_classifier.eval()
acc = 0
f1 = 0
ys_true = []
ys_pred = []
for (images, labels) in tgt_data_loader_eval:
images = make_variable(images, volatile=True)
labels = make_variable(labels).detach().cpu().numpy()
preds = src_classifier(images)
for pred, image, label in zip(preds, images, labels):
if is_in_distribution(image.detach().cpu().numpy(), mean, inv,
m_mean, m_std):
ys_true.append(label)
ys_pred.append(np.argmax(pred.detach().cpu().numpy()))
else:
continue
acc = accuracy_score(ys_true, ys_pred)
f1 = get_f1(ys_pred, ys_true, 'macro')
print(" F1 = {:2%}, accuracy = {:2%}".format(f1, acc))
def test_from_save(model, saved_model, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
classifier = model.load_state_dict(torch.load(saved_model))
classifier.eval()
# init loss and accuracy
loss = 0.0
acc = 0.0
# set loss function
criterion = nn.NLLLoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels) #labels = labels.squeeze(1)
preds = classifier(images)
criterion(preds, labels)
loss += criterion(preds, labels).data[0]
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).cpu().sum()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {}, Avg Accuracy = {:.2%}".format(loss, acc))
def eval_src_encoder(encoder, classifier, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0.0
acc = 0.0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels)
preds = classifier(encoder(images))
try:
loss += criterion(preds, labels).data
except:
loss = criterion(preds, torch.max(labels, 1)[1]).data
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).cpu().sum()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, acc))
def eval_src(encoder, classifier, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
with torch.no_grad():
for (images, labels) in data_loader:
images = make_variable(images)
labels = make_variable(labels)
preds = classifier(encoder(images))
loss += criterion(preds, labels).item()
_, pred_cls = torch.max(preds.data, 1)
acc += (pred_cls == labels.data).sum().item()
#pred_cls = preds.data.max(1)[1]
#acc += pred_cls.eq(labels.data).cpu().sum()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, acc))
def compute_means(file_full, file_out):
"""
Calculate the means.
"""
# Load datasets
# TODO: Rename 'plev' to 'lev'
# NOTE: GFDL doesn't use CF conventions right now.
# See: https://github.com/xgcm/xgcm/issues/91
timer()
if os.path.exists(file_out):
os.remove(file_out)
data_full = nc4.Dataset(file_full, mode='r')
data_out = nc4.Dataset(file_out, mode='w')
copy_attrs(data_full, data_out, ignore=('NCO', 'filename', 'history'))
for coord in ('time', 'plev', 'lat', 'lon', 'plev_bnds'):
copy_variable(data_full, data_out, coord, singleton=coord == 'lon')
# Calculate means
# NOTE: NetCDF data is in 32-bit for storage concerns, but always carry out
# math operations in 64-bit!
zmass = vertical_mass(data_full)
for name, var in data_full.variables.items():
if var.ndim < 3:
continue
data = var[:].astype('d')
mean = zonal_mean(data, zmass)
make_variable(data_out, name, mean,
**{attr: getattr(var, attr)
for attr in var.ncattrs()})
timer(f' * Time for zonal mean of {name!r}')
return data_out
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images)
labels = make_variable(labels).squeeze_()
preds = classifier(encoder(images))
loss += criterion(preds, labels).item()
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).cpu().sum().item()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {}, Avg Accuracy = {:2%}".format(loss, acc))
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
# loss = 0
# acc = 0
loss1 = 0
loss2 = 0
loss3 = 0
acc1 = 0
acc2 = 0
acc3 = 0
# set loss function
# criterion = nn.CrossEntropyLoss()
#my
criterion = nn.MSELoss(reduce=True, size_average=True)
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True) #为True表示不需要反向传播
labels = make_variable(labels) #.squeeze_()
# print('标签：',labels)
preds = classifier(encoder(images))
# print('预测值是：',preds)
# loss += criterion(preds, labels).item()
# print('loss:',loss)
loss1 += criterion(preds[:, 0], labels[:, 0]).item()
loss2 += criterion(preds[:, 1], labels[:, 1]).item()
loss3 += criterion(preds[:, 2], labels[:, 2]).item()
# pred_cls = preds.data.max(1)[1]
# acc += pred_cls.eq(labels.data).cpu().sum()
# acc += ((preds - labels) ** 2).cpu().sum()
# print('acc:',acc)
acc1 += ((preds[:, 0] - labels[:, 0])**2).cpu().sum()
acc2 += ((preds[:, 1] - labels[:, 1])**2).cpu().sum()
acc3 += ((preds[:, 2] - labels[:, 2])**2).cpu().sum()
# loss /= len(data_loader)
# acc /= len(data_loader.dataset)
loss1 /= len(data_loader)
loss2 /= len(data_loader)
loss3 /= len(data_loader)
acc1 /= len(data_loader.dataset)
acc2 /= len(data_loader.dataset)
acc3 /= len(data_loader.dataset)
# print("Avg Loss = {}, Avg Accuracy = {}".format(loss, acc**0.5))
print('Avg loss1: {}, Avg loss2: {}, Avg loss3: {}'.format(
loss1, loss2, loss3))
print('Avg Acc1: {}, Avg Acc2: {}, Avg Acc3: {}'.format(acc1, acc2, acc3))
def eval_src(encoder, classifier, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
encoder.eval() #eval验证模式不启用Dropout和BatchNormalization
classifier.eval()
# init loss and accuracy
# loss = 0
# acc = 0
loss_1 = 0
loss_2 = 0
loss_3 = 0
acc1 = 0
acc2 = 0
acc3 = 0
#my
criterion = nn.MSELoss()
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels)
# print('标签：',labels)
# print('标签：',labels.shape)
preds = classifier(encoder(images)) #.squeeze()
# print('预测值是：',preds.shape)
# print('预测值是：',preds)
# loss += criterion(preds, labels).item() #data[0]6
loss_1 += criterion(preds[:, 0], labels[:, 0]).item()
loss_2 += criterion(preds[:, 1], labels[:, 1]).item()
loss_3 += criterion(preds[:, 2], labels[:, 2]).item()
# pred_cls = preds.data.max(1)[1] #返回每一行最大值所在的索引(我的不需要，因为分类器（即我的回归器)直接输出一个结果)
# acc += pred_cls.eq(labels.data).cpu().sum()
# acc += ((preds - labels) ** 2).cpu().sum()
acc1 += ((preds[:, 0] - labels[:, 0])**2).cpu().sum()
acc2 += ((preds[:, 1] - labels[:, 1])**2).cpu().sum()
acc3 += ((preds[:, 2] - labels[:, 2])**2).cpu().sum()
# loss /= len(data_loader)
# acc /= len(data_loader.dataset)
loss_1 /= len(data_loader)
loss_2 /= len(data_loader)
loss_3 /= len(data_loader)
acc1 /= len(data_loader.dataset)
acc2 /= len(data_loader.dataset)
acc3 /= len(data_loader.dataset)
# print("Avg Loss = {}, Avg Accuracy = {}".format(loss, acc))
print('Avg loss1: {}, Avg loss2: {}, Avg loss3: {}'.format(
loss_1, loss_2, loss_3))
print('Avg Acc1: {}, Avg Acc2: {}, Avg Acc3: {}'.format(acc1, acc2, acc3))
def train_src(model, params, data_loader):
"""Train classifier for source domain."""
####################
# 1. setup network #
####################
# set train state for Dropout and BN layers
model.train()
# setup criterion and optimizer
optimizer = optim.Adam(model.parameters(), lr=params.lr)
loss_class = nn.NLLLoss()
####################
# 2. train network #
####################
for epoch in range(params.num_epochs_src):
for step, (images, labels) in enumerate(data_loader):
# make images and labels variable
images = make_variable(images)
labels = make_variable(labels.squeeze_())
# zero gradients for optimizer
optimizer.zero_grad()
# compute loss for critic
preds = model(images)
loss = loss_class(preds, labels)
# optimize source classifier
loss.backward()
optimizer.step()
# print step info
if ((step + 1) % params.log_step_src == 0):
print("Epoch [{}/{}] Step [{}/{}]: loss={}".format(
epoch + 1, params.num_epochs_src, step + 1,
len(data_loader), loss.data[0]))
# eval model on test set
if ((epoch + 1) % params.eval_step_src == 0):
eval_src(model, data_loader)
model.train()
# save model parameters
if ((epoch + 1) % params.save_step_src == 0):
save_model(
model, params.src_dataset +
"-source-classifier-{}.pt".format(epoch + 1))
# save final model
save_model(model, params.src_dataset + "-source-classifier-final.pt")
return model
def train_src( source_encoder, source_classifier, data_loader ):
source_encoder.train()
source_classifier.train()
optimizer = optim.Adam(
list(source_encoder.parameters()) + list(source_classifier.parameters()))#,
# lr = params.c_learning_rate,
# betas = ( params.beta1, params.beta2 )
# )
criterion = nn.CrossEntropyLoss()
for epoch in range( params.num_epochs_pre ):
for step, ( images, lables ) in enumerate( data_loader ):
images = make_variable(images)
lables = make_variable( lables.squeeze_() )
optimizer.zero_grad()
preds = source_classifier( source_encoder( images ) )
loss = criterion( preds, lables )
loss.backward()
optimizer.step()
# print step info
if ((step + 1) % params.log_step_pre == 0):
print("Epoch [{}/{}] Step [{}/{}]: loss={}"
.format(epoch + 1,
params.num_epochs_pre,
step + 1,
len(data_loader),
loss.data.item()))
# eval model on test set
if ((epoch + 1) % params.eval_step_pre == 0):
eval_src(source_encoder, source_classifier, data_loader)
# save model parameters
if ((epoch + 1) % params.save_step_pre == 0):
save_model(source_encoder, "ADDA-source-encoder-{}.pt".format(epoch + 1))
save_model(
source_classifier, "ADDA-source-classifier-{}.pt".format(epoch + 1))
# # save final model
save_model(source_encoder, "ADDA-source-encoder-final.pt")
save_model(source_classifier, "ADDA-source-classifier-final.pt")
return source_encoder, source_classifier
def eval_src(encoder, classifier, val_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
val_loss = 0.0
val_acc_top1 = 0
val_acc_top5 = 0
correct_labels_top1 = []
incorrect_labels_top1 = []
correct_labels_top5 = []
incorrect_labels_top5 = []
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
with torch.no_grad():
for (x_val, y_val) in val_loader:
x_val = make_variable(x_val)
y_val = make_variable(y_val)
labels = y_val[:, 0]
labels = labels.long()
# print(x_val.shape)
# print(y_val.shape)
output = classifier(encoder(x_val))
loss = criterion(output, labels)
val_loss += loss.item() * x_val.size(0)
_, pred_top5 = output.topk(k=5, dim=1)
y_val = y_val.cpu().detach().numpy()
for i in range(x_val.shape[0]):
if labels[i] in pred_top5[i]:
val_acc_top5 += 1
correct_labels_top5.append(y_val[i])
if labels[i] == pred_top5[i, 0]:
val_acc_top1 += 1
correct_labels_top1.append(y_val[i])
else:
incorrect_labels_top1.append(y_val[i])
else:
incorrect_labels_top1.append(y_val[i])
incorrect_labels_top5.append(y_val[i])
val_loss = val_loss / len(val_loader.dataset)
val_acc_top1 = val_acc_top1 / len(val_loader.dataset)
val_acc_top5 = val_acc_top5 / len(val_loader.dataset)
print(
"Avg Val Loss = {}, Avg top1 val Accuracy = {:2%}, avg top val accuracy = {:2%}"
.format(val_loss, val_acc_top1, val_acc_top5))
return val_acc_top5
def train(classifier, data_loader):
"""Train classifier for source domain."""
####################
# 1. setup network #
####################
# set train state for Dropout and BN layers
classifier.train()
# setup criterion and optimizer
optimizer = optim.Adam(list(classifier.parameters()),
lr=params.c_learning_rate,
betas=(params.beta1, params.beta2))
#criterion = nn.CrossEntropyLoss(weights=tf.convert_to_tensor([1, 300]))
criterion = nn.CrossEntropyLoss()
####################
# 2. train network #
####################
for epoch in range(params.num_epochs_pre):
for step, (images, labels) in enumerate(data_loader):
# make images and labels variable
images = make_variable(images)
labels = make_variable(labels.squeeze_())
# zero gradients for optimizer
optimizer.zero_grad()
# compute loss for critic
preds = classifier(images)
loss = criterion(preds, labels)
# optimize source classifier
loss.backward()
optimizer.step()
# print step info
if ((step + 1) % params.log_step_pre == 0):
print("Epoch [{}/{}] Step [{}/{}]: loss={}".format(
epoch + 1, params.num_epochs_pre, step + 1,
len(data_loader), loss.data))
# eval model on test set
if ((epoch + 1) % params.eval_step_pre == 0):
eval(classifier, data_loader)
return classifier
def _prepare_sample(self, sample, volatile, cuda):
self._sample = {
'index':
make_variable(sample['index'], cuda=False, volatile=volatile),
'feature':
make_variable(sample['feature'], cuda=cuda, volatile=volatile),
'position':
make_variable(sample['position'], cuda=cuda, volatile=volatile),
'target':
make_variable(sample['target'], cuda=cuda,
volatile=volatile).view(-1),
'size':
len(sample['index']),
'mask':
make_variable(sample['mask'], cuda=cuda, volatile=volatile),
}
def eval_tgt_hw(encoder, classifier, data_loader, csv_output_path):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
file_namelist = []
predlist = []
# evaluate network
for (images, filename) in data_loader:
images = make_variable(images, volatile=True)
tgt_feature = encoder(images)
preds = classifier(tgt_feature)
pred_cls = preds.data.max(1)[1]
files = []
preds = []
for j in filename:
files.append(j)
for i in pred_cls:
preds.append(i.item())
file_namelist += files
predlist += preds
dataframe = pd.DataFrame({'image_name': file_namelist, 'label': predlist})
dataframe.to_csv("{}".format(csv_output_path), index=False, sep=',')
print("PREDICT OKOKOK")
def generate_batched_itr(self, data_itr, beam_size=None, maxlen_a=0.0, maxlen_b=None, cuda=False):
"""Iterate over a batched dataset and yield individual translations.
Args:
maxlen_a/b: generate sequences of maximum length ax + b,
where x is the source sentence length.
cuda: use GPU for generation
"""
if maxlen_b is None:
maxlen_b = self.maxlen
for sample in data_itr:
s = utils.make_variable(sample, cuda=cuda)
input = s['net_input']
srclen = input['src_tokens'].size(1)
with torch.no_grad():
hypos = self.generate(
input['src_tokens'],
input['src_lengths'],
beam_size=beam_size,
maxlen=int(maxlen_a*srclen + maxlen_b)
)
for i, id in enumerate(s['id'].data):
src = input['src_tokens'].data[i, :]
# remove padding from ref
ref = utils.strip_pad(s['target'].data[i, :], self.pad)
yield id, src, ref, hypos[i]
def get_distribution(src_encoder, tgt_encoder, src_classifier, tgt_classifier,
critic, data_loader, which_data_loader):
print(
"Start calculating the mahalanobis distances' mean and standard deviation ... "
)
vectors = []
for (images, labels) in data_loader:
images = make_variable(images, volatile=True).squeeze_()
labels = make_variable(labels).squeeze_()
torch.no_grad()
src_preds = src_classifier(torch.squeeze(
src_encoder(images))).detach().cpu().numpy()
tgt_preds = tgt_classifier(torch.squeeze(
tgt_encoder(images))).detach().cpu().numpy()
critic_at_src = critic(torch.squeeze(
src_encoder(images))).detach().cpu().numpy()
critic_at_tgt = critic(torch.squeeze(
tgt_encoder(images))).detach().cpu().numpy()
for image, label, src_pred, tgt_pred, src_critic, tgt_critic \
in zip(images, labels, src_preds, tgt_preds, critic_at_src, critic_at_tgt):
vectors.append(
np.linalg.norm(src_critic.tolist() + tgt_critic.tolist()))
#print('processing vector ' + str(src_critic.tolist() + tgt_critic.tolist()))
mean = np.asarray(vectors).mean(axis=0)
cov = np.cov(vectors)
try:
iv = np.linalg.inv(cov)
except:
iv = cov
mahalanobis = np.asarray(
[distance.mahalanobis(v, mean, iv) for v in vectors])
mahalanobis_mean = np.mean(mahalanobis)
mahalanobis_std = np.std(mahalanobis)
np.save('snapshots//' + which_data_loader + '_mahalanobis_mean.npy',
mahalanobis_mean)
np.save('snapshots//' + which_data_loader + '_mahalanobis_std.npy',
mahalanobis_std)
np.save('snapshots//' + which_data_loader + '_iv.npy', iv)
np.save('snapshots//' + which_data_loader + '_mean.npy', mean)
print(
"Finished obtaining the mahalanobis distances' mean and standard deviation on "
+ which_data_loader)
return mahalanobis_mean, mahalanobis_std, iv, mean
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
f1 = 0
# set loss function
criterion = nn.CrossEntropyLoss()
flag = False
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels).squeeze_()
preds = classifier(encoder(images))
loss += criterion(preds,
labels).data # criterion is cross entropy loss
pred_cls = preds.data.max(1)[1]
#f1 += get_f1(pred_cls, labels.data, average='macro')
acc += pred_cls.eq(labels.data).cpu().sum()
if not flag:
ys_pred = pred_cls
ys_true = labels
flag = True
else:
ys_pred = torch.cat((ys_pred, pred_cls), 0)
ys_true = torch.cat((ys_true, labels), 0)
loss = loss.float()
acc = acc.float()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
#f1 /= len(data_loader.dataset)
f1 = get_f1(ys_pred, ys_true, 'macro')
f1_weighted = get_f1(ys_pred, ys_true, 'weighted')
print("Avg Loss = {}, F1 = {:2%}, Weighted F1 = {:2%}".format(
loss, f1, f1_weighted))
def eval_tgt_with_probe(encoder, critic, src_classifier, tgt_classifier,
data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
src_classifier.eval()
tgt_classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
f1 = 0
ys_pred = []
ys_true = []
# set loss function
criterion = nn.CrossEntropyLoss()
flag = False
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels).squeeze_()
probeds = critic(encoder(images))
for image, label, probed in zip(images, labels, probeds):
if torch.argmax(probed) == 1:
pred = torch.argmax(
src_classifier(encoder(torch.unsqueeze(
image, 0)))).detach().cpu().numpy()
else:
pred = torch.argmax(
tgt_classifier(encoder(torch.unsqueeze(
image, 0)))).detach().cpu().numpy()
ys_pred.append(np.squeeze(pred))
ys_true.append(np.squeeze(label.detach().cpu().numpy()))
loss /= len(data_loader)
acc /= len(data_loader.dataset)
#f1 /= len(data_loader.dataset)
f1 = get_f1(ys_pred, ys_true, 'macro')
f1_weighted = get_f1(ys_pred, ys_true, 'weighted')
print("Avg Loss = {}, F1 = {:2%}, Weighted F1 = {:2%}".format(
loss, f1, f1_weighted))
def get_distribution(data_loader):
vectors = []
for (images, labels) in data_loader:
images = make_variable(images, volatile=True).detach().cpu().numpy()
labels = make_variable(labels).detach().cpu().numpy()
vectors.append(np.linalg.norm(images))
mean = np.mean(vectors)
inv = np.cov(vectors)
m_dists = [(x - mean) * inv * (x - mean) for x in vectors]
m_mean = np.mean(m_dists)
m_std = np.std(m_dists)
return mean, inv, m_mean, m_std
def make_variables(sample, sample_spec, phase="train"):
""" Creates the Torch variables for a sample """
inputs = sample_spec.get_inputs()
labels = sample_spec.get_labels()
masks = sample_spec.get_masks()
if phase == "train":
input_vars = [utils.make_variable(sample[k], True) for k in inputs]
elif phase == "test":
input_vars = [
utils.make_variable(sample[k], volatile=True) for k in inputs
]
label_vars = [utils.make_variable(sample[k], False) for k in labels]
mask_vars = [utils.make_variable(sample[k], False) for k in masks]
return input_vars, label_vars, mask_vars
def eval_tgt(encoder, classifier, data_loader):
"""Evaluation for target encoder by source classifier on target dataset."""
# set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
# init loss and accuracy
loss = 0.0
acc_top5 = 0.0
acc_top1 = 0.0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
with torch.no_grad():
for (images, y) in data_loader:
images = make_variable(images)
y = make_variable(y)
labels = y[:, 0]
labels = labels.long()
output = classifier(encoder(images))
loss += criterion(output, labels).item()
_, pred_top5 = output.topk(k=5, dim=1)
pred_top5 = pred_top5.t()
correct_top5 = pred_top5.eq(
labels.view(1, -1).expand_as(pred_top5))
# top-5 Accuracy
acc_top5 += correct_top5[:5].view(-1).float().sum(0, keepdim=True)
# top-1 Accuracy
acc_top1 += correct_top5[:1].view(-1).float().sum(0, keepdim=True)
# pred_cls = preds.max(1)[1]
# acc += pred_cls.eq(labels.data).cpu().sum()
# loss /= 1.0*len(data_loader)
# acc /= 1.0*len(data_loader.dataset)
loss = loss / len(data_loader.dataset)
acc_top1 = acc_top1 / len(data_loader.dataset)
acc_top5 = acc_top5 / len(data_loader.dataset)
print(loss)
print(acc_top5)
print(acc_top1)
def optimize_model(self, adapt, inputs, target, alpha):
"""
Updates the parameters of the main model
:param adapt: if True, uses synthetetic gradients for updates, else does standard backprop
:param inputs: images
:param target: labels
:param model_optimizer: Pytorch optimizer for the main network
:param forward: forward function of the main model
"""
batch_size = len(target)
# Zero the parameter gradients
self.model.optimizer_F.zero_grad()
self.model.optimizer_F_src.zero_grad()
self.model.optimizer_F_tar.zero_grad()
self.model.optimizer_D.zero_grad()
self.model.optimizer_S.zero_grad()
# Forward classification model
x_src, x_tar, d, g = self.model.forward(inputs, alpha)
_, preds_src = torch.max(x_src.data, 1)
_, preds_tar = torch.max(x_tar.data, 1)
_, preds_d = torch.max(d.data, 1)
value_g, preds_g = torch.max(g.data, 1)
if adapt:
domain_label = torch.ones(batch_size)
equal_idx = (torch.eq(
utils.make_variable(torch.zeros(batch_size)).long().data,
preds_d))
conf_idx = (value_g > np.log(self.tau))
adapt_idx = torch.nonzero(equal_idx & conf_idx).squeeze()
loss_F_src = utils.make_variable(torch.zeros(1))
loss_F_tar = utils.make_variable(torch.zeros(1))
loss_syn = utils.make_variable(torch.zeros(1))
if len(adapt_idx.size()) > 0:
#loss_F_src = self.model_loss(x_src[adapt_idx, :], utils.make_variable(preds_g[adapt_idx]))
loss_F_tar = self.model_loss(
x_tar[adapt_idx, :],
utils.make_variable(preds_g[adapt_idx]))
#loss_syn = self.model_loss(g[adapt_idx, :], utils.make_variable(preds_g[adapt_idx]))
else:
domain_label = torch.zeros(batch_size)
loss_F_src = self.model_loss(x_src, target)
loss_F_tar = utils.make_variable(torch.zeros(1))
loss_syn = self.model_loss(g, target)
loss_D = self.domain_loss(d, utils.make_variable(domain_label.long()))
loss_F = loss_F_src + loss_F_tar + loss_D + self.beta * loss_syn
loss_F.backward()
# Step main optimizers
self.model.optimizer_F.step()
self.model.optimizer_F_src.step()
self.model.optimizer_F_tar.step()
self.model.optimizer_D.step()
self.model.optimizer_S.step()
return loss_F_src, loss_F_tar, loss_D, loss_syn, preds_src, preds_tar, preds_d, preds_g
def eval(classifier, data_loader):
"""Evaluate classifier for source domain."""
# set eval state for Dropout and BN layers
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
f1 = 0
# set loss function
criterion = nn.CrossEntropyLoss()
flag = False
# evaluate network
for (images, labels) in data_loader:
images = make_variable(images, volatile=True)
labels = make_variable(labels)
preds = classifier(images)
loss += criterion(preds, labels).data
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).cpu().sum()
if not flag:
ys_pred = pred_cls
ys_true = labels
flag = True
else:
ys_pred = torch.cat((ys_pred, pred_cls), 0)
ys_true = torch.cat((ys_true, labels), 0)
loss = loss.float()
acc = acc.float()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
#f1 /= len(data_loader.dataset)
f1 = get_f1(ys_pred, ys_true, 'weighted')
#f1_weighted = get_f1(ys_pred, ys_true, 'weighted')
print("Avg Loss = {}, F1 = {:2%}, accuracy = {:2%}".format(loss, f1, acc))
