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