论文Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization

    class GradCam:
    def __init__(self, model, target_layer_names, use_cuda):
        self.model = model
        self.model.eval()
        self.cuda = use_cuda
        if self.cuda:
            self.model = model.cuda()
    
        self.extractor = ModelOutputs(self.model, target_layer_names)
    
    def forward(self, input):
        return self.model(input)
    
    def __call__(self, input, index=None):
        if self.cuda:
            features, output = self.extractor(input.cuda())
        else:
            features, output = self.extractor(input)
    
        if index == None:
            index = np.argmax(output.cpu().data.numpy())
    
        one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)
        one_hot[0][index] = 1
        one_hot = torch.from_numpy(one_hot).requires_grad_(True)
        if self.cuda:
            one_hot = torch.sum(one_hot.cuda() * output)
        else:
            one_hot = torch.sum(one_hot * output)
    
        self.model.features.zero_grad()
        self.model.classifier.zero_grad()
        one_hot.backward(retain_graph=True)
    
        grads_val = self.extractor.get_gradients()[-1].cpu().data.numpy()
    
        target = features[-1]
        target = target.cpu().data.numpy()[0, :]
    
        weights = np.mean(grads_val, axis=(2, 3))[0, :]
        cam = np.zeros(target.shape[1:], dtype=np.float32)
    
        for i, w in enumerate(weights):
            cam += w * target[i, :, :]
    
        cam = np.maximum(cam, 0)
        cam = cv2.resize(cam, (224, 224))
        cam = cam - np.min(cam)
        cam = cam / np.max(cam)
        return cam