def plot_images(torch_img, normed_torch_img, model):
images = []
g1 = GradCAM(model, model.layer1)
g2 = GradCAM(model, model.layer2)
g3 = GradCAM(model, model.layer3)
g4 = GradCAM(model, model.layer4)
mask1, _ = g1(normed_torch_img)
mask2, _ = g2(normed_torch_img)
mask3, _ = g3(normed_torch_img)
mask4, _ = g4(normed_torch_img)
heatmap1, result1 = visualize_cam(mask1, torch_img)
heatmap2, result2 = visualize_cam(mask2, torch_img)
heatmap3, result3 = visualize_cam(mask3, torch_img)
heatmap4, result4 = visualize_cam(mask4, torch_img)
images.extend([torch_img.cpu(), heatmap1, heatmap2, heatmap3, heatmap4])
images.extend([torch_img.cpu(), result1, result2, result3, result4])
grid_image = make_grid(images, nrow=5)
imshow(grid_image)
def gradcam_misclassified(mis_class,model,device):
plt.figure(figsize=(75, 75))
num_of_images = len(mis_class)
for index in range(1, num_of_images + 1):
images =[]
b = torch.from_numpy(mis_class[index-1]['img'])
trans = transforms.ToPILImage()
pil_img=trans(torchvision.utils.make_grid(b))
t_img,n_t_img=Utils.change(pil_img,device)
g= GradCAM(model,model.layer4)
mask,_=g(n_t_img)
heatmap,res = visualize_cam(mask,t_img)
images.extend([b,heatmap,res])
grid_image=make_grid(images,nrow=3)
imshow2(grid_image,mis_class[index-1]['pred'],mis_class[index - 1]['target'])
channels,
activation,
voxelCount,
nbClasses,
activation_layer=-4)
if example_no == "all":
list_raw = glob.glob("Examples\inouts\*.raw")
for fileidx, filename in enumerate(list_raw):
array = np.zeros((1, voxelCount, voxelCount, voxelCount, channels))
for c in range(channels):
loadFile(array, filename, voxelCount, voxelCount, voxelCount,
c)
predicted_class = cnnModel.predict(array)
print(filename, 'has a predicted class', predicted_class)
attMap = GradCAM(activationFunction, array)
gBackprop = saliency_fn([array, 0])
gGradCam = gBackprop[0] * attMap[..., np.newaxis]
gGradCam = (gGradCam / np.max(gGradCam))
finalOutput = (1 * np.float32(gGradCam)) + 1 * np.float32(array)
finalOutput = (finalOutput / np.max(finalOutput))
finalOutput *= 255.0
finalOutput.astype('uint8').tofile("GradCAM_outputs\\" + filename)
else:
filename = "Examples/inouts/" + example_no + ".raw"
array = np.zeros((1, voxelCount, voxelCount, voxelCount, channels))
for c in range(channels):
loadFile(array, filename, voxelCount, voxelCount, voxelCount, c)
predicted_class = cnnModel.predict(array)
print(filename, 'has a predicted class', predicted_class)
attMap = GradCAM(activationFunction, array)
import argparse
from GradCAM import GradCAM
def str2bool(v):
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.')
if __name__=="__main__":
parser = argparse.ArgumentParser(description='PyTorch GradCAM')
parser.add_argument('--img_path', type = str, defaul = "examples/elephant.png", help = 'Image Path')
#Available model list:{'alexnet', 'vgg19', 'resnet50', 'densenet169', 'mobilenet_v2' ,'wide_resnet50_2', ...}
parser.add_argument('--model_path', type = str, default = "resnet50", help = 'Choose a pretrained model or saved model (.pt)')
parser.add_argument('--select_t_layer', type = str2bool, default = 'False', help = 'Choose a target layer manually?')
arg = parser.parse_args()
gradcam_obj = GradCAM(arg.img_path,arg.model_path,arg.select_t_layer)
gradcam_obj()
from GradCAM import GradCAM
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='PyTorch GradCAM')
parser.add_argument('--img_path',
type=str,
default="examples/catdog.png",
help='Image Path')
#Pretrained model list:{'AlexNet', 'VGG19', 'ResNet50', 'DenseNet169', 'MobileNet' ,'WideResNet50'}
parser.add_argument('--model_path',
type=str,
default="VGG19",
help='Chocie a pretrained model or saved model (.pt)')
#if you use gpu or cpu, set True or False, respectly.
parser.add_argument('--cuda',
action='store_true',
default=True,
help='Use cuda or not')
parser.add_argument('--cuda_device',
type=int,
default=0,
help='Use cuda or not')
arg = parser.parse_args()
gradcam = GradCAM(arg.img_path, arg.model_path, arg.cuda_device)
gradcam()
# test accuracy
dliter = iter(dl) # dataloader iterator
accs = torch.empty(opts.ntestbatches)
for i in range(opts.ntestbatches):
letters, samples = next(dliter)
scores = net(samples.to(opts.device))
_, predictions = scores.to("cpu").max(dim=1)
acc = (predictions == letters).sum() / float(scores.size(0))
accs[i] = acc
print("accs: ", accs)
print("mean accuracy: ", float(sum(accs)) / len(accs))
# test grad-cam
GC = GradCAM(net, device=opts.device)
samples.requires_grad = True
guidemods = []
for mod in net.features:
if mod.__class__.__name__ == "ReLU":
guidemods.append(mod)
cams = GC(samples, submodule=net.features[-2], guided=guidemods)
print("cams.shape: ", cams.shape)
cams = torch.nn.Upsample(scale_factor=2,
mode="bilinear")(torch.from_numpy(cams[0]).detach())
print("cams.shape: ", cams.shape)
imlist = [cam for cam in cams] # convert first dim into list
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.')
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='PyTorch GradCAM')
parser.add_argument('--img_path',
type=str,
default="examples/catdog.png",
help='Image Path')
#Available model list:{'alexnet', 'vgg19', 'resnet50', 'densenet169', 'mobilenet_v2' ,'wide_resnet50_2', ...}
parser.add_argument('--model_path',
type=str,
default="resnet50",
help='Choose a pretrained model or saved model (.pt)')
parser.add_argument('--select_t_layer',
type=str2bool,
default='False',
help='Choose a target layer manually?')
arg = parser.parse_args()
gradcam_obj = GradCAM(img_path=arg.img_path,
model_path=arg.model_path,
select_t_layer=arg.select_t_layer)
gradcam_obj()
parser.add_argument("-se",
help="Put the selayer in the model.",
action="store_true")
args = parser.parse_args()
#load image
img = utils.image_loader(args.path)
#load model & state_dict
model = modellist(args.modelnum, seon=args.se)
model.load_state_dict(torch.load(args.state_dict_path))
if args.modelnum in range(1, 5):
model_type = 'vgg'
elif args.modelnum in range(5, 10):
model_type = 'resnet'
layer_name = 'block4'
else:
model_type = 'densenet'
model.eval()
model_dict = dict(model_type=model_type,
arch=model,
layer_name=layer_name,
input_size=(224, 224))
cam = GradCAM.GradCAM(model_dict)
mask = cam(img)
_, result = utils.visualize_cam(mask, img)
utils.imshow(result, model)
def mainMultipleImages(args, input_height, input_width):
"""
"""
resultsFile = open(
'./eval/evaluation' +
asctime(gmtime()).replace(' ', '_').replace(':', '') + '.txt', 'a')
if args.model == 'VGG16':
model = VGG16(weights='imagenet')
is_conv = 'conv'
resultsFile.write(args.model + '\n')
if args.model == 'ResNet50':
model = ResNet50(weights='imagenet')
is_conv = '_conv'
resultsFile.write(args.model + '\n')
if args.layer == 'all':
for layer in model.layers:
if is_conv in layer.name:
print('Evaluating on layer: ' + layer.name)
gradCAM = GradCAM(model, layer.name, input_height, input_width)
t_drop = 0
t_inc = 0
n_im = 0
for root, _, files in os.walk(args.folderPath):
for name in files:
path = os.path.join(root, name)
image = preProcessImage(path, args.model, input_height,
input_width)
locMap, c, _ = gradCAM.getLocalizationMap(image)
drop, inc = gradCAM.evaluate(locMap, path, c)
t_drop += drop
t_inc += inc
n_im += 1
if args.resultsPath != 'None':
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(
args.resultsPath + layer.name + '_' + name,
np.uint8(heatMap))
resultsFile.write(layer.name + '\t' + str(t_drop / n_im) +
'\t' + str(t_inc / n_im) + '\n')
resultsFile.close()
else:
if args.layer == "last":
conv_layers = []
for layer in model.layers:
if is_conv in layer.name:
conv_layers.append(layer.name)
# Take last layer
layer_name = conv_layers[-1]
else:
layer_name = args.layer
gradCAM = GradCAM(model, layer_name, input_height, input_width)
t_drop = 0
t_inc = 0
n_im = 0
for root, _, files in os.walk(args.folderPath):
for name in files:
path = os.path.join(root, name)
image = preProcessImage(path, args.model, input_height,
input_width)
locMap, c, _ = gradCAM.getLocalizationMap(image)
drop, inc = gradCAM.evaluate(locMap, path, c)
t_drop += drop
t_inc += inc
n_im += 1
if args.resultsPath != 'None':
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(args.resultsPath + layer_name + '_' + name,
np.uint8(heatMap))
resultsFile.write(layer_name + '\t' + str(t_drop / n_im) + '\t' +
str(t_inc / n_im) + '\n')
resultsFile.close()
def mainSimpleImage(args, input_height, input_width):
"""
Perform gradCAM over a single image specified in args.imagePath. The result will be saved if
args.resultsPath has been specified.
"""
if args.model == 'VGG16':
model = VGG16(weights='imagenet')
is_conv = 'conv'
if args.model == 'ResNet50':
model = ResNet50(weights='imagenet')
is_conv = '_conv'
classMap = pickle.load(open('classMap.p', 'rb'))
c = None
if args.imageClass != 'None':
c = classMap[args.imageClass]
if args.layer == 'all':
for layer in model.layers:
if is_conv in layer.name:
path = args.imagePath
image = preProcessImage(path, args.model, input_height,
input_width)
c = classMap.get(args.imageClass, args.imageClass)
if args.gradCAM:
gradCAM = GradCAM(model, layer.name, input_height,
input_width)
locMap, _, _ = gradCAM.getLocalizationMap(image, c)
if args.gradCAMpp:
gradCAM_pp = GradCAMPlusPlus(model, layer.name,
input_height, input_width)
locMap_pp, _ = gradCAM_pp.getLocalizationMap(image, c)
if args.resultsPath != 'None':
name = os.path.split(path)[-1]
if args.gradCAM:
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(
args.resultsPath + layer.name + '_' + str(c) +
'_' + name, np.uint8(heatMap))
if args.gradCAMpp:
heatMap_pp = gradCAM_pp.getHeatmap(locMap_pp, image)
plt.imsave(
args.resultsPath + layer.name + '_++_' + str(c) +
name, np.uint8(heatMap_pp))
else:
if args.layer == "last":
conv_layers = []
for layer in model.layers:
if is_conv in layer.name:
conv_layers.append(layer.name)
# Take last layer
layer_name = conv_layers[-1]
else:
layer_name = args.layer
path = args.imagePath
image = preProcessImage(path, args.model, input_height, input_width)
if args.gradCAM:
gradCAM = GradCAM(model, layer_name, input_height, input_width)
locMap, _, _ = gradCAM.getLocalizationMap(image, c)
if args.gradCAMpp:
gradCAM_pp = GradCAMPlusPlus(model, layer_name, input_height,
input_width)
locMap_pp, _ = gradCAM_pp.getLocalizationMap(image, c)
if args.resultsPath != 'None':
name = os.path.split(path)[-1]
if args.gradCAM:
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(args.resultsPath + layer_name + '_' + str(c) + name,
np.uint8(heatMap))
if args.gradCAMpp:
heatMap_pp = gradCAM_pp.getHeatmap(locMap_pp, image)
plt.imsave(
args.resultsPath + layer_name + '_++_' + str(c) + name,
np.uint8(heatMap_pp))
def perform_GradCAM(args, model, image, is_conv, genre_idx, id=0):
"""
Perform GradCAM or/ands GradCAM++over the layer specified in args.layer and it saves the result if
args.resultsPath is specified.
"""
_, input_height, input_width, _ = image.shape
if args.layer == 'all':
for layer in model.layers:
if is_conv in layer.name:
if args.gradCAM:
gradCAM = GradCAM(model, layer.name, input_height,
input_width)
locMap, _, _ = gradCAM.getLocalizationMap(image)
if args.gradCAMpp:
gradCAM_pp = GradCAMPlusPlus(model, layer.name,
input_height, input_width)
locMap_pp, _ = gradCAM_pp.getLocalizationMap(image)
if args.resultsPath != 'None':
if args.gradCAM:
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(
args.resultsPath + layer.name + '_' +
str(genre_idx) + "_" + str(id) + ".jpg",
np.uint8(heatMap))
if args.gradCAMpp:
heatMap_pp = gradCAM_pp.getHeatmap(locMap_pp, image)
plt.imsave(
args.resultsPath + layer.name + '_++_' +
str(genre_idx) + "_" + str(id) + ".jpg",
np.uint8(heatMap_pp))
else:
if args.layer == "last":
conv_layers = []
for layer in model.layers:
if is_conv in layer.name:
conv_layers.append(layer.name)
# Take last layer
layer_name = conv_layers[-1]
else:
layer_name = args.layer
if args.gradCAM:
gradCAM = GradCAM(model, layer_name, input_height, input_width)
locMap, _, _ = gradCAM.getLocalizationMap(image)
if args.gradCAMpp:
gradCAM_pp = GradCAMPlusPlus(model, layer_name, input_height,
input_width)
locMap_pp, _ = gradCAM_pp.getLocalizationMap(image)
if args.resultsPath != 'None':
if args.gradCAM:
heatMap = gradCAM.getHeatmap(locMap, image)
plt.imsave(
args.resultsPath + layer_name + '_' + str(genre_idx) +
"_" + str(id) + ".jpg", np.uint8(heatMap))
if args.gradCAMpp:
heatMap_pp = gradCAM_pp.getHeatmap(locMap_pp, image)
plt.imsave(
args.resultsPath + layer_name + '_++_' + str(genre_idx) +
"_" + str(id) + ".jpg", np.uint8(heatMap_pp))