def process_image(image_path, output_path):
explainer = GradCAM()
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
data = ([img], None)
original_image = Image.open(image_path)
width = int(original_image.size[0] / 4)
height = int(original_image.size[1] / 4)
original_image.thumbnail((width, height), Image.ANTIALIAS)
class_index, class_name, prob_value = get_predictions(img, model)
print('class_index:', class_index)
heatmap = explainer.explain(data, model, "block5_conv3", class_index)
#heatmap = explainer.explain(data, model, "block5_conv3", class_index)
# overlay the text prediction on the heatmap overlay
heatmap_with_prediction_overlayed = overlay_prediction_on_image(
array_to_PIL(heatmap), class_name[-1], prob_value[0] * 100, width,
height)
# place the images side by side
joined_image = join_images(original_image,
heatmap_with_prediction_overlayed)
joined_image.save(output_path)
def grad_cam(self, value, index):
for classe in self.labels:
grad_cam = GradCAM()
grid = grad_cam.explain((value, self.setY[index]),
self.model,
class_index=classe,
layer_name=self.target_layers)
name = "n_{}_".format(index) + str(classe) + "_grad_cam.png"
grad_cam.save(grid, ".", sg.PATH_GRAD + name)
def on_epoch_end(self, epoch, logs=None):
"""
Draw GradCAM outputs at each epoch end to Tensorboard.
Args:
epoch (int): Epoch index
logs (dict): Additional information on epoch
"""
explainer = GradCAM()
heatmap = explainer.explain(self.validation_data, self.model,
self.layer_name, self.class_index)
# Using the file writer, log the reshaped image.
with self.file_writer.as_default():
tf.summary.image("Grad CAM", np.array([heatmap]), step=epoch)
def test_should_explain_output(mocker):
mock_get_gradients = mocker.patch(
"tf_explain.core.grad_cam.GradCAM.get_gradients_and_filters",
return_value=(
[mocker.sentinel.conv_output_1, mocker.sentinel.conv_output_2],
[mocker.sentinel.guided_grads_1, mocker.sentinel.guided_grads_2],
),
)
mocker.sentinel.cam_1.numpy = lambda: mocker.sentinel.cam_1
mocker.sentinel.cam_2.numpy = lambda: mocker.sentinel.cam_2
mock_generate_output = mocker.patch(
"tf_explain.core.grad_cam.GradCAM.generate_ponderated_output",
return_value=[mocker.sentinel.cam_1, mocker.sentinel.cam_2],
)
mocker.patch(
"tf_explain.core.grad_cam.heatmap_display",
side_effect=[mocker.sentinel.heatmap_1, mocker.sentinel.heatmap_2],
)
mocker.patch("tf_explain.core.grad_cam.grid_display",
side_effect=lambda x: x)
explainer = GradCAM()
data = ([mocker.sentinel.image_1,
mocker.sentinel.image_2], mocker.sentinel.labels)
grid = explainer.explain(
data,
mocker.sentinel.model,
mocker.sentinel.class_index,
mocker.sentinel.layer_name,
mocker.sentinel.use_guided_grads,
)
for heatmap, expected_heatmap in zip(
grid, [mocker.sentinel.heatmap_1, mocker.sentinel.heatmap_2]):
assert heatmap == expected_heatmap
mock_get_gradients.assert_called_once_with(
mocker.sentinel.model,
[mocker.sentinel.image_1, mocker.sentinel.image_2],
mocker.sentinel.layer_name,
mocker.sentinel.class_index,
mocker.sentinel.use_guided_grads,
)
mock_generate_output.assert_called_once_with(
[mocker.sentinel.conv_output_1, mocker.sentinel.conv_output_2],
[mocker.sentinel.guided_grads_1, mocker.sentinel.guided_grads_2],
)
def predict_with_gradcam(model,
imgNP,
labels,
selected_labels,
layer_name='bn',
expected=None,
predictions=None,
showPlot=False):
'''
TODO: Explainer requires model to sent for every call. This may be expensive.
Need to find a way to Initialize the model or share with predict engine.
Else the memory required may double.
'''
#preprocessed_input = load_image(img, image_dir, df)
if predictions is None:
predictions = model.predict(imgNP)
#print("Loading original image")
plt.figure(figsize=(15, 10))
plt.subplot(151)
plt.title(("Original - " +
expected) if expected is not None else "Original")
plt.axis('off')
plt.imshow(imgNP[0], cmap='gray')
explainer = GradCAM()
j = 1
for i in range(len(labels)):
if labels[i] in selected_labels:
#print("Generating gradcam for class",labels[i])
#gradcam = grad_cam(model, imgNP, i, layer_name)
#print("the class index is :", i)
gradcam = explainer.explain(validation_data=(imgNP, labels),
model=model,
layer_name=layer_name,
class_index=i)
plt.subplot(151 + j)
#plt.title(labels[i]+": p="+str(predictions[0][i]))
plt.title("{:}: p={:.2f}%".format(labels[i],
predictions[0][i] * 100))
plt.axis('off')
plt.imshow(imgNP[0], cmap='gray')
plt.imshow(gradcam, cmap='jet', alpha=min(0.5, predictions[0][i]))
j += 1
if showPlot:
plt.show()
def test_should_raise_error_if_grad_cam_layer_cannot_be_found():
model = tf.keras.Sequential([
tf.keras.layers.Dense(10, input_shape=(10, ), name="dense_1"),
tf.keras.layers.Dense(1, name="dense_2"),
])
with pytest.raises(ValueError):
layer_name = GradCAM.infer_grad_cam_target_layer(model)
def test_should_produce_gradients_and_filters(convolutional_model,
random_data):
images, _ = random_data
layer_name = "activation_1"
output, grads = GradCAM.get_gradients_and_filters(convolutional_model,
images, layer_name, 0)
assert output.shape == [len(images)] + list(
convolutional_model.get_layer(layer_name).output.shape[1:])
assert grads.shape == output.shape
def test_should_ponderate_output():
grad = np.concatenate(
[np.ones((3, 3, 1)), 2 * np.ones((3, 3, 1)), 3 * np.ones((3, 3, 1))],
axis=-1)
output = np.concatenate(
[np.ones((3, 3, 1)), 2 * np.ones((3, 3, 1)), 4 * np.ones((3, 3, 1))],
axis=-1)
ponderated_output = GradCAM.ponderate_output(output, grad)
ponderated_sum = 1 * 1 + 2 * 2 + 3 * 4
expected_output = ponderated_sum * np.ones((3, 3))
np.testing.assert_almost_equal(expected_output, ponderated_output)
def save_all_explainer(validation_data,
model,
name_conv,
n_conv=1,
dir_save_im='./',
save_name='outputs'):
explainerGradCam = GradCAM()
explainerActiv = ExtractActivations()
explainerOccl = OcclusionSensitivity()
explainerSmoothGrad = SmoothGrad()
for i in range(1, n_conv + 1):
output = explainerActiv.explain(validation_data, model,
'{}_{}'.format(name_conv, i))
explainerActiv.save(output, dir_save_im,
'{}-activ-conv{}.jpg'.format(save_name, i))
output = explainerGradCam.explain(validation_data, model,
'{}_{}'.format(name_conv, i), 0)
explainerGradCam.save(output, dir_save_im,
'{}-gradCam0-conv{}.jpg'.format(save_name, i))
output = explainerSmoothGrad.explain(validation_data, model, 0)
explainerSmoothGrad.save(output, dir_save_im,
'{}-smooth0.jpg'.format(save_name))
output = explainerSmoothGrad.explain(validation_data, model, 1)
explainerSmoothGrad.save(output, dir_save_im,
'{}-smooth1.jpg'.format(save_name))
output = explainerOccl.explain(validation_data, model, 0, 5)
explainerOccl.save(output, dir_save_im,
'{}-occlSens0.jpg'.format(save_name))
output = explainerOccl.explain(validation_data, model, 1, 5)
explainerOccl.save(output, dir_save_im,
'{}-occlSens1.jpg'.format(save_name))
def test_should_generate_ponderated_output(mocker):
mocker.patch(
"tf_explain.core.grad_cam.GradCAM.ponderate_output",
side_effect=[
mocker.sentinel.ponderated_1, mocker.sentinel.ponderated_2
],
)
expected_output = [
mocker.sentinel.ponderated_1, mocker.sentinel.ponderated_2
]
outputs = [mocker.sentinel.output_1, mocker.sentinel.output_2]
grads = [mocker.sentinel.grads_1, mocker.sentinel.grads_2]
output = GradCAM.generate_ponderated_output(outputs, grads)
for real, expected in zip(output, expected_output):
assert real == expected
def explain(self,
model_input,
model,
layer_name,
class_index,
colormap=cv2.COLORMAP_INFERNO):
"""
Compute GradCAM for a specific class index.
Args:
model_input (tf.tensor): Data to perform the evaluation on.
model (tf.keras.Model): tf.keras model to inspect
layer_name (str): Targeted layer for GradCAM
class_index (int, None): Index of targeted class
colormap (int): Used in parent method signature, but ignored here
Returns:
tf.cams: The gradcams
"""
outputs, guided_grads, predictions = FEGradCAM.get_gradients_and_filters(
model, model_input, layer_name, class_index)
cams = GradCAM.generate_ponderated_output(outputs, guided_grads)
input_min = tf.reduce_min(model_input)
input_max = tf.reduce_max(model_input)
# Need to move input image into the 0-255 range
adjust_sum = 0.0
adjust_factor = 1.0
if input_min < 0:
adjust_sum = 1.0
adjust_factor /= 2.0
if input_max <= 1:
adjust_factor *= 255.0
heatmaps = [
heatmap_display(cam.numpy(),
(inp.numpy() + adjust_sum) * adjust_factor,
colormap) for cam, inp in zip(cams, model_input)
]
return heatmaps, predictions
if method_number==1: # Occlusion method - results were disappointing.
########### Method: Occlusion ################
explainer = OcclusionSensitivity() # define which type of heatmap we want
occlusion_patch_width = 20
heatmap = explainer.explain( my_data, model, my_index, occlusion_patch_width, colormap=cv2.COLORMAP_PINK )
my_title_text = 'Occlusion - patch = ' + repr(occlusion_patch_width) + ' pixels'
my_file_text = 'tf_explain_occlusion' + '_' + repr(occlusion_patch_width) #+ repr{my_row} + '{}_P{}_{}'.format('%i %i %i')
elif method_number==2:
########### Method: Grad CAM ################
### Apply GradCAM (class activation map) to the last convolution layer of the network.
explainer = GradCAM()
# find last convolution layer in model (typically 1x1 convolution)
n_layers = len(model.layers)
layer_names = [layer.name for layer in model.layers]
my_layer_name = '' # start with empty string
for i_layer in range(n_layers):
this_name = layer_names[i_layer]
if "conv" in this_name:
my_layer_name = this_name
print(my_layer_name)
# Generate result
heatmap = explainer.explain(my_data, model, my_layer_name, my_index, colormap=cv2.COLORMAP_HOT )
my_title_text = 'GradCam - Layer:' + my_layer_name
(mask, withoutMask) = model.predict(expanded_face)[0]
predicted_class = 0
label = "No Mask"
if mask > withoutMask:
label = "Mask"
predicted_class = 1
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
cv2.putText(image, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(image, (startX, startY), (endX, endY), color, 2)
st.image(image, width=640)
st.write('### ' + label)
if grad_cam_button:
data = ([face], None)
explainer = GradCAM()
grad_cam_grid = explainer.explain(
data, model, class_index=predicted_class, layer_name="Conv_1"
)
st.image(grad_cam_grid)
if occlusion_sensitivity_button:
data = ([face], None)
explainer = OcclusionSensitivity()
sensitivity_occlusion_grid = explainer.explain(data, model, predicted_class, patch_size_value)
st.image(sensitivity_occlusion_grid)
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 1])
plt.legend(loc='lower right')
test_loss, test_acc = model.evaluate(images_vali, labels_vali, verbose=2)
print(test_acc)
"""Our simple CNN has achieved a test accuracy of over 70%. Not bad for a few lines of code! For another CNN style,
see an example using the Keras subclassing API and a `tf.GradientTape`
[here](https://www.tensorflow.org/tutorials/quickstart/advanced)."""
#%%
# Instantiation of the explainer
explainer = GradCAM()
for class_index in range(7):
ind_in_images_vali = np.where(labels_vali == class_index)[0]
img_explain = images_vali[ind_in_images_vali[0:25], :, :, :]
# print(img_single.size)
data = (img_explain, None)
# Save output
output_dir = '.'
output_name = 'grad_cam_class_%d.png' % class_index
output = explainer.explain(data, model, "conv3", class_index)
explainer.save(output, output_dir, output_name)
'Do not see a bird here :/', 'Black capped chickadee', 'Blue jay',
'Brown headed cowbird F', 'brown headed cowbird M', 'Carolina wren',
'Common Grakle', 'Downy woodpecker', 'Eatern Bluebird',
'Eu starling on-duty Ad', 'Eu starling off-duty Ad', 'House finch M',
'House finch F', 'House sparrow F/Im', 'House sparrow M', 'Mourning dove',
'Caridal M', 'Cardinal F', 'Norhtern flicker (red)', 'Pileated woodpecker',
'Red winged blackbird F/Im', 'Red winged blackbird M', 'Squirrel!',
'Tufted titmouse', 'White breasted nuthatch'
]
file_list = []
label_list = []
filename_classes = "C:/Users/alert/Google Drive/ML/Databases/Birds_dB/Mappings/minimal_bird_list.txt"
LIST_OF_CLASSES = [line.strip() for line in open(filename_classes, 'r')]
explainer = GradCAM()
explainer_occ = OcclusionSensitivity()
model = load_model("E:\\KerasOutput\\run_2019_11_25_07_33\\my_keras_model.h5")
model.summary()
testDir = "C:\\Users\\alert\\Google Drive\\ML\\Electric Bird Caster\\Classified\Carolina wren\\"
files = os.listdir(testDir)
shuffle(files)
# f = "2019-11-12_07-25-14_840.jpg"
for f in files:
img_pil = image.load_img(path=testDir + f, target_size=(224, 224, 3))
expanded_image = np.expand_dims(image, axis=0)
class_names = ['Focal Leakage', 'Normal', 'Papilledema', 'Punctuate Leakage', 'Vessel Leakage']
classes = model.predict(expanded_image)[0]
(focal, normal, papilledema, punctuate, vessel) = classes
pred = list(classes)
for i in pred:
x = max(pred)
y = pred.index(x)
predicted_class_index = y
classes = class_names[y]
x = int(x*100)
st.subheader(classes + ': ' + str(x) + '%')
if grad_cam_button:
data = ([image], None)
explainer = GradCAM()
grad_cam_grid = explainer.explain(
data, model, class_index=y, layer_name="mixed7"
)
st.image(grad_cam_grid, width = 200)
if occlusion_sensitivity_button:
data = ([image], None)
explainer = OcclusionSensitivity()
sensitivity_occlusion_grid = explainer.explain(data, model, y , patch_size_value)
st.image(sensitivity_occlusion_grid, width = 200)
def test_should_infer_layer_name_for_grad_cam(model, expected_layer_name):
layer_name = GradCAM.infer_grad_cam_target_layer(model)
assert layer_name == expected_layer_name
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.inception_v3 import preprocess_input
from matplotlib import pyplot as plt
import os
import skimage
from tensorflow.keras.preprocessing import image
from random import shuffle
from tf_explain.core.grad_cam import GradCAM
# model.summary()
model = load_model("E:\\KerasOutput\\run_2019_11_25_07_33\\my_keras_model.h5")
doImageGen = True
explainer = GradCAM()
if doImageGen:
eval_test_datagen = ImageDataGenerator(
preprocessing_function=preprocess_input)
# testDir = 'C:/Users/alert/Google Drive/ML/Databases/Birds_dB/Keras2/test/'
testDir = "E:\\ML Training Data\\Keras\\test\\"
# 'C:\\Users\\alert\\Google Drive\\ML\\Databases\\Photo Booth User Group Photos\\'
# test_path = "E:\\ML Training Data\\Keras\\eval\\"
label_list = []
filename_classes = "C:/Users/alert/Google Drive/ML/Databases/Birds_dB/Mappings/minimal_bird_list.txt"
LIST_OF_CLASSES = [line.strip() for line in open(filename_classes, 'r')]
test_generator = eval_test_datagen.flow_from_directory(
def explain_tfexplain():
global graph
data = {"success": "failed"}
# # ensure an image was properly uploaded to our endpoint
if flask.request.method == "POST":
if flask.request.form.get("image"):
explainer = request.args.get("explainer")
#with graph.as_default():
model_path = flask.request.form.get("model_path")
model = load_model(model_path)
# # read the image in PIL format
image64 = flask.request.form.get("image")
image = base64.b64decode(image64)
image = Image.open(io.BytesIO(image))
image = prepare_image(image, target=(224, 224))
image = image*(1./255)
#img = tf.keras.preprocessing.image.img_to_array(image)
prediction = model.predict(image)
topClass = getTopXpredictions(prediction, 1)
print(topClass[0])
image = np.squeeze(image)
if explainer == "GRADCAM":
im = ([image], None)
from tf_explain.core.grad_cam import GradCAM
exp = GradCAM()
imgFinal = exp.explain(im, model, class_index=topClass[0][0])
#exp.save(imgFinal, ".", "grad_cam.png")
elif explainer == "OCCLUSIONSENSITIVITY":
im = ([image], None)
from tf_explain.core.occlusion_sensitivity import OcclusionSensitivity
exp = OcclusionSensitivity()
imgFinal = exp.explain(im, model,class_index=topClass[0][0], patch_size=10)
#exp.save(imgFinal, ".", "grad_cam.png")
elif explainer == "GRADIENTSINPUTS":
im = (np.array([image]), None)
from tf_explain.core.gradients_inputs import GradientsInputs
exp = GradientsInputs()
imgFinal = exp.explain(im, model, class_index=topClass[0][0])
#exp.save(imgFinal, ".", "gradients_inputs.png")
elif explainer == "VANILLAGRADIENTS":
im = (np.array([image]), None)
from tf_explain.core.vanilla_gradients import VanillaGradients
exp = VanillaGradients()
imgFinal = exp.explain(im, model, class_index=topClass[0][0])
#exp.save(imgFinal, ".", "gradients_inputs.png")
elif explainer == "SMOOTHGRAD":
im = (np.array([image]), None)
from tf_explain.core.smoothgrad import SmoothGrad
exp = SmoothGrad()
imgFinal = exp.explain(im, model, class_index=topClass[0][0])
#exp.save(imgFinal, ".", "gradients_inputs.png")
elif explainer == "INTEGRATEDGRADIENTS":
im = (np.array([image]), None)
from tf_explain.core.integrated_gradients import IntegratedGradients
exp = IntegratedGradients()
imgFinal = exp.explain(im, model, class_index=topClass[0][0])
#exp.save(imgFinal, ".", "gradients_inputs.png")
elif explainer == "ACTIVATIONVISUALIZATION":
#need some solution to find out and submit layers name
im = (np.array([image]), None)
from tf_explain.core.activations import ExtractActivations
exp = ExtractActivations()
imgFinal = exp.explain(im, model, layers_name=["activation_1"])
#exp.save(imgFinal, ".", "gradients_inputs.png")
img = pilimage.fromarray(imgFinal)
imgByteArr = inputoutput.BytesIO()
img.save(imgByteArr, format='JPEG')
imgByteArr = imgByteArr.getvalue()
img64 = base64.b64encode(imgByteArr)
img64_string = img64.decode("utf-8")
data["explanation"] = img64_string
data["prediction"] = str(topClass[0][0])
data["prediction_score"] = str(topClass[0][1])
data["success"] = "success"
return flask.Response(json.dumps(data), mimetype="text/plain")
import tensorflow as tf
from tf_explain.core.grad_cam import GradCAM
IMAGE_PATH = "./cat.jpg"
if __name__ == "__main__":
model = tf.keras.applications.vgg16.VGG16(weights="imagenet",
include_top=True)
img = tf.keras.preprocessing.image.load_img(IMAGE_PATH,
target_size=(224, 224))
img = tf.keras.preprocessing.image.img_to_array(img)
model.summary()
data = ([img], None)
tabby_cat_class_index = 281
explainer = GradCAM()
# Compute GradCAM on VGG16
grid = explainer.explain(data,
model,
class_index=tabby_cat_class_index,
layer_name="block5_conv3")
explainer.save(grid, ".", "grad_cam.png")
img /= 255.0
# Show image
plt.figure()
plt.imshow(img)
plt.axis('off')
plt.show()
# Reshape data
img = img.reshape(-1, *img.shape)
# Prepage data
data = (img, None)
label_idx = np.where(np.array(classes) == label)[0][0]
explainer = GradCAM()
grid = explainer.explain(validation_data=data,
model=model.model,
class_index=label_idx,
layer_name='conv5_block3_3_conv')
plt.figure()
plt.imshow(grid)
plt.axis('off')
plt.show()
explainer = OcclusionSensitivity()
grid = explainer.explain(validation_data=data,
model=model.model,
class_index=label_idx,
patch_size=10)
import tensorflow as tf
from tf_explain.core.grad_cam import GradCAM
IMAGE_PATH = './cat.jpg'
if __name__ == '__main__':
model = tf.keras.applications.vgg16.VGG16(weights='imagenet',
include_top=True)
img = tf.keras.preprocessing.image.load_img(IMAGE_PATH,
target_size=(224, 224))
img = tf.keras.preprocessing.image.img_to_array(img)
model.summary()
data = ([img], None)
tabby_cat_class_index = 281
explainer = GradCAM()
# Compute GradCAM on VGG16
grid = explainer.explain(data, model, 'block5_conv3',
tabby_cat_class_index)
explainer.save(grid, '.', 'grad_cam.png')
import tensorflow as tf
from tf_explain.core.grad_cam import GradCAM
IMAGE_PATH = "./cat.jpg"
if __name__ == "__main__":
model = tf.keras.applications.vgg16.VGG16(weights="imagenet",
include_top=True)
img = tf.keras.preprocessing.image.load_img(IMAGE_PATH,
target_size=(224, 224))
img = tf.keras.preprocessing.image.img_to_array(img)
print(img.shape)
model.summary()
data = ([img], None)
tabby_cat_class_index = 281
explainer = GradCAM()
# Compute GradCAM on VGG16
grid = explainer.explain(data, model, "block5_conv3",
tabby_cat_class_index)
explainer.save(grid, ".", "grad_cam.png")
plt.ylim([0.5, 1])
plt.legend(loc='lower right')
test_loss, test_acc = model.evaluate(
x=[data_input1_vali, data_input2_vali, data_input3_vali, data_input4_vali],
y=[data_output_vali],
verbose=1)
print(test_acc)
"""Our simple CNN has achieved a test accuracy of over 70%. Not bad for a few lines of code! For another CNN style,
see an example using the Keras subclassing API and a `tf.GradientTape`
[here](https://www.tensorflow.org/tutorials/quickstart/advanced)."""
#%%
# Instantiation of the explainer
explainer = GradCAM()
for class_index in range(7):
for input_index, name_of_conv in zip(
range(4),
['Conv_time_3', 'Conv_freq_3', 'Conv_spec_3', 'Conv_recc_3']):
ind_in_images_vali = np.where(labels_vali == class_index)[0]
img_explain1 = data_input1_vali[
ind_in_images_vali[0:25], :, :, :].astype('float32')
img_explain2 = data_input2_vali[
ind_in_images_vali[0:25], :, :, :].astype('float32')
img_explain3 = data_input3_vali[
ind_in_images_vali[0:25], :, :, :].astype('float32')
img_explain4 = data_input4_vali[
ind_in_images_vali[0:25], :, :, :].astype('float32')
def gradCAM(X, model, layer_name, class_index):
explainerGradCam = GradCAM()
outputs = explainerGradCam.explain((X, None), model, layer_name,
class_index)
return cv2.cvtColor(outputs, cv2.COLOR_RGB2BGR)
def write():
st.title(' Face Mask Detector')
net = load_face_detector_and_model()
model = load_cnn_model()
selected_option = st.radio("Choose", ('File', 'Webcam'))
if selected_option == 'File':
#uploaded_image = st.sidebar.file_uploader("Choose a JPG file", type="jpg")
uploaded_image = st.sidebar.file_uploader("Choose a JPG file",
type=FILE_TYPES)
confidence_value = st.sidebar.slider('Confidence:', 0.0, 1.0, 0.5, 0.1)
if uploaded_image:
image1 = Image.open(uploaded_image)
st.sidebar.image(image1,
caption='Uploaded Image.',
use_column_width=True)
#st.sidebar.info('Uploaded image:')
#st.sidebar.image(uploaded_image, width=240)
#f = open(uploaded_image, 'rb')
#file = st.file_uploader("Upload file", type=FILE_TYPES)
show_file = st.empty()
if not uploaded_image:
show_file.info("Please upload a file of type: " +
", ".join(FILE_TYPES))
return
file_type = get_file_type(uploaded_image)
if file_type == FileType.IMAGE:
show_file.image(image1)
elif file_type == FileType.PYTHON:
st.code(uploaded_image.getvalue())
else:
data = pd.read_csv(uploaded_image)
st.dataframe(data.head(10))
f = open(get_file_name(uploaded_image), 'rb')
img_bytes = f.read()
f.close()
grad_cam_button = st.sidebar.button('Grad CAM')
patch_size_value = st.sidebar.slider('Patch size:', 10, 90, 20, 10)
occlusion_sensitivity_button = st.sidebar.button(
'Occlusion Sensitivity')
image = cv2.imdecode(np.fromstring(img_bytes, np.uint8), 1)
#image = cv2.imdecode(np.fromstring(uploaded_image.read(), np.uint8), 1)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
orig = image.copy()
(h, w) = image.shape[:2]
blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300),
(104.0, 177.0, 123.0))
net.setInput(blob)
detections = net.forward()
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > confidence_value:
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
face = image[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
expanded_face = np.expand_dims(face, axis=0)
(mask, withoutMask) = model.predict(expanded_face)[0]
predicted_class = 0
label = "No Mask"
if mask > withoutMask:
label = "Mask"
predicted_class = 1
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
label = "{}: {:.2f}%".format(label,
max(mask, withoutMask) * 100)
cv2.putText(image, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(image, (startX, startY), (endX, endY), color,
2)
st.image(image, width=640)
st.write('### ' + label)
if grad_cam_button:
data = ([face], None)
explainer = GradCAM()
grad_cam_grid = explainer.explain(data,
model,
class_index=predicted_class,
layer_name="Conv_1")
st.image(grad_cam_grid)
if occlusion_sensitivity_button:
data = ([face], None)
explainer = OcclusionSensitivity()
sensitivity_occlusion_grid = explainer.explain(
data, model, predicted_class, patch_size_value)
st.image(sensitivity_occlusion_grid)
# PROGRAM FOR WEB CAM
if selected_option == 'Webcam':
labels_dict = {0: 'without_mask', 1: 'with_mask'}
color_dict = {0: (0, 0, 255), 1: (0, 255, 0)}
size = 4
webcam = cv2.VideoCapture(0) #Use camera 0
st.write("Webcam On")
stframe_cam = st.empty()
# We load the xml file
classifier = cv2.CascadeClassifier(
'src/pages/Services/frecog/haarcascade_frontalface_default.xml')
while True:
(rval, im) = webcam.read()
stframe_cam.image(im)
# st.write("Webcam Read")
#if im:
#ret, framecar = vf.read()
im = cv2.flip(im, 1, 1) #Flip to act as a mirror
# Resize the image to speed up detection
mini = cv2.resize(im, (im.shape[1] // size, im.shape[0] // size))
# detect MultiScale / faces
faces = classifier.detectMultiScale(mini)
# Draw rectangles around each face
for f in faces:
(x, y, w, h) = [v * size
for v in f] #Scale the shapesize backup
#Save just the rectangle faces in SubRecFaces
face_img = im[y:y + h, x:x + w]
resized = cv2.resize(face_img, (150, 150))
normalized = resized / 255.0
reshaped = np.reshape(normalized, (1, 150, 150, 3))
reshaped = np.vstack([reshaped])
result = model.predict(reshaped)
#print(result)
label = np.argmax(result, axis=1)[0]
cv2.rectangle(im, (x, y), (x + w, y + h), color_dict[label], 2)
cv2.rectangle(im, (x, y - 40), (x + w, y), color_dict[label],
-1)
cv2.putText(im, labels_dict[label], (x, y - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
# Show the image
stframe_cam.image('LIVE', im)
#cv2.imshow('LIVE', im)
key = cv2.waitKey(10)
# if Esc key is press then break out of the loop
if key == 27: #The Esc key
break
# Stop video
webcam.release()
# Close all started windows
cv2.destroyAllWindows()
#write()
#uploaded_image.close()
#################################### Load Data #####################################
folder = './drive/MyDrive/processed_data/'
te_data = np.load(folder+'data_test.npy')
FOV = np.load(folder+'FOV_te.npy')
te_mask = np.load(folder+'mask_test.npy')
te_data = np.expand_dims(te_data, axis=3)
print('Dataset loaded')
#te_data2 = dataset_normalized(te_data)
te_data2 = te_data /255.
explainer = GradCAM()
dataaa = (te_data2[1].reshape(1,512,512,1),None)
grid = explainer.explain(dataaa, model, class_index=1)
explainer.save(grid, ".", "grad_cam.png")
explainer = OcclusionSensitivity()
grid = explainer.explain(dataaa, model, class_index=1)
explainer.save(grid, ".", "occ_cam.png")
