def lime_explainer(image, preds): for x in preds.argsort()[0][-5:]: print(x, names[x], preds[0, x]) top_indeces.append(x) tmp = datetime.now() explainer = lime_image.LimeImageExplainer() # Hide color is the color for a superpixel turned OFF. Alternatively, if it is NONE, the superpixel will be replaced by the average of its pixels explanation = explainer.explain_instance(image, predict_fn, top_labels=5, hide_color=0, num_samples=1000) #to see the explanation for the top class temp, mask = explanation.get_image_and_mask(top_indeces[4], positive_only=True, num_features=5, hide_rest=True) im_top1 = mark_boundaries(temp / 2 + 0.5, mask) #print "iminfo",im_top1.shape, im_top1.dtype im_top1 = im_top1[:, :, (2, 1, 0)] #BGR to RGB temp1, mask1 = explanation.get_image_and_mask(top_indeces[3], positive_only=True, num_features=100, hide_rest=True) im_top2 = mark_boundaries(temp1 / 2 + 0.5, mask1) im_top2 = im_top2[:, :, (2, 1, 0)] #BGR to RGB del top_indeces[:] return im_top1, im_top2
def lime(model): #process image mnist = MNIST() image, label = mnist.get_batch(1, dataset='testing') image = image[0] image = np.concatenate((image, image, image), axis=2) print(image.shape) print('Print image:') plt.imshow(np.squeeze(image) / 2 + 0.5) plt.show() print(model.compute_error(image, expand_dims=True)) #Explain explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(image, model.compute_error, top_labels=2) print(explanation) #Show superpixels temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, hide_rest=True) #pdb.set_trace() print('Print superpixels:') marked = seg.mark_boundaries(temp / 2 + 0.5, mask).astype(np.uint8) plt.imshow(marked) plt.show()
def explain_with_lime(): for i in range(50): img = cv2.imread('data/breakout/images/breakout-' + str(i) + '.png') # Revert image to array for it in range(4): img = image.img_to_array(img[:, :, it * 3:3 * (it + 1)]) output.append(img) actions = str(f.readline()) actset.append(actions) predictions = get_prediction(output[i][i][i][0], actset[i]) explainer = lime_image.LimeImageExplainer() # Hide color is the color for a superpixel turned OFF. Alternatively, if # it is NONE, the superpixel will be replaced by the average of its pixels explanation = explainer.explain_instance(output[0][0], actset[0], model, hide_color=0, num_samples=1000) from skimage.segmentation import mark_boundaries temp, mask = explanation.get_image_and_mask(295, positive_only=True, num_features=5, hide_rest=True) fig = (mark_boundaries(temp / 2 + 0.5, mask)) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) fig.savefig("data/breakout/LIME_output/LIME_breakout.png")
def main(): # Synset words classes = get_classtable() # Images image_paths = ['samples/cat_dog.png'] images = load_images(image_paths) probs = predict(images) probs, ids = probs.sort(dim=1, descending=True) for i in range(5): print('#{}: class: {}, prob: {}'.format(i, classes[ids[0, i]], probs[0, i])) # lime explainer = lime_image.LimeImageExplainer() start = time.time() explanation = explainer.explain_instance( images[0], predict_numpy, top_labels=5, hide_color=0, num_samples=1000, ) for i in range(5): temp, mask = explanation.get_image_and_mask(explanation.top_labels[i], positive_only=True, num_features=5, hide_rest=True) img_boundary1 = mark_boundaries(temp/255.0, mask) cv2.imwrite('{}.jpg'.format(classes[ids[0, i]]), (img_boundary1[:, :, ::-1] * 255).astype(np.uint8))
def generate_explanation(model, input_image): explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(image=input_image, classifier_fn=model.predict, hide_color=0, num_samples=1000, random_seed=18) temp, mask = explanation.get_image_and_mask(label=explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=False) return temp, mask
def CalcExplainAndShow(self, id_=None): #Step 1 : Do the Calculation for the prediction using the pretrained model prediction = self.CalcProbImage(id_=id_) name_list = [] id_list = [] for x in prediction[0].argsort()[0][-2:]: name_list.insert(0, names[x].split(',')[0].capitalize()) id_list.insert(0, x) #Step 2 : Get the explanation for the prediction explainer = lime_image.LimeImageExplainer() #Step 3 : Create the button for each of the 5 best predictions button_1 = Button( self.top_complex, text=name_list[0], command=lambda: self.ExplainAndShow(name=name_list[0], id_=id_list[0], explainer=explainer, image=prediction[1]), bg="turquoise", width=27) button_1.place(x=675, y=300) button_2 = Button( self.top_complex, text=name_list[1], command=lambda: self.ExplainAndShow(name=name_list[1], id_=id_list[1], explainer=explainer, image=prediction[1]), bg="tan", width=27) button_2.place(x=675, y=330)
def get_lime(img_indices): images, labels = train_set.getbatch(img_indices) fig, axs = plt.subplots(2, 4, figsize=(15, 8)) for i, img in enumerate(images): convert_img = cv2.cvtColor( img.permute(1, 2, 0).numpy(), cv2.COLOR_RGB2BGR) axs[0][i].imshow(convert_img) for idx, (image, label) in enumerate( zip(images.permute(0, 2, 3, 1).numpy(), labels)): x = image.astype(np.double) explainer = lime_image.LimeImageExplainer() explaination = explainer.explain_instance(image=x, classifier_fn=predict, segmentation_fn=segmentation) lime_img, mask = explaination.get_image_and_mask(label=label.item(), positive_only=False, hide_rest=False, num_features=11, min_weight=0.05) axs[1][idx].imshow(lime_img) plt.show() print(labels)
def __init__(self, *argv, **kwargs): """ Initialize lime Image explainer object """ super(LimeImageExplainer, self).__init__(*argv, **kwargs) self.explainer = lime_image.LimeImageExplainer(*argv, **kwargs)
def __init__(self, model, num_samples=1000): if isinstance(model, str): self.model = load_model(model) else: self.model = model self.num_samples = num_samples self.explainer = lime_image.LimeImageExplainer()
def explain_with_lime(img_p, foolbox_model, random_seed=42): img = get_image(img_p) explainer = lime_image.LimeImageExplainer() transf_img = np.array(get_pil_transform()(img)) classifier_fn = partial(foolbox_predict, foolbox_model) explanation = explainer.explain_instance(transf_img, classifier_fn, # classification function top_labels=5, hide_color=0, random_seed=random_seed, num_samples=1000) # number of images that will be sent to classification function # temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], # positive_only=True, # num_features=5, # hide_rest=False) temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=10, hide_rest=False) print(f"Top labels for image '{img_p}':") for idx, label_idx in enumerate(explanation.top_labels, 1): print(f"\t{idx}) '{imagenet_label_dict[label_idx]} ({label_idx})'") probs = classifier_fn([transf_img]) print(f"Predicted class: {probs.argmax()}, probability: {probs.max()}") img_boundary1 = mark_boundaries(temp / 255.0, mask) return img_boundary1
def __init__(self, model: nn.Module): self.model = model self.explainer = lime_image.LimeImageExplainer(verbose=False) self.segmenter = SegmentationAlgorithm('quickshift', kernel_size=1, max_dist=200, ratio=0.2)
def explain_image(self, model, data, class_to_explain): explainer = lime_image.LimeImageExplainer() if data.shape[1] < 50: segmenter = SegmentationAlgorithm( 'quickshift', kernel_size=1, max_dist=200, ratio=0.2) explanation = explainer.explain_instance(data[0], model.predict, top_labels=self.top_labels, # hide_color=0, num_samples=self.num_samples, segmentation_fn=segmenter) else: explanation = explainer.explain_instance(data[0], model.predict, top_labels=self.top_labels, # hide_color=0, num_samples=self.num_samples) temp, mask = explanation.get_image_and_mask(class_to_explain, positive_only=False, num_features=self.num_features, hide_rest=False) return mark_boundaries(temp / 2 + 0.5, mask)
def lime_exp(): explainer = lime_image.LimeImageExplainer() # Hide color is the color for a superpixel turned OFF. Alternatively, if # it is NONE, the superpixel will be replaced by the average of its pixels # explain_instance(image, classifier_fn, labels=(1, ), hide_color=None, top_labels=5, num_features=100000, num_samples=1000, batch_size=10, qs_kernel_size=4, distance_metric='cosine', model_regressor=None) # My note: Get one explainer for now # for i in range(len(output)): explanation = explainer.explain_instance(output[0][0], actions, model, hide_color=0, num_samples=1000) from skimage.segmentation import mark_boundaries temp, mask = explanation.get_image_and_mask(295, positive_only=True, num_features=5, hide_rest=True) fig = (mark_boundaries(temp / 2 + 0.5, mask)) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) fig.savefig("output.png")
def explain(image, my_model, prediction_rank=0, show_img=True): start = time.time() explainer = lime_image.LimeImageExplainer(verbose=True) explanation = explainer.explain_instance(image, my_model.predict, top_labels=5, hide_color=0, num_samples=1000) # print(explanation) decoder = get_imagenet_to_label() print(explanation.top_labels[prediction_rank], decoder[explanation.top_labels[prediction_rank]]) temp, mask = explanation.get_image_and_mask( explanation.top_labels[prediction_rank], positive_only=False, num_features=5, hide_rest=False ) # num_features is top super pixel that gives positive value print("Explanation time", time.time() - start) if show_img: plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.show() masked_image = mark_boundaries(temp / 2 + 0.5, mask) return masked_image
def explain(input, img, y, pred_class, img_name): # Initiate explainer instance explainer = lime_image.LimeImageExplainer() # Get the explaination of an image explaination = explainer.explain_instance(image=img, classifier_fn=predict, segmentation_fn=segmentation) # Get processed image lime_img, mask = explaination.get_image_and_mask(label=y, positive_only=False, hide_rest=False, num_features=5, min_weight=0.0) # save the image lime_img = lime_img.astype('float32') lime_img = lime_img / 255 # y:real wolf == 1; pred_class: guess wolf == 1; plt.imsave(f'./explanation/{argv[1]}/{img_name[:9]}_{y}{pred_class}.jpg', lime_img) # plt.imsave(f'./explanation/random/{clas}_{y}_{img_name[:9]}_mark.jpg', mark_boundaries(lime_img, mask)) # plt.imsave(f'test.jpg', lime_img) pred = model.predict(input)[0][0] if float(pred) > 0.99 or float(pred) < 0.01: plt.imsave( f'./explanation/{argv[1]}_verysure/{img_name[:9]}_{y}{pred_class}.jpg', lime_img)
def plotLime(output_path, model, train_x, train_y): def segmentation(data): return slic(data, n_segments=100, compactness=1, sigma=1) images, labels = [ train_x[83][..., ::-1], train_x[4218], train_x[4707][..., ::-1], train_x[8598][..., ::-1] ], train_y[[83, 4218, 4707, 8598]] fig, axs = plt.subplots(1, 4) for idx, (image, label) in enumerate(zip(images, labels)): explainer = lime_image.LimeImageExplainer() explaination = explainer.explain_instance( image=image, hide_color=None, classifier_fn=model.predict_on_batch, segmentation_fn=segmentation) lime_img, mask = explaination.get_image_and_mask( label=explaination.top_labels[0], positive_only=False, hide_rest=False, num_features=11, min_weight=0.05) axs[idx].imshow(lime_img[..., ::-1] if idx == 1 else lime_img) plt.savefig(os.path.join(output_path, '5-3.png')) plt.close()
def plot_task_3(self): def predict_fn(image): image = torch.from_numpy(image[:, :, :, 0]).unsqueeze(1) pred = self.model(image) pred = pred.squeeze().detach().numpy() return pred def segmentation_fn(image): image = image.astype(np.float64) segments = slic(image, n_segments=100, compactness=10) return segments explainer = lime_image.LimeImageExplainer() for label in range(7): image = self.get_image_for_label(label, 0) image = image.squeeze().numpy() explanation = explainer.explain_instance( image, classifier_fn=predict_fn, top_labels=7, num_features=10000, segmentation_fn=segmentation_fn, random_seed=19961004) image, mask = explanation.get_image_and_mask(label, positive_only=False, num_features=5, hide_rest=False) plt.imshow(image) #plt.show() plt.savefig(os.path.join(self.output, 'fig3_{}.jpg'.format(label))) plt.close()
def explain(model, img, topLabels, numSamples, numFeatures, hideRest, hideColor, positiveOnly): img, oldImg = transform_img_fn(img) img = img*(1./255) prediction = model.predict(img) explainer = lime_image.LimeImageExplainer() img = np.squeeze(img) explanation = explainer.explain_instance(img, model.predict, top_labels=topLabels, hide_color=hideColor, num_samples=numSamples) temp, mask = explanation.get_image_and_mask(getTopPrediction(prediction[0]), positive_only=positiveOnly, num_features=numFeatures, hide_rest=hideRest) tempMask = mask * 255 temp = Image.fromarray(np.uint8(tempMask)) temp = temp.resize((oldImg.width, oldImg.height)) temp = image.img_to_array(temp) temp = temp * 1./255 temp = temp.astype(np.int64) temp = np.squeeze(temp) oldImgArr = image.img_to_array(oldImg) oldImgArr = oldImgArr * (1./255) oldImgArr = oldImgArr.astype(np.float64) imgExplained = mark_boundaries(oldImgArr, temp) imgFinal = np.uint8(imgExplained*255) img = Image.fromarray(imgFinal) imgByteArr = io.BytesIO() img.save(imgByteArr, format='JPEG') imgByteArr = imgByteArr.getvalue() return imgByteArr
def lime_exp(): print "============= LIME STARTING ============= \n" explainer = lime_image.LimeImageExplainer() # print "imgset length: ", len(imgset), '\n' # Hide color is the color for a superpixel turned OFF. Alternatively, if # it is NONE, the superpixel will be replaced by the average of its pixels # explain_instance(image, classifier_fn, labels=(1, ), hide_color=None, top_labels=5, num_features=100000, num_samples=1000, batch_size=10, qs_kernel_size=4, distance_metric='cosine', model_regressor=None) # for i in range(50): # lime_img = np.reshape(imgset[i], (1, 84, 84, 3)) # print "imgset 0: ", imgset[0] preds = get_pd(imgset[0], predictor) explanation = explainer.explain_instance(nontrans_imgset[0], preds, actset[0], hide_color=0, num_samples=1000) temp, mask = explanation.get_image_and_mask(295, positive_only=True, num_features=5, hide_rest=True) fig = (mark_boundaries(temp / 2 + 0.5, mask)) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) fig.savefig("limeoutput.png")
def LIME_explainer(model, path, preprocess_fn): """ This function takes in a trained model and a path to an image and outputs 5 visual explanations using the LIME model """ def image_and_mask(title, positive_only=True, num_features=5, hide_rest=True): temp, mask = explanation.get_image_and_mask( explanation.top_labels[0], positive_only=positive_only, num_features=num_features, hide_rest=hide_rest) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) plt.title(title) plt.show() image = imread(path) if len(image.shape) == 2: image = np.stack([image, image, image], axis=-1) image = preprocess_fn(image) image = resize(image, (hp.img_size, hp.img_size, 3)) explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(image.astype('double'), model.predict, top_labels=5, hide_color=0, num_samples=1000) # The top 5 superpixels that are most positive towards the class with the # rest of the image hidden image_and_mask("Top 5 superpixels", positive_only=True, num_features=5, hide_rest=True) # The top 5 superpixels with the rest of the image present image_and_mask("Top 5 with the rest of the image present", positive_only=True, num_features=5, hide_rest=False) # The 'pros and cons' (pros in green, cons in red) image_and_mask("Pros(green) and Cons(red)", positive_only=False, num_features=10, hide_rest=False) # Select the same class explained on the figures above. ind = explanation.top_labels[0] # Map each explanation weight to the corresponding superpixel dict_heatmap = dict(explanation.local_exp[ind]) heatmap = np.vectorize(dict_heatmap.get)(explanation.segments) plt.imshow(heatmap, cmap='RdBu', vmin=-heatmap.max(), vmax=heatmap.max()) plt.colorbar() plt.title("Map each explanation weight to the corresponding superpixel") plt.show()
def limeify(image_to_explain, trained_pipeline, class_names): logger.info("Start a LIME explanation") lime_image_probabilities = trained_pipeline.predict(np.array([image_to_explain]))[0] image_probabilities = tuple(zip(class_names, lime_image_probabilities)) logger.info( "Models predicted probabilities for image:\n" + pformat(image_probabilities) ) plt.imshow(image_to_explain) plt.show() explainer = lime_image.LimeImageExplainer() segmenter = SegmentationAlgorithm( "quickshift", kernel_size=1, max_dist=200, ratio=0.2 ) explanation = explainer.explain_instance( image_to_explain, trained_pipeline.predict, top_labels=10, num_samples=1000, segmentation_fn=segmenter, ) logger.info("Done with a LIME") temp, mask = explanation.get_image_and_mask( explanation.top_labels[0], positive_only=False, num_features=5, hide_rest=False ) plt.imshow(mark_boundaries(temp, mask)) plt.show()
def explain(self, model, image_path): image = prepare_for_prediction(model, image_path, expand_dims=False) label_onehot = model.predict(tf.expand_dims(image, 0))[0] label = tf.math.argmax(label_onehot) image = tf.cast(image, dtype=tf.float64) explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(image.numpy(), model.predict, top_labels=5, hide_color=0, num_samples=500) temp, mask = explanation.get_image_and_mask(label.numpy(), positive_only=True, num_features=5, hide_rest=True) result_image = mark_boundaries(temp / 2 + 0.5, mask) result_image = tf.image.convert_image_dtype(result_image, dtype=tf.uint8, saturate=True) image_base46 = get_base64png(result_image) result = {"label_id": float(label), "image": image_base46} return result
def estimate_gradient(self, x_tensor, target_model): """ Estimate the gradient of x_tensor on the target_model :param x_tensor: :param target_model: :return: Estimated W, Sample Radius, Samples """ def predict_fun(x): # The original gray image is change to RGB image by LIME by default. # To use the original classifier, we need to remove the channels added by LIME x = torch.tensor(x[:, :, :, 0], device=config.DEVICE, dtype=torch.float64).view(-1, self.var_num) rst = target_model.predicts(x).cpu().numpy() # Output 1 * 2 array return rst x_tensor = x_tensor.view(self.img_size, self.img_size) explainer = lime_image.LimeImageExplainer(feature_selection='none') explanation = explainer.explain_instance(x_tensor.cpu().numpy(), predict_fun, top_labels=None, hide_color=0, num_samples=self.var_num + 2, num_features=self.var_num, segmentation_fn=self.segmenter, labels=(0, 1)) self.py = explanation.local_pred # We only consider the weights related to positive labels w_lime = sorted(explanation.local_exp[1], key=lambda i: i[0]) w_lime = torch.tensor([v for _, v in w_lime], dtype=torch.float64, device=config.DEVICE).unsqueeze(0) return w_lime
def explain_multiple(model, img, topLabels, numSamples, numFeatures, hideRest, hideColor, positiveOnly): img, oldImg = transform_img_fn(img) img = img * (1. / 255) prediction = model.predict(img) explainer = lime_image.LimeImageExplainer() img = np.squeeze(img) explanation = explainer.explain_instance(img, model.predict, top_labels=topLabels, hide_color=hideColor, num_samples=numSamples) topClasses = getTopXpredictions(prediction, topLabels) explanations = [] for cl in topClasses: temp, mask = explanation.get_image_and_mask(cl[0], positive_only=positiveOnly, num_features=numFeatures, hide_rest=hideRest) imgExplained = mark_boundaries(temp, mask) img = Image.fromarray(np.uint8(imgExplained * 255)) imgByteArr = io.BytesIO() img.save(imgByteArr, format='JPEG') imgByteArr = imgByteArr.getvalue() explanations.append((cl[0], cl[1], imgByteArr)) return (explanations, len(explanations))
def explain(modelPath, img): modelPath = "C:/Users/Alex Heimerl/Desktop/test/vgg16_pokemon_100.h5" model = load_model(modelPath) img = img / 255 prediction = model.predict(img) explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(np.squeeze(img), model.predict, top_labels=2, hide_color=0, num_samples=1000) temp, mask = explanation.get_image_and_mask(getTopPrediction( prediction[0]), positive_only=True, num_features=50, hide_rest=True) imgExplained = mark_boundaries(temp, mask) img = Image.fromarray(np.uint8(imgExplained * 255)) imgByteArr = io.BytesIO() img.save(imgByteArr, format='JPEG') imgByteArr = imgByteArr.getvalue() return imgByteArr
def inception(): images = transform_img_fn_inception( [r'C:/Users/Alex Heimerl/Desktop/nova/Scripts/Capture1.jpg']) inet_model = VGG16(weights='imagenet', include_top=False) x = inet_model.output x = GlobalAveragePooling2D()(x) # let's add a fully-connected layer x = Dense(1024, activation='relu')(x) # and a logistic layer -- let's say we have 200 classes predictions = Dense(2, activation='softmax')(x) # this is the model we will train model = Model(inputs=inet_model.input, outputs=predictions) model.compile(optimizer='rmsprop', loss='categorical_crossentropy') preds = model.predict(images) print(preds) explainer = lime_image.LimeImageExplainer() # Hide color is the color for a superpixel turned OFF. Alternatively, if it is NONE, the superpixel will be replaced by the average of its pixels explanation = explainer.explain_instance(images[0] * 1. / 255, model.predict, top_labels=5, hide_color=0, num_samples=100) temp, mask = explanation.get_image_and_mask(1, positive_only=True, num_features=10, hide_rest=True) img_exp = mark_boundaries(temp, mask) plt.imshow(img_exp) plt.show()
def call_lime(predit_data, i=0): # class_names = sorted(predit_data.class_indices.items(), key=lambda pair: pair[1]) class_names = np.array([key.title() for key, value in class_names]) # final_model = combine_model() # print prediction result predicted_batch = final_model.predict(predit_data) predicted_id = np.argmax(predicted_batch, axis=-1) label_id = np.argmax(label_batch, axis=-1) print("Actual Style is: ", class_names[label_id[i]]) for j in range(0, 7, 1): print("Prediction for ", class_names[j], ": ", predicted_batch[i, j]) # explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance(image_batch[i], final_model.predict, top_labels=5, hide_color=0, num_samples=1000) # show the top class temp, mask = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=False) plt.imshow(mark_boundaries(temp / 2 + 0.5, mask)) color = "green" if predicted_id[i] == label_id[i] else "red" plt.title(class_names[label_id[i]], color=color) plt.suptitle("Model predictions (green: correct, red: incorrect)") # plt.show() # return explanation
def datscan_explain(datscan_sample): # Some imports import keras from keras.models import load_model from keras.applications.vgg16 import VGG16, preprocess_input import tensorflow as tf import numpy as np from numpy import asarray import cv2 import math import os.path IMG_SIZE = (224, 224) basename = os.path.basename(datscan_sample) save_path = './static/images/explanations/' + str(basename) vgg16 = load_model('./notebooks/spect_trained_final_1.h5') X = [] img = cv2.imread(datscan_sample) #img = cv2.imread('60.jpg') X.append(img) X = np.array(X) scan_sample = preprocess_imgs(set_name=X, img_size=IMG_SIZE) #Import LIME import lime from lime import lime_image from skimage.segmentation import mark_boundaries import matplotlib.pyplot as plt # create lime ImageExplainer explainer = lime_image.LimeImageExplainer() # Choosing the image from X_test_prep set image = scan_sample[0].astype(np.uint8) # Apply LIME to the image print("APPLYING LIME, THIS IS A CPU INTENSIVE PROCESS AND WILL TAKE TIME") explanation = explainer.explain_instance(image, vgg16.predict, top_labels=2, hide_color=0, num_samples=1000) #Arguments for get_image_and_mask() method defined below temp, mask = explanation.get_image_and_mask(0, positive_only=True, num_features=5, hide_rest=False) # Alert! You need to delete the explained.jpg file everytime you want to run an aexplanation on a new image. # Or else you will get a file overwrite error. Need to think of a fix for this. plt.imshow(mark_boundaries(temp / 2 + 0.5, mask).astype(np.uint8)) plt.imsave(save_path, mark_boundaries(temp / 2 + 0.5, mask).astype(np.uint8)) return save_path
def analyzeIoU(self, model, x_train_batch, y_train_batch, shapely_polygons_batch, num_accurate=10, num_inaccurate=10, good=0.7, bad=0.3, limit=30): """Calculates and finds images with most accurate/inaccurate IoU Args: x_train_batch (np.array): array of training images y_train_batch (np.array): array of labels (labels are 1-hot vectors) shapely_polygons_batch (np.array): array of shapely polygons for each images' obj seg num_accurate (int): number of 'accurate' segmentations to find num_inaccurate (int): number of 'inaccurate' segmentations to find good (float): minimal IoU score to be considered an 'accurate' segmentation bad (float): maximal IoU score to be considered an 'inaccurate' segmentation limit (int): number of segmentations to consider and calcIoU for Returns: info (array): contains (i, expl) tuples for IoU accepted as accurate or inaccurate i is the index of the image in x_train_batch expl is the explanation created on the corresponding ith image """ x = len(x_train_batch) assert len(y_train_batch) == x assert len(shapely_polygons_batch) == x i, acc, not_acc = 0, 0, 0 info = [] # contains tuples (i, expl) while acc < num_accurate and not_acc < num_inaccurate or i < x: explainer = lime_image.LimeImageExplainer() s = time.time() expl = explainer.explain_instance(x_train_batch[i], model.predict, top_labels=1, hide_color=0, num_samples=100, timed=True, batch_size=128, use_bandits=self.use_bandits) diff = time.time() - s s = time.time() score = calcIoU(shapely_polygons_batch[i], explainer.segments, explainer.features_to_use) print("Score: {}".format(score)) print("Explanation time: {}".format(diff)) print("Score time: {}".format(time.time() - s)) if scores <= bad: not_acc += 1 info.append((i, expl)) elif scores >= good: acc += 1 info.append((i, expl)) i += 1 return info
def explain(self, image, target_class): explainer = lime_image.LimeImageExplainer() explanation = explainer.explain_instance( image, self.model.predict, top_labels=None, labels=(target_class,), num_samples=1000) temp, mask = explanation.get_image_and_mask( target_class, positive_only=False, num_features=10, hide_rest=True) return (mask == 2).astype(int), (mask == 1).astype(int)