LIME and its Variants Tutorials - GLIME¶

Previously in LIME Tutorial Part1, we have shown how to use LIME in practice.

In this part of tutorial, we will give some analyses on LIME's stability and introduce alternatives of LIME.

Classifying Images¶

The process is the same as in Getting Started Tutorial.

Stability between GLIME and LIME¶

Since LIME depends on the samples generated from the neiborhood of the local data point, the randomness is inevitable. Worse, when the num_samples is small, the quality of LIME explanation is affected.

First, let's see the instability from LIME. We use ResNet101 from paddle.vision and repeat the LIME explanations five times.

Though LIME can identify some of the important features/superpixels on the fish, the noises are very random, which affect the explanation quality. Note that we use a small number of samples (500), and use a larger number would decrease the randomness but the computation would increase.

We introduce an alternative, named GLIME, which is proposed by our team. We show that the stability and the explanation quality are significantly improved. The paper would be released soon.

Let's see the repeated results and introduce the details in the following.

As we can see, there are still some noises but the randomness is largely decreased compared to LIME when using the same number of samples.

LIME, NormLIME, GLIME: Local vs Global¶

LIME is known as a local explanation. This means that LIME explains a single data point only. This is reasonable for complex models, such as deep neural networks.

However, global explanations have their advantages over local ones. For example, it is data independent, needs only once computation, and shows the general property of the model. But they are propably less accurate than local ones.

GLIME is a combination of local and global explanations. By introducing the prior knowledge of the global information, GLIME improves LIME through adding a regularization term when computing the proxy linear model at the local data points. Theoretical details will be introduced with the paper being public.

Here we introduce how to use GLIME.

(Optional) Compute LIME Explanations¶

Because GLIME needs a global information, we use NormLIME or AVG as the aggregation of local explanations.

This can be done through scripts/benchmark.py using the command line:

data_list="/root/datasets/ImageNet/val/\*/\*.JPEG"  # ImageNet validation set path.
n=2000  # number of images for evaluation
s=3000  # number of samples for LIME

python ./scripts/benchmark.py --name imagenet --model resnet101 --num_classes 1000 --it lime --num_images $n --data_list $data_list --it_configs="{\"num_samples\": ${s}, \"top_k\": 5}"

This would save a .npz file where the LIME results and evaluation (deletion and insertion scores) are computed.

(Optional) NormLIME and AVG Global Explanations¶

To facilate the usage of GLIME, we have already computed the LIME results and the aggregated global NormLIME and AVG explanations.

The corresponding script to compute NormLIME and AVG explanations is as follows:

import numpy as np
path = 'work_dirs/imagenet_resnet101_lime_2000.npz'
lime_results = dict(np.load(path, allow_pickle=True))
list_lime_results = [lime_results[img_path].item() for img_path in lime_results]

import paddle
from paddle.vision import resnet101
model = resnet101(pretrained=True, num_classes=1000)

import interpretdl as it
glime = it.GLIMECVInterpreter(model)

glime.compute_global_weights(g_name='normlime', list_of_lime_explanations=list_lime_results, save_path='work_dirs/imagenet_global_weights_normlime.npy')
# or glime.compute_global_weights(g_name='avg', list_of_lime_explanations=list_lime_results, save_path='work_dirs/imagenet_global_weights_avg.npy')

GLIME Usage¶

Fortunately, once the global_weights computed, we do not need to repeat the previous two steps, including computing LIME results and aggregating them.

The step to use GLIME now is as simple as use LIME.

We just need one more step to set the global weights in advance, like this:

algo = it.GLIMECVInterpreter(paddle_model)
algo.set_global_weights("/root/codespace/InterpretDL/work_dirs/imagenet_global_weights_avg.npy")

One more argument that distinguishes GLIME and LIME is the prior_method in the interpret() function. We need to set it to ridge.

Next Step¶

This is the second part of LIME and Its Variants. In this tutorial, we introduced GLIME on the vision task.

Note that LIME and GLIME can be applied to any differentiable models and any tasks, not limited in visual recognition. We have also the tutorials of NLP tasks, using Ernie2.0 in English (on NBViewer), Bert in English (on NBViewer), BiLSTM in Chinese (on NBViewer) and Ernie1.0 in Chinese (on NBViewer) as examples. For text visualizations, NBViewer gives better and colorful rendering results.

GLIME is also applicable for NLP tasks. We would deliver related tutorails in the future. Any suggestion and help are welcome.