def generate_image(self, pre_imgs, targets, **kwargs): # make saliency map by VBP output_VBP, probs, preds = self.VBP_model.generate_image( pre_imgs, targets, **kwargs) # rescale input image input_img = pre_imgs.detach().numpy() input_img = rescale_image(input_img) # input image x VBP sal_maps = np.multiply(output_VBP, input_img) sal_maps = rescale_image(sal_maps.transpose(0, 3, 1, 2)) return sal_maps, probs, preds
def generate_image(self, pre_imgs, targets, **kwargs): # default layer = 8 if 'layer' not in kwargs.keys() else kwargs['layer'] color = False if 'color' not in kwargs.keys() else kwargs['color'] # make saliency map by GradCAM & Guided Backprop output_GC, probs, preds = self.GC_model.generate_image(pre_imgs, targets, layer=layer, color=color) output_GB, _, _ = self.GB_model.generate_image(pre_imgs, targets) # GradCAM x Guided Backprop sal_maps = np.multiply(output_GC, output_GB) sal_maps = rescale_image(sal_maps.transpose(0, 3, 1, 2)) return sal_maps, probs, preds
def generate_image(self, pre_imgs, targets, **kwargs): # default layer = 8 if 'layer' not in kwargs.keys() else kwargs['layer'] color = False if 'color' not in kwargs.keys() else kwargs['color'] # convert target type to LongTensor targets = torch.LongTensor(targets) # prediction pre_imgs = Variable(pre_imgs, requires_grad=True) outputs = self.model(pre_imgs) # calculate gradients self.model.zero_grad() one_hot_output = torch.zeros_like(outputs).scatter( 1, targets.unsqueeze(1), 1).detach() outputs.backward(gradient=one_hot_output) probs, preds = outputs.detach().max(1) gradients = self.gradients[layer].numpy() # A = w * conv_output convs = self.conv_outputs[layer].detach().numpy() weights = np.mean(gradients, axis=(2, 3)) weights = weights.reshape(weights.shape + ( 1, 1, )) gradcams = weights * convs gradcams = gradcams.sum(axis=1) # relu gradcams = np.maximum(gradcams, 0) # minmax scaling * 255 gradcams = rescale_image(gradcams, channel=False) # resize images colors = [color] * gradcams.shape[0] gradcams = np.array(list(map(resize_image, gradcams, pre_imgs, colors))) return (gradcams, probs.numpy(), preds.numpy())
def generate_image(self, pre_imgs, targets, **kwargs): # convert target type to LongTensor targets = torch.LongTensor(targets) # prediction pre_imgs = Variable(pre_imgs, requires_grad=True) outputs = self.model(pre_imgs) # calculate gradients self.model.zero_grad() one_hot_output = torch.zeros_like(outputs).scatter( 1, targets.unsqueeze(1), 1).detach() outputs.backward(gradient=one_hot_output) probs, preds = outputs.detach().max(1) sal_maps = rescale_image(pre_imgs.grad.numpy()) return (sal_maps, probs.numpy(), preds.numpy())
def generate_image(self, pre_imgs, targets, **kwargs): # default layer = 0 if 'layer' not in kwargs.keys() else kwargs['layer'] # convert target type to LongTensor targets = torch.LongTensor(targets) # prediction outputs = self.model(pre_imgs).detach() probs, preds = outputs.max(1) # output deconvnet deconv_outputs = self.deconv_model(self.model.feature_maps[layer], layer, self.model.pool_locs) # denormalization deconv_outputs = deconv_outputs.data.numpy() deconv_outputs = rescale_image(deconv_outputs) return (deconv_outputs, probs.numpy(), preds.numpy())
def generate_image(self, pre_imgs, targets, **kwargs): # default steps = 10 if 'steps' not in kwargs.keys() else kwargs['steps'] # convert target type to LongTensor targets = torch.LongTensor(targets) # divide image xbar_list = self.generate_images_on_linear_path(pre_imgs, steps) sal_maps = np.zeros(pre_imgs.size()) # make saliency map from divided images for xbar_image in xbar_list: single_integrated_grad, probs, preds = self.generate_gradients( xbar_image, targets) sal_maps = sal_maps + (single_integrated_grad / steps) # rescale saliency map sal_maps = rescale_image(sal_maps) return (sal_maps, probs, preds)
def generate_image(self, pre_imgs, targets, **kwargs): # last layer idx layer = 11 if 'layer' not in kwargs.keys() else kwargs['layer'] color = False if 'color' not in kwargs.keys() else kwargs['color'] # convert target type to LongTensor targets = torch.LongTensor(targets) # prediction pre_imgs = Variable(pre_imgs, requires_grad=True) outputs = self.model(pre_imgs) probs, preds = outputs.detach().max(1) # last layer output last_layer_output = self.conv_outputs[layer].detach().numpy( ) # (B, C, H, W) # w_k w_k = self.model.cam_mlp.mlp[0].weight.detach().numpy( ) # (nb_class, C) b_w_k = np.zeros((targets.shape[0], w_k.shape[1])) for i in range(targets.shape[0]): b_w_k[i] = w_k[targets[i]] b_w_k = b_w_k.reshape(b_w_k.shape + ( 1, 1, )) # (B, C, 1, 1) # b_w_k x last layer output cams = (b_w_k * last_layer_output).sum(1) # minmax scaling * 255 cams = rescale_image(cams, channel=False) # resize to input image size colors = [color] * cams.shape[0] cams = np.array(list(map(resize_image, cams, pre_imgs, colors))) return (cams, probs.numpy(), preds.numpy())
def generate_image(self, pre_imgs, targets, **kwargs): # default layer = 11 if 'layer' not in kwargs.keys() else kwargs['layer'] color = False if 'color' not in kwargs.keys() else kwargs['color'] # convert target type to LongTensor targets = torch.LongTensor(targets) # prediction pre_imgs = Variable(pre_imgs, requires_grad=True) outputs = self.model(pre_imgs) probs, preds = outputs.detach().max(1) # n th convolution block output conv_out = self.conv_outputs[layer].mean(axis=1).detach().numpy() # minmax scaling * 255 conv_out = rescale_image(conv_out, channel=False) colors = [color] * conv_out.shape[0] gradcams = np.array(list(map(resize_image, conv_out, pre_imgs, colors))) return (gradcams, probs.numpy(), preds.numpy())