if arg.beta[0] <= 0 or arg.beta[1] <= 0:
raise argparse.ArgumentTypeError("betas <= 0")
if __name__ == "__main__":
arg = arg_parse()
arg_check(arg)
os.environ["CUDA_VISIBLE_DEVICES"] = arg.gpus
torch_device = torch.device("cuda")
train_path = "data/prostate/train/"
val_path = "data/prostate/val/"
test_path = "data/prostate/test/"
preprocess = preprocess.get_preprocess(arg.augment)
train_loader = Loader(train_path,
arg.batch_size,
transform=preprocess,
sampler='',
torch_type='float',
cpus=4,
shuffle=True,
drop_last=True)
val_loader = Loader(val_path,
arg.batch_size,
transform=preprocess,
sampler=arg.sampler,
torch_type=arg.dtype,
cpus=arg.cpus,
#image_paths = image_paths
print("Evaluating on {} images.".format(len(image_paths)))
num_batches = int(len(image_paths) / batch_size)
model = utils.load_model('vgg16').cuda()
results = {}
for batch_no in range(num_batches):
print("Batch {} of {}".format(batch_no + 1, num_batches))
image_batch = image_paths[batch_no * batch_size:(batch_no + 1) *
batch_size]
raw_imgs = [viz.pil_loader(image_path) for image_path in image_batch]
# make sure preprocessing is correct
inputs = [
get_preprocess('vgg16', 'pattern_vanilla_grad')(raw_img)
for raw_img in raw_imgs
]
inputs = torch.stack(inputs).cuda()
inputs = utils.cuda_var(inputs, requires_grad=True)
diff_sum = 0
with torch.cuda.device(0):
torch.cuda.empty_cache()
model = utils.load_model('vgg16').cuda()
explainer = get_explainer(model, 'vanilla_grad')
out = torch.softmax(model(inputs.clone()), axis=-1)
classes = torch.max(out, dim=1)[1]
out = out.detach().cpu().numpy()
# idx = torch.randperm(layer.nelement())
# layer = layer.view(-1)[idx].view(layer.size())
# reset randomization method
model.load_state_dict(state_dict)
model_methods = [
#['googlenet', 'vanilla_grad', 'camshow'],
#['vgg16', 'grad_x_input', 'camshow'],
#['vgg16', 'saliency', 'camshow'],
#['vgg16', 'integrate_grad', 'camshow'],
#['vgg16', 'deconv', 'camshow'],
#['vgg16', 'guided_backprop', 'camshow'],
['vgg16', 'pattern_net', 'camshow'],
['vgg16', 'pattern_lrp', 'camshow'],
['vgg16', 'smooth_grad', 'camshow'],
['vgg16', 'deeplift_rescale', 'camshow']]
if __name__ == '__main__':
for m in model_methods:
method = m[1]
image_path = '../images/bee.jpg'
image_class = 309
image_class_name = 'bee'
raw_img = viz.pil_loader(image_path)
img_input = get_preprocess('vgg16', method)(raw_img)
img_input = utils.cuda_var(img_input.unsqueeze(0), requires_grad=True)
target = torch.LongTensor([image_class])
cascading_parameter_randomization(method, False, img_input, target)
arg_check(arg)
os.environ["CUDA_VISIBLE_DEVICES"] = arg.gpus
torch_device = torch.device("cuda")
data_path = "/data/00_Nuclues_segmentation/00_data/"
if arg.in_channel == 1:
data_path += "/2D/New(50_Cells)"
elif arg.in_channel > 1 and arg.out_channel == 1:
data_path += "/25D/%dchannel" % (arg.in_channel)
train_path = data_path + "/%s/Train/" % (arg.data)
valid_path = data_path + "/%s/Val/" % (arg.data)
test_path = data_path + "/All/Test/"
preprocess = preprocess.get_preprocess(arg)
train_loader = NucleusLoader(train_path,
arg.batch_size,
transform=preprocess,
sampler=arg.sampler,
channel=arg.in_channel,
torch_type=arg.dtype,
cpus=arg.cpus,
shuffle=True,
drop_last=True)
valid_loader = NucleusLoader(valid_path,
arg.batch_size,
transform=preprocess,
sampler=arg.sampler,
channel=arg.in_channel,
# Take the sample image, and display it (original form)
image_path = "models/test_" + displayed_class + "_images/" + displayed_class + str(
number_image) + ".jpg"
raw_img = viz.pil_loader(image_path)
plt.figure(figsize=(5, 5))
plt.imshow(raw_img)
plt.axis('off')
plt.title(displayed_class)
# Now, we want to display the saliency maps of this image, for every model_method element
all_saliency_maps = []
for model_name, method_name, _ in model_methods:
# Get a specific picture transformation (see torchvision.transforms documentation)
transf = get_preprocess(model_name, method_name)
# Load the pretrained model
model = utils.load_model(model_name)
model.cuda()
# Get the explainer
explainer = get_explainer(model, method_name)
# Transform the image
inp = transf(raw_img)
if method_name == 'googlenet': # swap channel due to caffe weights
inp_copy = inp.clone()
inp[0] = inp_copy[2]
inp[2] = inp_copy[0]
inp = utils.cuda_var(inp.unsqueeze(0), requires_grad=True)
target = torch.LongTensor([image_class]).cuda()
def compute_saliency_map(model_name, displayed_class, number_image):
model_methods = [
[model_name, 'vanilla_grad', 'imshow'],
[model_name, 'grad_x_input', 'imshow'],
[model_name, 'saliency', 'imshow'],
[model_name, 'integrate_grad', 'imshow'],
[model_name, 'deconv', 'imshow'],
[model_name, 'guided_backprop', 'imshow'],
#[model_name, 'gradcam', 'camshow'],
#[model_name, 'excitation_backprop', 'camshow'],
#[model_name, 'contrastive_excitation_backprop', 'camshow']
]
# Change 'image_class' to 0 if you want to display for a dog
if (displayed_class == "dog"):
image_class = 0
elif (displayed_class == "cat"):
image_class = 1
else:
print("ERROR: wrong displayed class")
# Take the sample image, and display it (original form)
image_path = "models/test_" + displayed_class + "_images/" + str(
number_image)
raw_img = viz.pil_loader(image_path)
plt.figure(figsize=(5, 5))
plt.imshow(raw_img)
plt.axis('off')
plt.title(displayed_class)
# Now, we want to display the saliency maps of this image, for every model_method element
all_saliency_maps = []
for model_name, method_name, _ in model_methods:
# Get a specific picture transformation (see torchvision.transforms documentation)
transf = get_preprocess(model_name, method_name)
# Load the pretrained model
model = utils.load_model(model_name)
model.cuda()
# Get the explainer
explainer = get_explainer(model, method_name)
# Transform the image
inp = transf(raw_img)
if method_name == 'googlenet': # swap channel due to caffe weights
inp_copy = inp.clone()
inp[0] = inp_copy[2]
inp[2] = inp_copy[0]
inp = utils.cuda_var(inp.unsqueeze(0), requires_grad=True)
target = torch.LongTensor([image_class]).cuda()
saliency = explainer.explain(inp, target)
saliency = utils.upsample(saliency, (raw_img.height, raw_img.width))
#all_saliency_maps.append(saliency.cpy().numpy())
all_saliency_maps.append(saliency.cpu().numpy())
# Display all the results
plt.figure(figsize=(25, 15))
plt.subplot(3, 5, 1)
plt.imshow(raw_img)
plt.axis('off')
plt.title(displayed_class)
for i, (saliency,
(model_name, method_name,
show_style)) in enumerate(zip(all_saliency_maps, model_methods)):
plt.subplot(3, 5, i + 2 + i // 4)
if show_style == 'camshow':
viz.plot_cam(np.abs(saliency).max(axis=1).squeeze(),
raw_img,
'jet',
alpha=0.5)
else:
if model_name == 'googlenet' or method_name == 'pattern_net':
saliency = saliency.squeeze()[::-1].transpose(1, 2, 0)
else:
saliency = saliency.squeeze().transpose(1, 2, 0)
saliency -= saliency.min()
saliency /= (saliency.max() + 1e-20)
plt.imshow(saliency, cmap='gray')
plt.axis('off')
if method_name == 'excitation_backprop':
plt.title('Exc_bp')
elif method_name == 'contrastive_excitation_backprop':
plt.title('CExc_bp')
else:
plt.title('%s' % (method_name))
plt.tight_layout()
if not os.path.exists('images/' + model_name + '/'):
os.makedirs('images/' + model_name + '/')
save_destination = 'images/' + model_name + '/' + str(
number_image[:-4]) + '_saliency.png'
plt.savefig(save_destination)
plt.clf()
help='Number of validation samples to run')
parser.add_argument('--n_patches', type=int, default=100,
help='Number of patches to degrade')
parser.add_argument('--imagenet_download_key', default=None,
help='Optional URL string for imagenet download')
args = parser.parse_args()
methods = args.methods
batch_size = args.batch_size
data_dir = args.data_dir
val_size = args.val_size
n_patches = args.n_patches
imagenet_download_key = args.imagenet_download_key
# Load data
input_transform = get_preprocess('vgg16', 'pattern_vanilla_grad')
imagenet_data = get_imagenet_dataloader(data_dir, input_transform, val_size, batch_size, imagenet_download_key)
num_batches = len(imagenet_data)
print("Evaluating on {} images.".format(val_size))
model = utils.load_model('vgg16').cuda()
results = {}
for batch_idx, batch in enumerate(imagenet_data):
t = time.time()
print("Batch {} of {}".format(batch_idx+1, num_batches))
for m in methods:
print("Method: {}".format(m))
