def transformation_cifar10_vs_tinyimagenet(): _, (x_test, y_test) = load_cifar10() x_test_out = load_tinyimagenet('/home/izikgo/Imagenet_resize/Imagenet_resize/') transformer = Transformer(8, 8) n = 16 k = 8 base_mdl = create_wide_residual_network(x_test.shape[1:], 10, n, k) transformations_cls_out = Activation('softmax')(dense(transformer.n_transforms)(base_mdl.get_layer(index=-3).output)) mdl = Model(base_mdl.input, [base_mdl.output, transformations_cls_out]) mdl.load_weights('cifar10_WRN_doublehead-transformations_{}-{}.h5'.format(n, k)) scores_mdl = Model(mdl.input, mdl.output[1]) x_test_all = np.concatenate((x_test, x_test_out)) preds = np.zeros((len(x_test_all), transformer.n_transforms)) for t in range(transformer.n_transforms): preds[:, t] = scores_mdl.predict(transformer.transform_batch(x_test_all, [t] * len(x_test_all)), batch_size=128)[:, t] labels = np.concatenate((np.ones(len(x_test)), np.zeros(len(x_test_out)))) scores = preds.mean(axis=-1) save_roc_pr_curve_data(scores, labels, 'cifar10-vs-tinyimagenet_transformations.npz')
def osoc_test(hyper_para): transformer = Transformer(8, 8) C = wrn.WideResNet(28, num_classes=10, dropout_rate=0, widen_factor=10).cuda() C.load_state_dict(torch.load(hyper_para.experiment_name + '.pth')) single_class_ind = hyper_para.inclass[0] (x_train, y_train), (x_test, y_test) = load_cifar10() C.eval() score = [] lbl = [] features = [] correct = 0 total = 0 dset = CustomDataset(x_test, y_test) testLoader = DataLoader(dset, batch_size=128) for i, (inputs0, labels) in enumerate(testLoader): inputs = inputs0.permute(0, 3, 2, 1) if hyper_para.gpu: inputs = inputs.cuda() labels = labels.cuda() act, f = C(inputs) features += f.detach().cpu().tolist() val, ind = torch.max(act, dim=1) #score += val.detach().cpu().tolist() CC = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() val, ind, labels = (val.detach().cpu().tolist(), ind.detach().cpu().tolist(), labels.detach().cpu().tolist()) for ind, (ii, gt) in enumerate(zip(ind, labels)): gt = gt[0] CC.load_state_dict( torch.load('saved/' + hyper_para.experiment_name + '_' + str(gt) + '.pth')) x_test0 = transformer.transform_batch( np.expand_dims(inputs0[ind, :, :, :].detach().cpu().numpy(), 0), [0]) x_test0 = torch.tensor(x_test0).permute(0, 3, 2, 1).cuda() act, f = CC(x_test0) act = act.detach().cpu().tolist() score += [act[0][0]] if gt in hyper_para.inclass: total += 1 if ii == gt: correct += 1 lbl.append(1) else: lbl.append(0) break fpr, tpr, thresholds = metrics.roc_curve(lbl, score) AUC = metrics.auc(fpr, tpr) ACC = float(correct) / total print('AUROC: ' + str(AUC) + '\t Accuracy: ' + str(ACC))
class RotateDataset(Dataset): def __init__(self, x_tensor): self.x = x_tensor self.transformer = Transformer(8, 8) def __getitem__(self, index): trans_id = np.random.randint(self.transformer.n_transforms, size=1)[0] #return(self.transformer.transform_sample(self.x[index], trans_id), trans_id) return ((self.transformer.transform_batch( np.expand_dims(self.x[index], 0), [trans_id]))[0], trans_id) def __len__(self): return len(self.x)
class RotateDataset(Dataset): def __init__(self, x_tensor, lbl): self.x = x_tensor self.y = lbl self.perm = np.random.permutation(len(x_tensor)) self.transformer = Transformer(8, 8) def __getitem__(self, index): index = self.perm[index] trans_id = np.random.randint(self.transformer.n_transforms, size=1)[0] #return(self.transformer.transform_sample(self.x[index], trans_id), trans_id) return ((self.transformer.transform_batch( np.expand_dims(self.x[index], 0), [trans_id]))[0], trans_id, self.y[index]) def __len__(self): return len(self.x)
def os_test_ens(testLoader, hyper_para, C, isauc): C = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() C.load_state_dict( torch.load('saved/' + hyper_para.experiment_name + '_' + str(hyper_para.inclass[0]) + '.pth')) single_class_ind = hyper_para.inclass[0] (x_train, y_train), (x_test, y_test) = load_cifar10() transformer = Transformer(8, 8) glabels = y_test.flatten() == single_class_ind C.cuda().eval() scores = np.array([[]]) features = [] correct = 0 total = 0 preds = np.zeros((len(x_test), transformer.n_transforms)) for t in [0]: #range(72): score = [] x_test0 = transformer.transform_batch(x_test, [t] * len(x_test)) dset = CustomDataset(x_test0, [t] * len(x_test)) testLoader = DataLoader(dset, batch_size=128, shuffle=False) for i, (inputs, labels) in enumerate(testLoader): inputs = inputs.permute(0, 3, 2, 1) if True: inputs = inputs.cuda() labels = labels.cuda() act, f = C(inputs) features += f.detach().cpu().tolist() #act = torch.nn.functional.softmax(act, dim=1) score += act[:, t].detach().cpu().tolist() preds[:, t] = list(score) fpr, tpr, thresholds = metrics.roc_curve(glabels, score) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) scores = np.sum(((preds)), 1) fpr, tpr, thresholds = metrics.roc_curve(glabels, scores) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) return ([0, 0])
def _transformations_experiment(dataset_load_fn, dataset_name, single_class_ind, gpu_q): gpu_to_use = gpu_q.get() os.environ["CUDA_VISIBLE_DEVICES"] = gpu_to_use (x_train, y_train), (x_test, y_test) = dataset_load_fn() if dataset_name in ['cats-vs-dogs']: transformer = Transformer(16, 16) n, k = (16, 8) else: transformer = Transformer(8, 8) n, k = (10, 4) mdl = create_wide_residual_network(x_train.shape[1:], transformer.n_transforms, n, k) mdl.compile('adam', 'categorical_crossentropy', ['acc']) x_train_task = x_train[y_train.flatten() == single_class_ind] transformations_inds = np.tile(np.arange(transformer.n_transforms), len(x_train_task)) x_train_task_transformed = transformer.transform_batch(np.repeat(x_train_task, transformer.n_transforms, axis=0), transformations_inds) batch_size = 128 mdl.fit(x=x_train_task_transformed, y=to_categorical(transformations_inds), batch_size=batch_size, epochs=int(np.ceil(200/transformer.n_transforms)) ) ################################################################################################# # simplified normality score ################################################################################################# # preds = np.zeros((len(x_test), transformer.n_transforms)) # for t in range(transformer.n_transforms): # preds[:, t] = mdl.predict(transformer.transform_batch(x_test, [t] * len(x_test)), # batch_size=batch_size)[:, t] # # labels = y_test.flatten() == single_class_ind # scores = preds.mean(axis=-1) ################################################################################################# def calc_approx_alpha_sum(observations): N = len(observations) f = np.mean(observations, axis=0) return (N * (len(f) - 1) * (-psi(1))) / ( N * np.sum(f * np.log(f)) - np.sum(f * np.sum(np.log(observations), axis=0))) def inv_psi(y, iters=5): # initial estimate cond = y >= -2.22 x = cond * (np.exp(y) + 0.5) + (1 - cond) * -1 / (y - psi(1)) for _ in range(iters): x = x - (psi(x) - y) / polygamma(1, x) return x def fixed_point_dirichlet_mle(alpha_init, log_p_hat, max_iter=1000): alpha_new = alpha_old = alpha_init for _ in range(max_iter): alpha_new = inv_psi(psi(np.sum(alpha_old)) + log_p_hat) if np.sqrt(np.sum((alpha_old - alpha_new) ** 2)) < 1e-9: break alpha_old = alpha_new return alpha_new def dirichlet_normality_score(alpha, p): return np.sum((alpha - 1) * np.log(p), axis=-1) scores = np.zeros((len(x_test),)) observed_data = x_train_task for t_ind in range(transformer.n_transforms): observed_dirichlet = mdl.predict(transformer.transform_batch(observed_data, [t_ind] * len(observed_data)), batch_size=1024) log_p_hat_train = np.log(observed_dirichlet).mean(axis=0) alpha_sum_approx = calc_approx_alpha_sum(observed_dirichlet) alpha_0 = observed_dirichlet.mean(axis=0) * alpha_sum_approx mle_alpha_t = fixed_point_dirichlet_mle(alpha_0, log_p_hat_train) x_test_p = mdl.predict(transformer.transform_batch(x_test, [t_ind] * len(x_test)), batch_size=1024) scores += dirichlet_normality_score(mle_alpha_t, x_test_p) scores /= transformer.n_transforms labels = y_test.flatten() == single_class_ind res_file_name = '{}_transformations_{}_{}.npz'.format(dataset_name, get_class_name_from_index(single_class_ind, dataset_name), datetime.now().strftime('%Y-%m-%d-%H%M')) res_file_path = os.path.join(RESULTS_DIR, dataset_name, res_file_name) save_roc_pr_curve_data(scores, labels, res_file_path) mdl_weights_name = '{}_transformations_{}_{}_weights.h5'.format(dataset_name, get_class_name_from_index(single_class_ind, dataset_name), datetime.now().strftime('%Y-%m-%d-%H%M')) mdl_weights_path = os.path.join(RESULTS_DIR, dataset_name, mdl_weights_name) mdl.save_weights(mdl_weights_path) gpu_q.put(gpu_to_use)
metrics=['acc']) print(mdl.summary()) # get inliers of specific class x_train_task = x_train[y_train.flatten() == single_class_ind] print(x_train_task.shape) # [0_i, ..., (N_transforms-1)_i, ..., ..., 0_N_samples, ..., # (N_transforms-1)_N_samples] shape: (N_transforms*N_samples,) transformations_inds = np.tile(np.arange(transformer.n_transforms), len(x_train_task)) print(len(transformations_inds)) # start_time = time.time() x_train_task_transformed = transformer.transform_batch( np.repeat(x_train_task, transformer.n_transforms, axis=0), transformations_inds) time_usage = str( datetime.timedelta(seconds=int(round(time.time() - start_time)))) print("Time to perform transforms: " + time_usage) print(x_train_task_transformed.shape) batch_size = 128 start_time = time.time() mdl.fit(x=x_train_task_transformed, y=to_categorical(transformations_inds), batch_size=batch_size, epochs=int(np.ceil(200 / transformer.n_transforms))) time_usage = str( datetime.timedelta(seconds=int(round(time.time() - start_time)))) print("Time to train model: " + time_usage)
def _transformations_experiment(dataset_load_fn, dataset_name, single_class_ind, gpu_q): # gpu_to_use = gpu_q.get() # os.environ["CUDA_VISIBLE_DEVICES"] = gpu_to_use (x_train, y_train), (x_test, y_test) = dataset_load_fn() if dataset_name in ['cats-vs-dogs']: transformer = Transformer(16, 16) n, k = (16, 8) else: transformer = Transformer(8, 8) n, k = (10, 4) mdl = create_wide_residual_network(x_train.shape[1:], transformer.n_transforms, n, k) mdl.compile('adam', 'categorical_crossentropy', ['acc']) # get inliers of specific class x_train_task = x_train[y_train.flatten() == single_class_ind] # [0_i, ..., (N_transforms-1)_i, ..., ..., 0_N_samples, ..., # (N_transforms-1)_N_samples] shape: (N_transforms*N_samples,) transformations_inds = np.tile(np.arange(transformer.n_transforms), len(x_train_task)) x_train_task_transformed = transformer.transform_batch( np.repeat(x_train_task, transformer.n_transforms, axis=0), transformations_inds) batch_size = 128 mdl.fit(x=x_train_task_transformed, y=to_categorical(transformations_inds), batch_size=batch_size, epochs=int(np.ceil(200 / transformer.n_transforms))) scores = np.zeros((len(x_test), )) matrix_evals = np.zeros( (len(x_test), transformer.n_transforms, transformer.n_transforms)) observed_data = x_train_task for t_ind in range(transformer.n_transforms): observed_dirichlet = mdl.predict(transformer.transform_batch( observed_data, [t_ind] * len(observed_data)), batch_size=1024) log_p_hat_train = np.log(observed_dirichlet).mean(axis=0) alpha_sum_approx = calc_approx_alpha_sum(observed_dirichlet) alpha_0 = observed_dirichlet.mean(axis=0) * alpha_sum_approx mle_alpha_t = fixed_point_dirichlet_mle(alpha_0, log_p_hat_train) x_test_p = mdl.predict(transformer.transform_batch( x_test, [t_ind] * len(x_test)), batch_size=1024) matrix_evals[:, :, t_ind] += x_test_p scores += dirichlet_normality_score(mle_alpha_t, x_test_p) scores /= transformer.n_transforms matrix_evals /= transformer.n_transforms scores_simple = np.trace(matrix_evals, axis1=1, axis2=2) scores_entropy = get_entropy(matrix_evals) scores_xH = get_xH(transformer, matrix_evals) labels = y_test.flatten() == single_class_ind save_results_file(dataset_name, single_class_ind, scores=scores, labels=labels, experiment_name='transformations') save_results_file(dataset_name, single_class_ind, scores=scores_simple, labels=labels, experiment_name='transformations-simple') save_results_file(dataset_name, single_class_ind, scores=scores_entropy, labels=labels, experiment_name='transformations-entropy') save_results_file(dataset_name, single_class_ind, scores=scores_xH, labels=labels, experiment_name='transformations-xH') mdl_weights_name = '{}_transformations_{}_{}_weights.h5'.format( dataset_name, get_class_name_from_index(single_class_ind, dataset_name), datetime.datetime.now().strftime('%Y-%m-%d-%H%M')) mdl_weights_path = os.path.join(RESULTS_DIR, dataset_name, mdl_weights_name) mdl.save_weights(mdl_weights_path)
def octest0(hyper_para): C = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() C.load_state_dict( torch.load(hyper_para.experiment_name + '_' + str(hyper_para.inclass[0]) + '.pth')) single_class_ind = hyper_para.inclass[0] if hyper_para.source == 'mnist': (x_train, y_train), (x_test, y_test) = load_mnist() elif hyper_para.source == 'svhn': (x_train, y_train), (x_test, y_test) = load_svhn() elif hyper_para.source == 'amazon': (x_train, y_train), (x_test, y_test) = load_amazon() elif hyper_para.source == 'dslr': (x_train, y_train), (x_test, y_test) = load_dslr() transformer = Transformer(8, 8) glabels = y_test.flatten() == single_class_ind print(hyper_para.source) print(len(x_test)) print(np.sum(glabels)) C.cuda().eval() scores = np.array([[]]) features = [] correct = 0 total = 0 preds = np.zeros((len(x_test), transformer.n_transforms)) for t in range(1): score = [] dset = CustomDataset(x_test, y_test) testLoader = DataLoader(dset, batch_size=128, shuffle=False) transformer = Transformer(8, 8) for i, (inputs, labels) in enumerate(testLoader): inputs = torch.tensor( transformer.transform_batch(inputs.detach().cpu().numpy(), [t] * len(inputs))) inputs = inputs.permute(0, 3, 2, 1) if True: inputs = inputs.cuda() labels = labels.cuda() act, f = C(inputs) features += f.detach().cpu().tolist() #act = torch.nn.functional.softmax(act, dim=1) score += act[:, t].detach().cpu().tolist() preds[:, t] = list(score) fpr, tpr, thresholds = metrics.roc_curve(glabels, score) AUC = metrics.auc(fpr, tpr) #print('AUROC: ' + str(AUC) ) scores = np.sum(((preds)), 1) fpr, tpr, thresholds = metrics.roc_curve(glabels, scores) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) file1 = open("AUC.txt", "a") #append mode file1.write(hyper_para.source + "\t" + hyper_para.method + "\t" + str(hyper_para.inclass[0]) + "\t" + hyper_para.experiment_name + "\t" + str(AUC) + "\n") file1.close() C = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() C.load_state_dict( torch.load(hyper_para.experiment_name + '_' + str(hyper_para.inclass[0]) + '.pth')) single_class_ind = hyper_para.inclass[0] if hyper_para.target == 'mnist': (x_train, y_train), (x_test, y_test) = load_mnist() elif hyper_para.target == 'svhn': (x_train, y_train), (x_test, y_test) = load_svhn() elif hyper_para.target == 'amazon': (x_train, y_train), (sx_test, y_test) = load_amazon() elif hyper_para.target == 'dslr': (x_train, y_train), (x_test, y_test) = load_dslr() transformer = Transformer(8, 8) C.cuda().eval() scores = np.array([[]]) features = [] correct = 0 total = 0 preds = np.zeros((len(x_test) + len(x_train), transformer.n_transforms)) for t in range(1): score = [] dset = CustomDataset(np.concatenate((x_test, x_train), 0), np.concatenate((y_test, y_train), 0)) testLoader = DataLoader(dset, batch_size=128, shuffle=False) transformer = Transformer(8, 8) for i, (inputs, labels) in enumerate(testLoader): inputs = torch.tensor( transformer.transform_batch(inputs.detach().cpu().numpy(), [t] * len(inputs))) inputs = inputs.permute(0, 3, 2, 1) if True: inputs = inputs.cuda() labels = labels.cuda() act, f = C(inputs) features += f.detach().cpu().tolist() #act = torch.nn.functional.softmax(act, dim=1) score += act[:, t].detach().cpu().tolist() preds[:, t] = list(score) #print('AUROC: ' + str(AUC) ) glabels = (np.concatenate((y_test, y_train))).flatten() == single_class_ind scores = np.sum(((preds)), 1) fpr, tpr, thresholds = metrics.roc_curve(glabels, scores) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) file1 = open("AUC.txt", "a") #append mode file1.write(hyper_para.target + "\t" + hyper_para.method + "\t" + str(hyper_para.inclass[0]) + "\t" + hyper_para.experiment_name + "\t" + str(AUC) + "\n") file1.close()
def _transformations_experiment(dataset_load_fn, dataset_name, single_class_ind, gpu_q): gpu_to_use = gpu_q.get() os.environ["CUDA_VISIBLE_DEVICES"] = gpu_to_use (x_train, y_train), (x_test, y_test) = dataset_load_fn() if dataset_name in ['cats-vs-dogs']: transformer = Transformer(16, 16) n, k = (16, 8) else: transformer = Transformer(8, 8) n, k = (10, 4) #mdl = create_wide_residual_network(x_train.shape[1:], transformer.n_transforms, n, k) '''mdl.compile('adam', 'categorical_crossentropy', ['acc'])''' x_train_task = x_train[y_train.flatten() == single_class_ind] #x_train_task = x_train_task[0:15][:][:][:] transformations_inds = np.tile(np.arange(transformer.n_transforms), len(x_train_task)) x_train_task_transformed = transformer.transform_batch( np.repeat(x_train_task, transformer.n_transforms, axis=0), transformations_inds) batch_size = 32 '''mdl.fit(x=x_train_task_transformed, y=to_categorical(transformations_inds), batch_size=batch_size, epochs=int(np.ceil(200/transformer.n_transforms))) mdl_weights_name = '{}_transformations_{}_weights.h5'.format(dataset_name, get_class_name_from_index(single_class_ind, dataset_name)) #mdl.load_weights('cifar10/'+mdl_weights_name) ################################################################################################# # simplified normality score ################################################################################################# preds = np.zeros((len(x_test), transformer.n_transforms)) for t in [1]:#range(1): preds[:, t] = mdl.predict(transformer.transform_batch(x_test, [t] * len(x_test)), batch_size=batch_size)[:, t] labels = y_test.flatten() == single_class_ind scores = preds.mean(axis=-1) #print("Accuracy : "+ str(scores)) #################################################################################################''' dset = CustomDataset(x_train_task_transformed, transformations_inds) trainLoader = DataLoader(dset, batch_size=32, shuffle=True) ce_criterion = nn.CrossEntropyLoss() C = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() C = nn.DataParallel(C) optimizer_c = optim.Adam(C.parameters(), lr=0.001, betas=(0.9, 0.999)) C.train(mode=True) '''for epoch in range(int(1)): for (inputs, labels) in trainLoader: inputs = inputs.permute(0,3,2,1) if True: inputs = inputs.cuda() labels = labels.cuda() act,_ = C(inputs) loss_cc = ce_criterion(act, labels) optimizer_c.zero_grad() loss_cc.backward() optimizer_c.step() #running_cc += loss_cc.data running_cc = 0.0 torch.save(C.cpu().state_dict(), 'out.pth')''' C = C.cpu() C.load_state_dict(torch.load('out.pth')) (x_train, y_train), (x_test, y_test) = load_cifar10() transformer = Transformer(8, 8) glabels = y_test.flatten() == single_class_ind C.cuda().eval() scores = np.array([[]]) features = [] correct = 0 total = 0 preds = np.zeros((len(x_test), transformer.n_transforms)) for t in [6, 6]: #range(72): score = [] x_test0 = transformer.transform_batch(x_test, [t] * len(x_test)) dset = CustomDataset(x_test0, [t] * len(x_test)) testLoader = DataLoader(dset, batch_size=128, shuffle=False) for i, (inputs, labels) in enumerate(testLoader): inputs = inputs.permute(0, 3, 2, 1) if True: inputs = inputs.cuda() labels = labels.cuda() act, f = C(inputs) features += f.detach().cpu().tolist() #act = torch.nn.functional.softmax(act, dim=1) score += act[:, t].detach().cpu().tolist() preds[:, t] = list(score) fpr, tpr, thresholds = metrics.roc_curve(glabels, score) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) scores = np.sum(((preds)), 1) fpr, tpr, thresholds = metrics.roc_curve(glabels, scores) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) def calc_approx_alpha_sum(observations): N = len(observations) f = np.mean(observations, axis=0) return (N * (len(f) - 1) * (-psi(1))) / (N * np.sum(f * np.log(f)) - np.sum(f * np.sum(np.log(observations), axis=0))) def inv_psi(y, iters=5): # initial estimate cond = y >= -2.22 x = cond * (np.exp(y) + 0.5) + (1 - cond) * -1 / (y - psi(1)) for _ in range(iters): x = x - (psi(x) - y) / polygamma(1, x) return x def fixed_point_dirichlet_mle(alpha_init, log_p_hat, max_iter=1000): alpha_new = alpha_old = alpha_init for _ in range(max_iter): alpha_new = inv_psi(psi(np.sum(alpha_old)) + log_p_hat) if np.sqrt(np.sum((alpha_old - alpha_new)**2)) < 1e-9: break alpha_old = alpha_new return alpha_new def dirichlet_normality_score(alpha, p): return np.sum((alpha - 1) * np.log(p), axis=-1) '''scores = np.zeros((len(x_test),)) observed_data = x_train_task for t_ind in range(transformer.n_transforms): observed_dirichlet = mdl.predict(transformer.transform_batch(observed_data, [t_ind] * len(observed_data)), batch_size=64) log_p_hat_train = np.log(observed_dirichlet).mean(axis=0) alpha_sum_approx = calc_approx_alpha_sum(observed_dirichlet) alpha_0 = observed_dirichlet.mean(axis=0) * alpha_sum_approx mle_alpha_t = fixed_point_dirichlet_mle(alpha_0, log_p_hat_train) x_test_p = mdl.predict(transformer.transform_batch(x_test, [t_ind] * len(x_test)), batch_size=64) scores += dirichlet_normality_score(mle_alpha_t, x_test_p)''' scores /= transformer.n_transforms labels = y_test.flatten() == single_class_ind r = (roc_auc_score(labels, scores)) f = open("guru99.txt", "a") f.write(str(r) + "\n") f.close() '''res_file_name = '{}_transformations_{}_{}.npz'.format(dataset_name,
def octest(hyper_para): CC = wrn.WideResNet(28, num_classes=10, dropout_rate=0, widen_factor=10).cuda() CC.load_state_dict(torch.load(hyper_para.experiment_name + '.pth')) C = wrn.WideResNet(28, num_classes=72, dropout_rate=0, widen_factor=10).cuda() C.cuda().eval() CC.cuda().eval() muc = {} stdc = {} mu = {} std = {} for cname in hyper_para.inclass: single_class_ind = cname C.load_state_dict( torch.load('saved/' + hyper_para.experiment_name + '_' + str(cname) + '.pth')) (x_train, y_train), (x_test, y_test) = load_cifar10() transformer = Transformer(8, 8) x_train_task0 = x_train[[ i in hyper_para.inclass for i in y_train.flatten() ]] y_train_task = y_train[[ i in hyper_para.inclass for i in y_train.flatten() ]] for t in range(72): x_train_task = transformer.transform_batch(x_train_task0, [t] * len(y_train_task)) dset = CustomDataset(x_train_task, y_train_task) trainLoader = DataLoader(dset, batch_size=128, shuffle=True) features = [] for inputs0, labels in trainLoader: inputs = inputs0.permute(0, 3, 2, 1).cuda() act, f = C(inputs) features += act[:, t].detach().cpu().tolist() if t == 0: totfeatures = features else: totfeatures += features mu[str(cname)] = np.mean(totfeatures) std[str(cname)] = np.sqrt(np.var(totfeatures)) features = {} if True: (x_train, y_train), (x_test, y_test) = load_cifar10() x_train_task = x_train[[ i in hyper_para.inclass for i in y_train.flatten() ]] y_train_task = y_train[[ i in hyper_para.inclass for i in y_train.flatten() ]] dset = CustomDataset(x_train_task, y_train_task) trainLoader = DataLoader(dset, batch_size=128, shuffle=True) for inputs0, labels0 in trainLoader: inputs = inputs0.permute(0, 3, 2, 1).cuda() act, f = CC(inputs) val, ind = torch.max(act, dim=1) val, ind, labels0 = (val.detach().cpu().tolist(), ind.detach().cpu().tolist(), labels0.detach().cpu().tolist()) for idx, (ii, gt) in enumerate(zip(ind, labels0)): gt = gt[0] if ii == gt and gt in hyper_para.inclass: if str(ii) not in features.keys(): features[str(ii)] = [ act[idx, ii].detach().cpu().tolist() ] else: features[str(ii)] += [ act[idx, ii].detach().cpu().tolist() ] print(np.shape(features[str(ii)])) for k in features.keys(): muc[str(k)] = np.mean(features[str(k)]) stdc[str(k)] = np.sqrt(np.var(features[str(k)])) (x_train, y_train), (x_test, y_test) = load_cifar10() transformer = Transformer(8, 8) scores = np.array([[]]) features = [] lbl = [] correct = 0 total = 0 preds = np.zeros((len(x_test), transformer.n_transforms)) dset = CustomDataset(x_test, y_test) testLoader = DataLoader(dset, batch_size=128) score = [] for i, (inputs0, labels) in enumerate(testLoader): inputs = inputs0.permute(0, 3, 2, 1) if True: inputs = inputs.cuda() labels = labels.cuda() act0, f = CC(inputs) features += f.detach().cpu().tolist() val, ind = torch.max(act0, dim=1) val, ind, labels = (val.detach().cpu().tolist(), ind.detach().cpu().tolist(), labels.detach().cpu().tolist()) #act = torch.nn.functional.softmax(act, dim=1) #score += val for idx, (ii, gt) in enumerate(zip(ind, labels)): C.load_state_dict( torch.load('saved/' + hyper_para.experiment_name + '_' + str(ii) + '.pth')) gt = gt[0] score_temp = [] for t in range(72): x_test0 = transformer.transform_batch( torch.unsqueeze(inputs0[idx, :, :, :], 0).detach().cpu().numpy(), [t]) inputs = torch.tensor(x_test0).permute(0, 3, 2, 1).cuda() act, _ = C(inputs) act = act[:, t] act = act.detach().cpu().tolist() if t == 0: score_temp = act[0] else: score_temp += act[t] score += [(score_temp - mu[str(ii)]) / (std[str(ii)]) + (val[idx] - muc[str(ii)]) / (stdc[str(ii)])] if gt in hyper_para.inclass: total += 1 if ii == gt: correct += 1 lbl.append(1) else: lbl.append(0) fpr, tpr, thresholds = metrics.roc_curve(lbl, score) AUC = metrics.auc(fpr, tpr) print('AUROC: ' + str(AUC)) return ([0, 0])