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))