def test(model, data_loader, criterion, posp, max_fpr):
model.eval()
targets, predicts = list(), list()
loss = Averager()
posp = torch.FloatTensor([posp]).cuda()
one = torch.FloatTensor([1]).cuda()
with torch.no_grad():
for j, (ids, values, seqlength, label,
seq_mask) in enumerate(data_loader):
ids, values = ids.cuda(), values.cuda()
label = label.cuda().float()
seq_mask = seq_mask.cuda()
y, _ = model(ids, values, seqlength, seq_mask, 'tgt')
p = posp * label + (one - posp) * (one - label)
loss.add(torch.mean(p * criterion(y, label)).item())
targets.extend(label.tolist())
predicts.extend(y.tolist())
model.train()
return roc_auc_score(targets, predicts,
max_fpr=max_fpr), loss.item(), roc_auc_score(
targets, predicts)
sorted=True)
p = cfg.progalambda * (allExtraproto[topkindex] * topsim.unsqueeze(2).expand(cfg.way, cfg.topk, 1600)).sum(dim=1)/cfg.topk \
+ (1 - cfg.progalambda) * proto
else:
p = proto
logits = euclidean_metric(model(data_query), p)
label = torch.arange(cfg.way).repeat(cfg.query)
label = label.type(torch.cuda.LongTensor)
acc = count_acc(logits, label)
ave_acc.add(acc)
print('batch {}: {:.2f}({:.2f})'.format(i,
ave_acc.item() * 100,
acc * 100))
allacc.append(acc)
x = None
p = None
logits = None
allacc = np.array(allacc)
torch.save(allacc, cfg.result + '/allacc')
mean, std, conf_intveral = CI(allacc)
result = "mean: " + str(mean) + "\nstd: " + str(
std) + "\nconfidence intveral: [" + str(
print('epoch {}, train {}/{}, loss={:.4f} acc={:.4f}'.format(
epoch, i, len(train_loader), loss.item(), acc))
tl.add(loss.item())
ta.add(acc)
optimizer.zero_grad()
loss.backward()
optimizer.step()
p = None
proto = None
logits = None
loss = None
tl = tl.item()
ta = ta.item()
torch.cuda.empty_cache()
model.eval()
vl = Averager()
va = Averager()
if cfg.progalambda > 0:
with torch.no_grad():
n = 500
allExtraproto = []
index = torch.randperm(
allExtraData.shape[0])[:int(allExtraData.shape[0] / 10)]
extraDatatemp = allExtraData[index]
def train(model,
optimizer,
src_loader,
tgt_loader,
valid_loader,
criterion,
log_interval=1000,
val_interval=50,
posp=1,
nagp=0.5,
params_cls=0.5,
params_da=0.5,
da_type='cmmd',
max_fpr=0.01):
global max_auc
global max_auchead
global min_loss
posp = torch.FloatTensor([posp]).cuda()
nagp = torch.FloatTensor([nagp]).cuda()
one = torch.FloatTensor([1]).cuda()
iter_src = iter(src_loader)
iter_tgt = iter(tgt_loader)
num_iter = len(src_loader)
stoper = Stoper()
avg_all_loss = Averager()
avg_src_loss = Averager()
avg_tgt_loss = Averager()
avg_da_loss = Averager()
start_time = time.time()
for i in range(1, num_iter * 20):
model.train()
src_ids, src_values, src_seqlength, src_label, src_seq_mask = iter_src.next(
)
src_ids, src_values, src_label = src_ids.cuda(), src_values.cuda(
), src_label.cuda().float()
src_seq_mask = src_seq_mask.cuda()
if i % len(src_loader) == 0:
iter_src = iter(src_loader)
if i % len(tgt_loader) == 0:
iter_tgt = iter(tgt_loader)
src_p = posp * src_label + nagp * (one - src_label)
src_y, src_fea_LSTM = model(src_ids, src_values, src_seqlength,
src_seq_mask, 'src')
src_loss = torch.mean(
src_p * criterion(src_y, src_label)
) # + torch.mean(src_p * criterion(src_spey, src_label))
tgt_ids, tgt_values, tgt_seqlength, tgt_label, tgt_seq_mask = iter_tgt.next(
)
tgt_ids, tgt_values, tgt_label = tgt_ids.cuda(), tgt_values.cuda(
), tgt_label.cuda().float()
tgt_seq_mask = tgt_seq_mask.cuda()
# print(tgt_seqlength, tgt_label)
tgt_p = posp * tgt_label + nagp * (one - tgt_label)
tgt_y, tgt_fea_LSTM, tgt_spey = model(tgt_ids, tgt_values,
tgt_seqlength, tgt_seq_mask,
'tgt')
tgt_loss = torch.mean(
tgt_p * criterion(tgt_y, tgt_label)
) # + 0.5 * torch.mean(tgt_p * criterion(tgt_spey, tgt_label))
if da_type == 'cmmd':
da_loss = cmmd(src_fea_LSTM, tgt_fea_LSTM, src_label.long(),
tgt_label.long())
elif da_type == 'mmd':
da_loss = mmd_rbf_noaccelerate(src_fea_LSTM, tgt_fea_LSTM)
elif da_type == 'coral':
da_loss = coral(src_fea_LSTM, tgt_fea_LSTM)
elif da_type == 'euclidian':
da_loss = euclidian(src_fea_LSTM, tgt_fea_LSTM)
elif da_type == 'c_euclidian':
da_loss = c_euclidian(src_fea_LSTM, tgt_fea_LSTM, src_label.long(),
tgt_label.long())
elif da_type == 'nometric':
da_loss = nometric(src_fea_LSTM, tgt_fea_LSTM)
elif da_type == 'ced':
da_loss = ced(src_fea_LSTM, tgt_fea_LSTM, src_label.long(),
tgt_label.long())
lambd = 2 / (1 + math.exp((-5 * i) / (len(src_loader)))) - 1
loss = params_cls * src_loss + tgt_loss + params_da * lambd * da_loss
model.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
avg_all_loss.add(loss.item())
avg_src_loss.add(src_loss.item())
avg_tgt_loss.add(tgt_loss.item())
avg_da_loss.add(da_loss.item())
if (i + 1) % log_interval == 0:
print(
'step: {}, loss: {:.4f}, src_loss: {:.4f}, tgt_loss: {:.4f}, {}_loss:, {:.4f}, lambda: {}'
.format(i + 1, avg_all_loss.item(), avg_src_loss.item(),
avg_tgt_loss.item(), da_type, avg_da_loss.item(),
lambd))
avg_all_loss = Averager()
avg_src_loss = Averager()
avg_tgt_loss = Averager()
avg_da_loss = Averager()
if (i + 1) % val_interval == 0:
end_time = time.time()
print('train time (s):', end_time - start_time)
start_time = time.time()
auc_head, loss, auc = test(model, valid_loader, criterion, posp,
max_fpr)
if loss < min_loss:
min_loss = loss
if auc > max_auc:
max_auc = auc
if auc_head > max_auchead:
torch.save(model, f'{save_dir}/tmp.pt')
max_auchead = auc_head
print(
'dev --- auchead: {:.4f}, max_auchead: {:.4f}, auc: {:.4f}, max_auc: {:.4f}, loss: {:.4f}, minloss: {:.4f}'
.format(auc_head, max_auchead, auc, max_auc, loss, min_loss))
end_time = time.time()
print('dev time (s):', end_time - start_time)
start_time = time.time()
if stoper.add(auc_head):
print('training end')
break