def loadData(self): trainset = SimulationDataset("train", transforms=transforms.Compose([ utils.RandomCoose(['center']), utils.Preprocess(self.input_shape), # utils.RandomResizedCrop(self.input_shape), # utils.RandomNoise(), utils.RandomTranslate(10, 10), # utils.RandomBrightness(), # utils.RandomContrast(), # utils.RandomHue(), utils.RandomHorizontalFlip(), utils.ToTensor(), utils.Normalize([0.1, 0.4, 0.4], [0.9, 0.6, 0.5]) ])) # weights = utils.get_weights(trainset) # sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(weights), replacement=False) # self.trainloader = torch.utils.data.DataLoader(trainset, batch_size=self.cfg.batch_size, sampler=sampler, num_workers=0, pin_memory=True) self.trainloader = torch.utils.data.DataLoader(trainset, shuffle=True, batch_size=self.cfg.batch_size, num_workers=0, pin_memory=True) testset = SimulationDataset("test", transforms=transforms.Compose([ utils.RandomCoose(['center']), utils.Preprocess(self.input_shape), utils.ToTensor(), utils.Normalize([0.1, 0.4, 0.4], [0.9, 0.6, 0.5]) ])) self.testloader = torch.utils.data.DataLoader(testset, batch_size=self.cfg.batch_size, shuffle=False, num_workers=0, pin_memory=True)
def predict(self, image, preloaded=False): # set test mode self.net.eval() if (not preloaded): loadModel() print('Loaded Model') print('Starting Prediction') composed = transforms.Compose([ utils.Preprocess(self.input_shape), utils.ToTensor(), utils.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # Target gets discareded sample = {'image': image, 'target': 0} sample = composed(sample) inputs = sample['image'] # Add single batch diemension inputs = inputs.unsqueeze(0) if (self.cfg.cuda): inputs = Variable(inputs.cuda(async=True)) else: inputs = Variable(inputs) if (self.cfg.cuda): outputs = self.net(inputs).cuda(async=True) else: outputs = self.net(inputs) print('Finished Prediction') print('Control tensor: %.6f ' % (outputs.item())) # set train mode self.net.train() return outputs.item()
def loadData(self): trainset = SimulationDataset( "train", transforms=transforms.Compose([ utils.RandomCoose(['centre', 'left', 'right']), utils.Preprocess(self.input_shape), utils.RandomTranslate(100, 10), utils.RandomBrightness(), utils.RandomContrast(), utils.RandomHue(), utils.RandomHorizontalFlip(), utils.ToTensor(), utils.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ])) weights = utils.get_weights(trainset) sampler = torch.utils.data.sampler.WeightedRandomSampler( weights, len(weights), replacement=True) # self.trainloader = torch.utils.data.DataLoader(trainset, batch_size=self.cfg.batch_size, sampler=sampler, num_workers=4) self.trainloader = torch.utils.data.DataLoader( trainset, batch_size=self.cfg.batch_size, num_workers=4) testset = SimulationDataset("test", transforms=transforms.Compose([ utils.RandomCoose(['center']), utils.Preprocess(self.input_shape), utils.ToTensor(), utils.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ])) self.testloader = torch.utils.data.DataLoader( testset, batch_size=self.cfg.batch_size, shuffle=False, num_workers=4)
# plt.imshow(F.to_pil_image(sample['image'])) # plt.title(str(sample['target'])) # plt.show() return sample['image'], sample['target'] def __len__(self): return len(self.image_paths) if __name__ == '__main__': input_shape = (utils.IMAGE_HEIGHT, utils.IMAGE_WIDTH) dataset = SimulationDataset("train", transforms=transforms.Compose([ utils.RandomCoose(['center']), utils.Preprocess(input_shape), utils.RandomHorizontalFlip(), utils.ToTensor(), utils.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ])) print(dataset.__len__()) print(dataset.__getitem__(0)[0].size()) for c in range(3): for i in range(dataset.__len__()): print(dataset.__getitem__(i)[c].mean()) print(dataset.__getitem__(i)[c].std()) # print(dataset.__getitem__(0)) # print(len(dataset.__get_annotations__()))
def main(args): # log hyperparameter print(args) # select device args.cuda = not args.no_cuda and torch.cuda.is_available() device = torch.device("cuda: 0" if args.cuda else "cpu") # set random seed np.random.seed(args.seed) torch.manual_seed(args.seed) # data loader transform = transforms.Compose([utils.Normalize(), utils.ToTensor()]) infer_dataset = InferTVDataset(root=args.root, sub_size=args.block_size, volume_list="volume_test_list.txt", max_k=args.infering_step, transform=transform) kwargs = {"num_workers": 4, "pin_memory": True} if args.cuda else {} infer_loader = DataLoader(infer_dataset, batch_size=args.batch_size, shuffle=False, **kwargs) # model def generator_weights_init(m): if isinstance(m, nn.Conv3d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) g_model = Generator(args.upsample_mode, args.forward, args.backward, args.gen_sn) g_model.apply(generator_weights_init) if args.data_parallel and torch.cuda.device_count() > 1: g_model = nn.DataParallel(g_model) g_model.to(device) mse_loss = nn.MSELoss() adversarial_loss = nn.MSELoss() train_losses, test_losses = [], [] d_losses, g_losses = [], [] # load checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint {}".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint["epoch"] g_model.load_state_dict(checkpoint["g_model_state_dict"]) # g_optimizer.load_state_dict(checkpoint["g_optimizer_state_dict"]) if args.gan_loss != "none": # d_model.load_state_dict(checkpoint["d_model_state_dict"]) # d_optimizer.load_state_dict(checkpoint["d_optimizer_state_dict"]) d_losses = checkpoint["d_losses"] g_losses = checkpoint["g_losses"] train_losses = checkpoint["train_losses"] test_losses = checkpoint["test_losses"] print("=> load chekcpoint {} (epoch {})".format( args.resume, checkpoint["epoch"])) g_model.eval() inferRes = [] zSize, ySize, xSize = 120, 720, 480 for i in range(args.infering_step): inferRes.append(np.zeros((zSize, ySize, xSize))) inferScale = np.zeros((zSize, ySize, xSize)) time_start = 0 volume_type = '' with torch.no_grad(): for i, sample in tqdm(enumerate(infer_loader)): v_f = sample["v_f"].to(device) v_b = sample["v_b"].to(device) fake_volumes = g_model(v_f, v_b, args.infering_step, args.wo_ori_volume, args.norm) volume_type, time_start, x_start, y_start, z_start = utils.Parse( sample["vf_name"][0]) for j in range(fake_volumes.shape[1]): volume = fake_volumes[0, j, 0] min_value = -0.015 # -0.012058 max_value = 1.01 # 1.009666 mean = (min_value + max_value) / 2 std = mean - min_value volume = volume.to("cpu").numpy() * std + mean inferRes[j][z_start:z_start + args.block_size, y_start:y_start + args.block_size, x_start:x_start + args.block_size] += volume if j == 0: inferScale[z_start:z_start + args.block_size, y_start:y_start + args.block_size, x_start:x_start + args.block_size] += 1 # pdb.set_trace() for j in range(args.infering_step): inferRes[j] = inferRes[j] / inferScale inferRes[j] = inferRes[j].astype(np.float32) volume_name = volume_type + '_' + ("%04d" % (time_start + j + 1)) + '.raw' inferRes[j].tofile(os.path.join(args.save_pred, volume_name))
def make_z(args, shape, minval, maxval): z = minval + torch.rand(shape) * (maxval - 1) return z.to(args.device) def save_checkpoint(state, epoch): ckpt_dir = 'home/vkv/NAG/ckpt/' print("[*] Saving model to {}".format(ckpt_dir)) filename = 'NAG' + '_ckpt.pth.tar' ckpt_path = os.path.join(ckpt_dir, filename) torch.save(state, ckpt_path) normalize = utils.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) parser = argparse.ArgumentParser(description='BlackBox') parser.add_argument("--comet_username", type=str, default="joeybose", help='Username for comet logging') parser.add_argument("--comet_apikey", type=str,\ default="Ht9lkWvTm58fRo9ccgpabq5zV",help='Api for comet logging') parser.add_argument('--model_path', type=str, default="mnist_cnn.pt", help='where to save/load') parser.add_argument('--mnist', default=False, action='store_true',
def main(args): # log hyperparameter print(args) # select device args.cuda = not args.no_cuda and torch.cuda.is_available() device = torch.device("cuda: 0" if args.cuda else "cpu") # set random seed np.random.seed(args.seed) torch.manual_seed(args.seed) # data loader transform = transforms.Compose([ utils.Normalize(), utils.ToTensor() ]) train_dataset = TVDataset( root=args.root, sub_size=args.block_size, volume_list=args.volume_train_list, max_k=args.training_step, train=True, transform=transform ) test_dataset = TVDataset( root=args.root, sub_size=args.block_size, volume_list=args.volume_test_list, max_k=args.training_step, train=False, transform=transform ) kwargs = {"num_workers": 4, "pin_memory": True} if args.cuda else {} train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, **kwargs) # model def generator_weights_init(m): if isinstance(m, nn.Conv3d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) def discriminator_weights_init(m): if isinstance(m, nn.Conv3d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='leaky_relu') if m.bias is not None: nn.init.zeros_(m.bias) g_model = Generator(args.upsample_mode, args.forward, args.backward, args.gen_sn, args.residual) g_model.apply(generator_weights_init) if args.data_parallel and torch.cuda.device_count() > 1: g_model = nn.DataParallel(g_model) g_model.to(device) if args.gan_loss != "none": d_model = Discriminator(args.dis_sn) d_model.apply(discriminator_weights_init) # if args.dis_sn: # d_model = add_sn(d_model) if args.data_parallel and torch.cuda.device_count() > 1: d_model = nn.DataParallel(d_model) d_model.to(device) mse_loss = nn.MSELoss() adversarial_loss = nn.MSELoss() train_losses, test_losses = [], [] d_losses, g_losses = [], [] # optimizer g_optimizer = optim.Adam(g_model.parameters(), lr=args.lr, betas=(args.beta1, args.beta2)) if args.gan_loss != "none": d_optimizer = optim.Adam(d_model.parameters(), lr=args.d_lr, betas=(args.beta1, args.beta2)) Tensor = torch.cuda.FloatTensor if args.cuda else torch.FloatTensor # load checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint {}".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint["epoch"] g_model.load_state_dict(checkpoint["g_model_state_dict"]) # g_optimizer.load_state_dict(checkpoint["g_optimizer_state_dict"]) if args.gan_loss != "none": d_model.load_state_dict(checkpoint["d_model_state_dict"]) # d_optimizer.load_state_dict(checkpoint["d_optimizer_state_dict"]) d_losses = checkpoint["d_losses"] g_losses = checkpoint["g_losses"] train_losses = checkpoint["train_losses"] test_losses = checkpoint["test_losses"] print("=> load chekcpoint {} (epoch {})" .format(args.resume, checkpoint["epoch"])) # main loop for epoch in tqdm(range(args.start_epoch, args.epochs)): # training.. g_model.train() if args.gan_loss != "none": d_model.train() train_loss = 0. volume_loss_part = np.zeros(args.training_step) for i, sample in enumerate(train_loader): params = list(g_model.named_parameters()) # pdb.set_trace() # params[0][1].register_hook(lambda g: print("{}.grad: {}".format(params[0][0], g))) # adversarial ground truths real_label = Variable(Tensor(sample["v_i"].shape[0], sample["v_i"].shape[1], 1, 1, 1, 1).fill_(1.0), requires_grad=False) fake_label = Variable(Tensor(sample["v_i"].shape[0], sample["v_i"].shape[1], 1, 1, 1, 1).fill_(0.0), requires_grad=False) v_f = sample["v_f"].to(device) v_b = sample["v_b"].to(device) v_i = sample["v_i"].to(device) g_optimizer.zero_grad() fake_volumes = g_model(v_f, v_b, args.training_step, args.wo_ori_volume, args.norm) # adversarial loss # update discriminator if args.gan_loss != "none": avg_d_loss = 0. avg_d_loss_real = 0. avg_d_loss_fake = 0. for k in range(args.n_d): d_optimizer.zero_grad() decisions = d_model(v_i) d_loss_real = adversarial_loss(decisions, real_label) fake_decisions = d_model(fake_volumes.detach()) d_loss_fake = adversarial_loss(fake_decisions, fake_label) d_loss = d_loss_real + d_loss_fake d_loss.backward() avg_d_loss += d_loss.item() / args.n_d avg_d_loss_real += d_loss_real / args.n_d avg_d_loss_fake += d_loss_fake / args.n_d d_optimizer.step() # update generator if args.gan_loss != "none": avg_g_loss = 0. avg_loss = 0. for k in range(args.n_g): loss = 0. g_optimizer.zero_grad() # adversarial loss if args.gan_loss != "none": fake_decisions = d_model(fake_volumes) g_loss = args.gan_loss_weight * adversarial_loss(fake_decisions, real_label) loss += g_loss avg_g_loss += g_loss.item() / args.n_g # volume loss if args.volume_loss: volume_loss = args.volume_loss_weight * mse_loss(v_i, fake_volumes) for j in range(v_i.shape[1]): volume_loss_part[j] += mse_loss(v_i[:, j, :], fake_volumes[:, j, :]) / args.n_g / args.log_every loss += volume_loss # feature loss if args.feature_loss: feat_real = d_model.extract_features(v_i) feat_fake = d_model.extract_features(fake_volumes) for m in range(len(feat_real)): loss += args.feature_loss_weight / len(feat_real) * mse_loss(feat_real[m], feat_fake[m]) avg_loss += loss / args.n_g loss.backward() g_optimizer.step() train_loss += avg_loss # log training status subEpoch = (i + 1) // args.log_every if (i+1) % args.log_every == 0: print("Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}".format( epoch, (i+1) * args.batch_size, len(train_loader.dataset), 100. * (i+1) / len(train_loader), avg_loss )) print("Volume Loss: ") for j in range(volume_loss_part.shape[0]): print("\tintermediate {}: {:.6f}".format( j+1, volume_loss_part[j] )) if args.gan_loss != "none": print("DLossReal: {:.6f} DLossFake: {:.6f} DLoss: {:.6f}, GLoss: {:.6f}".format( avg_d_loss_real, avg_d_loss_fake, avg_d_loss, avg_g_loss )) d_losses.append(avg_d_loss) g_losses.append(avg_g_loss) # train_losses.append(avg_loss) train_losses.append(train_loss.item() / args.log_every) print("====> SubEpoch: {} Average loss: {:.6f} Time {}".format( subEpoch, train_loss.item() / args.log_every, time.asctime(time.localtime(time.time())) )) train_loss = 0. volume_loss_part = np.zeros(args.training_step) # testing... if (i + 1) % args.test_every == 0: g_model.eval() if args.gan_loss != "none": d_model.eval() test_loss = 0. with torch.no_grad(): for i, sample in enumerate(test_loader): v_f = sample["v_f"].to(device) v_b = sample["v_b"].to(device) v_i = sample["v_i"].to(device) fake_volumes = g_model(v_f, v_b, args.training_step, args.wo_ori_volume, args.norm) test_loss += args.volume_loss_weight * mse_loss(v_i, fake_volumes).item() test_losses.append(test_loss * args.batch_size / len(test_loader.dataset)) print("====> SubEpoch: {} Test set loss {:4f} Time {}".format( subEpoch, test_losses[-1], time.asctime(time.localtime(time.time())) )) # saving... if (i+1) % args.check_every == 0: print("=> saving checkpoint at epoch {}".format(epoch)) if args.gan_loss != "none": torch.save({"epoch": epoch + 1, "g_model_state_dict": g_model.state_dict(), "g_optimizer_state_dict": g_optimizer.state_dict(), "d_model_state_dict": d_model.state_dict(), "d_optimizer_state_dict": d_optimizer.state_dict(), "d_losses": d_losses, "g_losses": g_losses, "train_losses": train_losses, "test_losses": test_losses}, os.path.join(args.save_dir, "model_" + str(epoch) + "_" + str(subEpoch) + "_" + "pth.tar") ) else: torch.save({"epoch": epoch + 1, "g_model_state_dict": g_model.state_dict(), "g_optimizer_state_dict": g_optimizer.state_dict(), "train_losses": train_losses, "test_losses": test_losses}, os.path.join(args.save_dir, "model_" + str(epoch) + "_" + str(subEpoch) + "_" + "pth.tar") ) torch.save(g_model.state_dict(), os.path.join(args.save_dir, "model_" + str(epoch) + "_" + str(subEpoch) + ".pth")) num_subEpoch = len(train_loader) // args.log_every print("====> Epoch: {} Average loss: {:.6f} Time {}".format( epoch, np.array(train_losses[-num_subEpoch:]).mean(), time.asctime(time.localtime(time.time())) ))
from dataloader import SimulationDataset import matplotlib.pyplot as plt from PIL import Image import utils as utils import torch from torchvision import transforms import torchvision.transforms.functional as F input_shape = (utils.IMAGE_HEIGHT, utils.IMAGE_WIDTH) dataset = SimulationDataset("train", transforms=transforms.Compose([ utils.RandomCoose(['center']), utils.Preprocess(input_shape), utils.ToTensor(), utils.Normalize([0.1, 0.4, 0.4], [0.9, 0.6, 0.5]) ])) targets = [] for i in range(dataset.__len__()): image, target = dataset.__getitem__(i) targets.append(target) # plt.imshow(F.to_pil_image(image)) # plt.title(str(target)) # plt.show() plt.hist(targets, 50) plt.show()
y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) y_true_f = K.round(y_true_f) y_pred_f = K.round(y_pred_f) intersection = K.sum(K.abs(y_true_f * y_pred_f), axis=-1) return (2. * intersection + smooth) / (K.sum(y_true_f,-1) + K.sum(y_pred_f,-1) + smooth) model=load_model("./T2_Ax_result_ProstateCancerClassification_NormalvsCancer_01/weights-14.h5", custom_objects={'JunctionWeightLayer': utils.JunctionWeightLayer, 'dice_coef': dice_coef}) #%% img_list = img_hdf5[1233+100:] y_true = label_hdf5[1233+100:] y_true=np.array(y_true>=1, dtype=np.uint8) img_norm=[] for img in img_list: img_norm.append(utils.Normalize(img)) y_predict=model.predict(np.array(img_norm)) y_predict = y_predict.flatten() #for i in range(len(y_true)): # print(y_true[i], y_predict[i]) from sklearn.metrics import auc,average_precision_score, precision_recall_curve,classification_report, f1_score, confusion_matrix,brier_score_loss from sklearn.metrics import roc_auc_score,roc_curve ,fowlkes_mallows_score title="ROC Curve for case detection with prostate cancer" utils.plotROCCurveMultiCall(plt,y_true, y_predict, title) plt.savefig("./PCA_MRI_DETECTION_roc_curve.eps", transparent=True) plt.savefig("./PCA_MRI_DETECTION_roc_curve.pdf", transparent=True) plt.savefig("./PCA_MRI_DETECTION_roc_curve.png", transparent=True) plt.show() plt.close()
def main(args): if args.mnist: # Normalize image for MNIST # normalize = Normalize(mean=(0.1307,), std=(0.3081,)) normalize = None args.input_size = 784 elif args.cifar: normalize = utils.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) args.input_size = 32 * 32 * 3 else: # Normalize image for ImageNet normalize = utils.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) args.input_size = 150528 # Load data train_loader, test_loader = utils.get_data(args) # The unknown model to attack unk_model = utils.load_unk_model(args) # Try Whitebox Untargeted first if args.debug: ipdb.set_trace() if args.train_vae: encoder, decoder, vae = train_mnist_vae(args) else: encoder, decoder, vae = None, None, None if args.train_ae: encoder, decoder, ae = train_mnist_ae(args) else: encoder, decoder, ae = None, None, None # Add A Flow norm_flow = None if args.use_flow: # norm_flow = flows.NormalizingFlow(30, args.latent).to(args.device) norm_flow = flows.Planar # Test white box if args.white: # Choose Attack Function if args.no_pgd_optim: white_attack_func = attacks.L2_white_box_generator else: white_attack_func = attacks.PGD_white_box_generator # Choose Dataset if args.mnist: G = models.Generator(input_size=784).to(args.device) elif args.cifar: if args.vanilla_G: G = models.DCGAN().to(args.device) G = nn.DataParallel(G.generator) else: G = models.ConvGenerator(models.Bottleneck,[6,12,24,16],growth_rate=12,\ flows=norm_flow,use_flow=args.use_flow,\ deterministic=args.deterministic_G).to(args.device) G = nn.DataParallel(G) nc, h, w = 3, 32, 32 if args.run_baseline: attacks.whitebox_pgd(args, unk_model) pred, delta = white_attack_func(args, train_loader,\ test_loader, unk_model, G, nc, h, w) # Blackbox Attack model model = models.GaussianPolicy(args.input_size, 400, args.latent_size, decode=False).to(args.device) # Control Variate cv = to_cuda(models.FC(args.input_size, args.classes))
print utils.runcmd('cd ~/cache/nova-specs; ' 'git checkout master; ' 'git pull') for ent in os.listdir( os.path.expanduser('~/cache/nova-specs' '/specs/%s' % RELEASE)): if not ent.endswith('.rst'): continue APPROVED_SPECS.append(ent[:-4]) possible = reviews.component_reviews('openstack/nova-specs') for review in filter_obvious(possible): try: bp_name = review.get('topic', 'bp/nosuch').split('/')[1] except: bp_name = review.get('topic', '') PROPOSED_SPECS.append(bp_name) targets() for header in HEADERS: print '<li><a href="#%s">%s</a>' % (header.replace(' ', '_'), header) print '<br/><br/>' print utils.Normalize('\n'.join(OUTPUT)) print print 'I printed %d reviews' % len(PRINTED) print 'Generated at: %s' % datetime.datetime.now()