def gen_heatmap(self,
img_input,
pred_class,
gen_gif=True,
gif_fps=1,
blend_original_image=True,
norm_reverse=True,
base_dir_save='/tmp'):
gradcam = self.__grad_cam(self.model, img_input, pred_class,
self.layer_name)
jetcam = cv2.applyColorMap(np.uint8(255 * gradcam), cv2.COLORMAP_JET)
str_uuid = str(uuid.uuid1())
os.makedirs(os.path.join(base_dir_save, str_uuid), exist_ok=True)
if gen_gif:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
filename_original = os.path.join(base_dir_save, str_uuid,
'original.jpg')
cv2.imwrite(filename_original, image_original)
filename_CAM = os.path.join(base_dir_save, str_uuid,
'Grad_CAM{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, jetcam)
import imageio
mg_paths = [filename_original, filename_CAM]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(base_dir_save, str_uuid,
'Grad_CAM{}.gif'.format(pred_class))
imageio.mimsave(img_file_gif, gif_images, fps=gif_fps)
return img_file_gif
else:
if blend_original_image:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
jetcam = (np.float32(jetcam) + image_original) / 2
filename_CAM = os.path.join(base_dir_save, str_uuid,
'Grad_CAM{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, jetcam)
return filename_CAM
def server_grad_cam(model_no,
img_source,
pred,
preprocess=True,
blend_original_image=True):
model = dicts_models[model_no]['model_original']
image_size = dicts_models[model_no]['image_size']
if preprocess:
img_preprocess = my_preprocess.do_preprocess(img_source, crop_size=384)
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_preprocess, image_shape=(image_size, image_size, 3))
else:
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_source, image_shape=(image_size, image_size, 3))
penultimate_layer = get_last_conv_layer_number(model)
layer_idx = len(model.layers) - 1
modifier = 'guided' # [None, 'guided', 'relu']
# too slow
grads = visualize_cam(model,
layer_idx,
filter_indices=[pred],
seed_input=img_input,
penultimate_layer_idx=penultimate_layer,
backprop_modifier=modifier)
cam = cv2.applyColorMap(np.uint8(255 * grads), cv2.COLORMAP_JET)
if blend_original_image:
# Return to BGR [0..255] from the preprocessed image
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
# 传过来的是web目录
str_uuid = str(uuid.uuid1())
filename_CAM = os.path.join(BASE_DIR_SAVE, str_uuid,
'Grad_CAM{}.jpg'.format(pred))
if not os.path.exists(os.path.dirname(filename_CAM)):
os.makedirs(os.path.dirname(filename_CAM))
cv2.imwrite(filename_CAM, cam)
return filename_CAM
def gen_integrated_gradients(self,
img_input,
pred_class,
gen_gif=True,
gif_fps=1,
norm_reverse=True,
base_dir_save='/tmp'):
integrated_gradients = self.__get_integrated_gradients(
img_input, pred_class).numpy()
if integrated_gradients.ndim == 4:
integrated_gradients = integrated_gradients[0]
str_uuid = str(uuid.uuid1())
os.makedirs(os.path.join(base_dir_save, str_uuid), exist_ok=True)
integrated_gradients = np.mean(integrated_gradients,
axis=-1) # (299,299,3) ->(299,299)
integrated_gradients = np.maximum(integrated_gradients, 0) # ReLU
integrated_gradients /= np.max(integrated_gradients) # heatmap:0-1
# cam = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET)
filename_gradient = os.path.join(
base_dir_save, str_uuid, 'integrated_gradients{}.jpg'.format(1))
cv2.imwrite(filename_gradient, integrated_gradients * 255)
if gen_gif:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
filename_original = os.path.join(base_dir_save, str_uuid,
'original.jpg')
cv2.imwrite(filename_original, image_original)
import imageio
mg_paths = [filename_original, filename_gradient]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(
base_dir_save, str_uuid,
'integrated_gradients{}.gif'.format(pred_class))
imageio.mimsave(img_file_gif, gif_images, fps=gif_fps)
return img_file_gif
else:
return filename_gradient
def server_gradcam_plusplus(model_no,
img_source,
pred,
preprocess=True,
blend_original_image=True):
image_size = dicts_models[model_no]['image_size']
if preprocess:
img_preprocess = my_preprocess.do_preprocess(img_source, crop_size=384)
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_preprocess, image_shape=(image_size, image_size, 3))
else:
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_source, image_shape=(image_size, image_size, 3))
gradcamplus = grad_cam_plus(dicts_models[model_no]['model_original'],
img_input,
pred=pred,
image_size=image_size)
cam = cv2.applyColorMap(np.uint8(255 * gradcamplus), cv2.COLORMAP_JET)
if blend_original_image:
# Return to BGR [0..255] from the preprocessed image
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
#region 将CAM保存到文件
# 传过来的是web目录
str_uuid = str(uuid.uuid1())
filename_CAM = os.path.join(BASE_DIR_SAVE, str_uuid,
'GradCAM_PlusPlus{}.jpg'.format(pred))
if not os.path.exists(os.path.dirname(filename_CAM)):
os.makedirs(os.path.dirname(filename_CAM))
cv2.imwrite(filename_CAM, cam)
return filename_CAM
def shap_deep_explainer(self,
model_no,
num_reference,
img_input,
ranked_outputs=1,
norm_reverse=True,
blend_original_image=False,
gif_fps=1,
base_dir_save='/tmp/DeepExplain',
check_additivity=False):
#region mini-batch because of GPU memory limitation
list_shap_values = []
batch_size = self.dicts_models[model_no]['batch_size']
split_times = math.ceil(num_reference / batch_size)
for i in range(split_times):
shap_values_tmp1 = self.list_e[model_no][i].shap_values(
img_input,
ranked_outputs=ranked_outputs,
check_additivity=check_additivity)
# shap_values ranked_outputs
# [0] [0] (1,299,299,3)
# [1] predict_class array
shap_values_copy = copy.deepcopy(shap_values_tmp1)
list_shap_values.append(shap_values_copy)
for i in range(ranked_outputs):
for j in range(len(list_shap_values)):
if j == 0:
shap_values_tmp2 = list_shap_values[0][0][i]
else:
shap_values_tmp2 += list_shap_values[j][0][i]
shap_values_results = copy.deepcopy(list_shap_values[0])
shap_values_results[0][i] = shap_values_tmp2 / split_times
#endregion
#region save files
str_uuid = str(uuid.uuid1())
list_classes = []
list_images = []
for i in range(ranked_outputs):
predict_class = int(
shap_values_results[1][0][i]) #numpy int 64 - int
list_classes.append(predict_class)
save_filename = os.path.join(
base_dir_save, str_uuid,
'Shap_Deep_Explainer{}.jpg'.format(predict_class))
os.makedirs(os.path.dirname(save_filename), exist_ok=True)
list_images.append(save_filename)
pred_class_num = len(shap_values_results[0])
if blend_original_image:
if norm_reverse:
img_original = np.uint8(input_norm_reverse(img_input[0]))
else:
img_original = np.uint8(img_input[0])
img_original_file = os.path.join(os.path.dirname(list_images[0]),
'deepshap_original.jpg')
cv2.imwrite(img_original_file, img_original)
for i in range(pred_class_num):
# predict_max_class = attributions[1][0][i]
attribution1 = shap_values_results[0][i]
#attributions.shape: (1, 299, 299, 3)
data = attribution1[0]
data = np.mean(data, -1)
abs_max = np.percentile(np.abs(data), 100)
abs_min = abs_max
# dx, dy = 0.05, 0.05
# xx = np.arange(0.0, data1.shape[1], dx)
# yy = np.arange(0.0, data1.shape[0], dy)
# xmin, xmax, ymin, ymax = np.amin(xx), np.amax(xx), np.amin(yy), np.amax(yy)
# extent = xmin, xmax, ymin, ymax
# cmap = 'RdBu_r'
# cmap = 'gray'
cmap = 'seismic'
plt.axis('off')
# plt.imshow(data1, extent=extent, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
# plt.imshow(data, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
# fig = plt.gcf()
# fig.set_size_inches(2.99 / 3, 2.99 / 3) # dpi = 300, output = 700*700 pixels
plt.gca().xaxis.set_major_locator(plt.NullLocator())
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.margins(0, 0)
if blend_original_image:
plt.imshow(data,
interpolation='none',
cmap=cmap,
vmin=-abs_min,
vmax=abs_max)
save_filename1 = list_images[i]
plt.savefig(save_filename1, bbox_inches='tight', pad_inches=0)
plt.close()
img_heatmap = cv2.imread(list_images[i])
(tmp_height, tmp_width) = img_original.shape[:-1]
img_heatmap = cv2.resize(img_heatmap, (tmp_width, tmp_height))
img_heatmap_file = os.path.join(
os.path.dirname(list_images[i]),
'deepshap_{0}.jpg'.format(i))
cv2.imwrite(img_heatmap_file, img_heatmap)
dst = cv2.addWeighted(img_original, 0.65, img_heatmap, 0.35, 0)
img_blend_file = os.path.join(
os.path.dirname(list_images[i]),
'deepshap_blend_{0}.jpg'.format(i))
cv2.imwrite(img_blend_file, dst)
#region create gif
import imageio
mg_paths = [
img_original_file, img_heatmap_file, img_blend_file
]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(os.path.dirname(list_images[i]),
'deepshap_{0}.gif'.format(i))
imageio.mimsave(img_file_gif, gif_images, fps=gif_fps)
list_images[i] = img_file_gif
#endregion
else:
plt.imshow(data,
interpolation='none',
cmap=cmap,
vmin=-abs_min,
vmax=abs_max)
save_filename1 = list_images[i]
plt.savefig(save_filename1, bbox_inches='tight', pad_inches=0)
plt.close()
#endregion
return list_classes, list_images
def plot_heatmap_shap(attributions, list_images, img_input, blend_original_image):
pred_class_num = len(attributions[0])
if blend_original_image:
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
img_original = np.uint8(input_norm_reverse(img_input[0]))
import cv2
img_original = cv2.resize(img_original, (384, 384))
img_original_file = os.path.join(os.path.dirname(list_images[0]), 'deepshap_original.jpg')
cv2.imwrite(img_original_file, img_original)
for i in range(pred_class_num):
# predict_max_class = attributions[1][0][i]
attribution1 = attributions[0][i]
#attributions.shape: (1, 299, 299, 3)
data = attribution1[0]
data = np.mean(data, -1)
abs_max = np.percentile(np.abs(data), 100)
abs_min = abs_max
# dx, dy = 0.05, 0.05
# xx = np.arange(0.0, data1.shape[1], dx)
# yy = np.arange(0.0, data1.shape[0], dy)
# xmin, xmax, ymin, ymax = np.amin(xx), np.amax(xx), np.amin(yy), np.amax(yy)
# extent = xmin, xmax, ymin, ymax
# cmap = 'RdBu_r'
# cmap = 'gray'
cmap = 'seismic'
plt.axis('off')
# plt.imshow(data1, extent=extent, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
# plt.imshow(data, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
# fig = plt.gcf()
# fig.set_size_inches(2.99 / 3, 2.99 / 3) # dpi = 300, output = 700*700 pixels
plt.gca().xaxis.set_major_locator(plt.NullLocator())
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
plt.margins(0, 0)
if blend_original_image:
# cv2.imwrite('/tmp5/tmp/cv2.jpg', np.uint8(img_input[0]))
# img_original = cv2.cvtColor(np.uint8(img_input[0]), cv2.COLOR_BGR2RGB)
# plt.imshow(img_original)
plt.imshow(data, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
save_filename1 = list_images[i]
plt.savefig(save_filename1, bbox_inches='tight', pad_inches=0)
plt.close()
img_heatmap = cv2.imread(list_images[i])
img_heatmap = cv2.resize(img_heatmap, (384, 384))
img_heatmap_file = os.path.join(os.path.dirname(list_images[i]), 'deepshap_{0}.jpg'.format(i))
cv2.imwrite(img_heatmap_file, img_heatmap)
dst = cv2.addWeighted(img_original, 0.65, img_heatmap, 0.35, 0)
# cv2.imwrite('/tmp5/tmp/aaaaa.jpg', dst) #test code
img_blend_file = os.path.join(os.path.dirname(list_images[i]), 'deepshap_blend_{0}.jpg'.format(i))
cv2.imwrite(img_blend_file, dst)
# fig.savefig('/tmp5/tmp/aaa1.png', format='png', dpi=299, transparent=True, pad_inches=0)
# plt.savefig('/tmp5/tmp/aaa.jpg', bbox_inches='tight', pad_inches=0)
#region create gif
import imageio
mg_paths = [img_original_file, img_heatmap_file, img_blend_file]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(os.path.dirname(list_images[i]), 'deepshap_{0}.gif'.format(i))
imageio.mimsave(img_file_gif, gif_images, fps=GIF_FPS)
list_images[i] = img_file_gif
#endregion
else:
plt.imshow(data, interpolation='none', cmap=cmap, vmin=-abs_min, vmax=abs_max)
save_filename1 = list_images[i]
plt.savefig(save_filename1, bbox_inches='tight', pad_inches=0)
plt.close()
def server_cam(model_no,
img_source,
pred,
cam_relu=True,
preprocess=True,
blend_original_image=True):
image_size = dicts_models[model_no]['image_size']
if preprocess:
img_preprocess = my_preprocess.do_preprocess(img_source, crop_size=384)
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_preprocess, image_shape=(image_size, image_size, 3))
else:
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_source, image_shape=(image_size, image_size, 3))
#region generate CAM
model1 = dicts_models[model_no]['model_cam']
all_amp_layer_weights = dicts_models[model_no]['all_amp_layer_weights']
last_conv_output, pred_vec = model1.predict(img_input)
# pred = np.argmax(pred_vec) # get model's prediction class
# Remove single-dimensional entries from the shape of an array.
last_conv_output = np.squeeze(last_conv_output)
# get AMP layer weights
amp_layer_weights = all_amp_layer_weights[:, pred] # dim: (2048,)
# jijie add relu
# 对于每一个类别C，每个特征图K的均值都有一个对应的w
if cam_relu:
amp_layer_weights = np.maximum(amp_layer_weights, 0)
cam_small = np.dot(last_conv_output, amp_layer_weights) # dim: 224 x 224
cam_small = np.maximum(cam_small, 0) # ReLU
cam = cv2.resize(cam_small, (image_size, image_size)) # 14*14 224*224
heatmap = cam / np.max(cam) # heatmap:0-1
#cam: 0-255
cam = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET)
if blend_original_image:
# Return to BGR [0..255] from the preprocessed image
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
#endregion
#region 将CAM保存到文件
str_uuid = str(uuid.uuid1())
filename_CAM = os.path.join(BASE_DIR_SAVE, str_uuid,
'CAM{}.jpg'.format(pred))
if not os.path.exists(os.path.dirname(filename_CAM)):
os.makedirs(os.path.dirname(filename_CAM))
cv2.imwrite(filename_CAM, cam)
# endregion
return filename_CAM
def gen_heatmap(self,
img_input,
pred_class,
gen_gif=True,
gif_fps=1,
blend_original_image=True,
norm_reverse=True,
base_dir_save='/tmp'):
# gradcamplus: 0-1
gradcamplus = self.__grad_cam_plusplus(img_input,
pred_class=pred_class)
# cam: 0-255
cam = cv2.applyColorMap(np.uint8(255 * gradcamplus), cv2.COLORMAP_JET)
str_uuid = str(uuid.uuid1())
os.makedirs(os.path.join(base_dir_save, str_uuid), exist_ok=True)
if gen_gif:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
filename_original = os.path.join(base_dir_save, str_uuid,
'original.jpg')
cv2.imwrite(filename_original, image_original)
filename_CAM = os.path.join(
base_dir_save, str_uuid,
'GradCAM_PlusPlus{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, cam)
import imageio
mg_paths = [filename_original, filename_CAM]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(
base_dir_save, str_uuid,
'GradCAM_PlusPlus{}.gif'.format(pred_class))
imageio.mimsave(img_file_gif, gif_images, fps=gif_fps)
return img_file_gif
else:
if blend_original_image:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
filename_CAM = os.path.join(
base_dir_save, str_uuid,
'GradCAM_PlusPlus{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, cam)
return filename_CAM
def gen_heatmap(self,
img_input,
pred_class,
cam_relu=True,
gen_gif=True,
gif_fps=1,
blend_original_image=True,
norm_reverse=True,
base_dir_save='/tmp'):
height, width = img_input.shape[1], img_input.shape[2]
last_conv_output = self.model_last_conv.predict(img_input)
last_conv_output = np.squeeze(last_conv_output)
# get AMP layer weights
amp_layer_weights = self.all_amp_layer_weights[:,
pred_class] # dim: (2048,)
if cam_relu:
amp_layer_weights = np.maximum(amp_layer_weights, 0)
cam_small = np.dot(last_conv_output,
amp_layer_weights) # dim: 224 x 224
cam = cv2.resize(cam_small, (width, height)) # 14*14 224*224
cam = np.maximum(cam, 0) # ReLU
heatmap = cam / np.max(cam) # heatmap:0-1
# cam:0-255
cam = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET)
str_uuid = str(uuid.uuid1())
os.makedirs(os.path.join(base_dir_save, str_uuid), exist_ok=True)
if gen_gif:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
filename_original = os.path.join(base_dir_save, str_uuid,
'original.jpg')
cv2.imwrite(filename_original, image_original)
filename_CAM = os.path.join(base_dir_save, str_uuid,
'CAM{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, cam)
import imageio
mg_paths = [filename_original, filename_CAM]
gif_images = []
for path in mg_paths:
gif_images.append(imageio.imread(path))
img_file_gif = os.path.join(base_dir_save, str_uuid,
'CAM{}.gif'.format(pred_class))
imageio.mimsave(img_file_gif, gif_images, fps=gif_fps)
return img_file_gif
else:
if blend_original_image:
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
if norm_reverse:
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
cam = (np.float32(cam) + image_original) / 2
filename_CAM = os.path.join(base_dir_save, str_uuid,
'CAM{}.jpg'.format(pred_class))
cv2.imwrite(filename_CAM, cam)
return filename_CAM
def server_gradcam_plusplus(dicts_models,
model_no,
img_source,
pred,
preprocess=True,
blend_original_image=True,
base_dir_save='/tmp3'):
image_size = dicts_models[model_no]['image_size']
# region preprocessing if needed, convert to input_tensor
if isinstance(img_source, str):
if preprocess:
img_preprocess = my_preprocess.do_preprocess(img_source,
crop_size=384)
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_preprocess, image_shape=(image_size, image_size, 3))
else:
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_source, image_shape=(image_size, image_size, 3))
if isinstance(img_source, np.ndarray):
if img_source.ndim == 4:
img_input = img_source
# endregion
#region generating clas activation maps
#gradcamplus: 0-1
gradcamplus = grad_cam_plus(dicts_models[model_no]['model_original'],
img_input,
pred=pred,
image_size=image_size)
# cam: 0-255
cam = cv2.applyColorMap(np.uint8(255 * gradcamplus), cv2.COLORMAP_JET)
#endregion
#region blend original image
if blend_original_image:
# Return to BGR [0..255] from the preprocessed image
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
#endregion
#region 将CAM保存到文件
# 传过来的是web目录
str_uuid = str(uuid.uuid1())
filename_CAM = os.path.join(base_dir_save, str_uuid,
'GradCAM_PlusPlus{}.jpg'.format(pred))
if not os.path.exists(os.path.dirname(filename_CAM)):
os.makedirs(os.path.dirname(filename_CAM))
cv2.imwrite(filename_CAM, cam)
return filename_CAM
def server_grad_cam(dicts_models,
model_no,
img_source,
pred,
preprocess=True,
blend_original_image=True,
base_dir_save='/tmp3'):
model = dicts_models[model_no]['model_original']
image_size = dicts_models[model_no]['image_size']
#region preprocessing if needed, convert to input_tensor
if isinstance(img_source, str):
if preprocess:
img_preprocess = my_preprocess.do_preprocess(img_source,
crop_size=384)
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_preprocess, image_shape=(image_size, image_size, 3))
else:
img_input = LIBS.ImgPreprocess.my_image_helper.my_gen_img_tensor(
img_source, image_shape=(image_size, image_size, 3))
if isinstance(img_source, np.ndarray):
if img_source.ndim == 4:
img_input = img_source
#endregion
#region generating class activation maps
penultimate_layer = get_last_conv_layer_number(model)
layer_idx = len(model.layers) - 1
modifier = 'guided' # [None, 'guided', 'relu']
# too slow
grads = visualize_cam(model,
layer_idx,
filter_indices=[pred],
seed_input=img_input,
penultimate_layer_idx=penultimate_layer,
backprop_modifier=modifier)
cam = cv2.applyColorMap(np.uint8(255 * grads), cv2.COLORMAP_JET)
#endregion
if blend_original_image:
# Return to BGR [0..255] from the preprocessed image
image_original = img_input[0, :]
from LIBS.ImgPreprocess.my_image_norm import input_norm_reverse
image_original = input_norm_reverse(image_original)
image_original = image_original.astype(np.uint8)
image_original -= np.min(image_original)
image_original = np.minimum(image_original, 255)
cam = np.float32(cam) + np.float32(image_original)
cam = 255 * cam / np.max(cam)
#region save CAMs to files
str_uuid = str(uuid.uuid1())
filename_CAM = os.path.join(base_dir_save, str_uuid,
'Grad_CAM{}.jpg'.format(pred))
if not os.path.exists(os.path.dirname(filename_CAM)):
os.makedirs(os.path.dirname(filename_CAM))
cv2.imwrite(filename_CAM, cam)
#endregion
return filename_CAM
