From 53209e0653c0763f31965a379b24415832502a1d Mon Sep 17 00:00:00 2001
From: kashinkoji <chandancod88@gmail.com>
Date: Fri, 14 Jan 2022 18:39:43 +0530
Subject: [PATCH] active sampling strategy

---
 .DS_Store            | Bin 0 -> 6148 bytes
 lime/.DS_Store       | Bin 0 -> 8196 bytes
 lime/lime_base.py    |   2 +-
 lime/lime_tabular.py | 116 +++++++++++++++++++++++++++++++++++--------
 4 files changed, 96 insertions(+), 22 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 lime/.DS_Store

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..8f479f6009a6ab02b3e54b2efad10a299d2865a6
GIT binary patch
literal 6148
zcmeHK%Wl&^6upy#)=8<F1rpsLdBZM>(oj`pffVupMS_BGfd!z}jzeSNc%sB1Dj_I)
zz5o{d0^h+G@GY$1%!9~w%YqF;(OhZf%;TJK=6F1lAtKhC`g=rWBC?PK7D~u23DGao
zg~;iaZ6K3l3}{F$jp<D{yudaM#sTBN|K@=Bc8laupCal};``-2FXSG2#nx~asrpj}
zN<<q_1W@?Ujk{rr`!&P8ig5#qu`k3x4pmjEy|j+q$mn*cMUUu+j_C<?sYy>!>Y{!h
z`XTul^~a1lkKe|rmtp<Lur}!d#%xgs<2uwyvvX$|c7a07U`YKmPrCCZ;m(TZ%_bx5
z;x}&;29vl}`_6Lt!j+9p%PLu=?b0h}z-LbE#?wjD9lsE@$8J3EborR`a8-7_XF-2<
zQoh#WQS1g$e=Nm;-v{O8^C0s1tjVX5Kat}&s>8C1R`H~~JD=|#9#-u7L48rN=eO&%
zioJj9V6iA#*Kh9K>7EYH-_74IK77KY5eyr;j2(@?;WG-W3BGm4QOF}<l;CgCLzr;{
zOYgx_2QREDmPy7gu|Se`74d>Q(6yoNT>5gw(nu>NSa>l_X#{?cUej6n8B8pPq{5=4
zVnpW|zE~JZKC0^<`W0JS>pxX9L*syP;4d8z`-6=nu%U6OP;MQ_<P`u|K(h>##UBQt
zu{Aa{E)}8&!ITuJq)cBin3AL2*1U$sr9veqrY|2%Kbh$p3X@OA__m}IYbZ3ialkl`
zb|9~+WpVy@{(S#Wi%iWpU>sO02Uwx)w40ccK3gwLPMozi(kYS%!CNYn5@h-~mIZMX
d?;^=SpDhZ&hQ_5rv>?nM0cnHDj06AFfnT5N-?{(*

literal 0
HcmV?d00001

diff --git a/lime/.DS_Store b/lime/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ba48c0f1ae4e8620f5a4b52e8cd02e6a627f4b7e
GIT binary patch
literal 8196
zcmeI1&u-K(5XQ$#k+v#r`E%(7DNj&|HwaZZaOMG)W;ZN>Y&Y7?ik1V)op<0Bcs@?>
zePgqVo%Fy3Q88ZG<8|g|k3T2tIu#Ljv0J<lITMj7GVS9d6eEe(nFnbSTAsl=@FJD8
zGQ;Ownt``9m;$DNDPRhi0;a&fpaAx4rs*B~zQ1avDPRixmkRLrAw#CkgYCT4pAHmy
z1b{t2vnJGW4p1fwHV?M*R#EinPY*7jE*vqO$8kNQJ8T|o=dH)Zd0bo=*@Y8|)6v0Y
z>Mkz#)=E>r6c{SNv-^>r*(<q@&hNLc>-D^-*9AQIP`yMx|EUQzkwYnD2WBC)lsNH!
zkZnSIPl)3o0d6H%(!`{DJ|Gu}Z7XxxV5}DP&pKu!NtEvEfGp((T!}Xl<kpCItM4aL
z@<&3RfVlxxBfe|o-!$KCB<y6Fu#*ursNc7qevi;|h1r)-zd--n@fitK>~qIGj{KD@
z$4OPOPoDP3797`)v)hd7K_&ZiKi*cgX-7Hg7;_EAn9Ij~q_|VK4)L0+hJEf3Uaj0B
zLf&0-d`s^yDC$mniav$U4zpUJ_r-p0Gptvo<BzNy)s6Z%#h9gzJVT8d`SIW5+e+#<
zW-1)f5BGEuEAPw1a|hoFy{DegFY<gMpAb=jS$Gwx1@Gc_pqEf)@Z3?!sD~+f*nn>E
zDN##C<df~b^mN1mYH}zuWZFE~&RaIIU3Xzv+y5zuB~#!YDe%C@ddBnrtGnO--=i5>
zsHT7^@TUs6gUdIU7oc=kAECL+XUK1nndsMfs|bqd4*`7N|HBaV46bDIU^{Qof@CiO
MR0b<dfxoK2FIb5sa{vGU

literal 0
HcmV?d00001

diff --git a/lime/lime_base.py b/lime/lime_base.py
index d8a093173..1a3079582 100644
--- a/lime/lime_base.py
+++ b/lime/lime_base.py
@@ -204,4 +204,4 @@ def explain_instance_with_data(self,
         return (easy_model.intercept_,
                 sorted(zip(used_features, easy_model.coef_),
                        key=lambda x: np.abs(x[1]), reverse=True),
-                prediction_score, local_pred)
+                prediction_score, local_pred), easy_model
diff --git a/lime/lime_tabular.py b/lime/lime_tabular.py
index 880f3d391..b8e80545f 100644
--- a/lime/lime_tabular.py
+++ b/lime/lime_tabular.py
@@ -191,7 +191,8 @@ def __init__(self,
         self.categorical_names = categorical_names or {}
         self.sample_around_instance = sample_around_instance
         self.training_data_stats = training_data_stats
-
+        #Explainable Interpretable Model which is trained on perturbations to generate explanations
+        self.explainable_model = None
         # Check and raise proper error in stats are supplied in non-descritized path
         if self.training_data_stats:
             self.validate_training_data_stats(self.training_data_stats)
@@ -280,6 +281,9 @@ def kernel(d, kernel_width):
                                                  float(sum(frequencies)))
             self.scaler.mean_[feature] = 0
             self.scaler.scale_[feature] = 1
+            
+        self.scaled_data = None
+        self.yss = None
 
     @staticmethod
     def convert_and_round(values):
@@ -305,7 +309,7 @@ def explain_instance(self,
                          num_samples=5000,
                          distance_metric='euclidean',
                          model_regressor=None,
-                         sampling_method='gaussian'):
+                         sampling_method='gaussian', active_sampling_strategy = False, k = 50):
         """Generates explanations for a prediction.
 
         First, we generate neighborhood data by randomly perturbing features
@@ -335,30 +339,44 @@ def explain_instance(self,
                 and 'sample_weight' as a parameter to model_regressor.fit()
             sampling_method: Method to sample synthetic data. Defaults to Gaussian
                 sampling. Can also use Latin Hypercube Sampling.
+            active_sampling_strategy : if active learning sampling is to be used
+            k : number of samples through active_sampling_strategy, if applicable
 
         Returns:
             An Explanation object (see explanation.py) with the corresponding
             explanations.
         """
-        if sp.sparse.issparse(data_row) and not sp.sparse.isspmatrix_csr(data_row):
-            # Preventative code: if sparse, convert to csr format if not in csr format already
-            data_row = data_row.tocsr()
-        data, inverse = self.__data_inverse(data_row, num_samples, sampling_method)
-        if sp.sparse.issparse(data):
-            # Note in sparse case we don't subtract mean since data would become dense
-            scaled_data = data.multiply(self.scaler.scale_)
-            # Multiplying with csr matrix can return a coo sparse matrix
-            if not sp.sparse.isspmatrix_csr(scaled_data):
-                scaled_data = scaled_data.tocsr()
-        else:
-            scaled_data = (data - self.scaler.mean_) / self.scaler.scale_
-        distances = sklearn.metrics.pairwise_distances(
-                scaled_data,
-                scaled_data[0].reshape(1, -1),
-                metric=distance_metric
-        ).ravel()
+        if active_sampling_strategy == False:
+            if sp.sparse.issparse(data_row) and not sp.sparse.isspmatrix_csr(data_row):
+                # Preventative code: if sparse, convert to csr format if not in csr format already
+                data_row = data_row.tocsr()
+            data, inverse = self.__data_inverse(data_row, num_samples, sampling_method)
+            if sp.sparse.issparse(data):
+                # Note in sparse case we don't subtract mean since data would become dense
+                scaled_data = data.multiply(self.scaler.scale_)
+                # Multiplying with csr matrix can return a coo sparse matrix
+                if not sp.sparse.isspmatrix_csr(scaled_data):
+                    scaled_data = scaled_data.tocsr()
+            else:
+                scaled_data = (data - self.scaler.mean_) / self.scaler.scale_
+            distances = sklearn.metrics.pairwise_distances(
+                    scaled_data,
+                    scaled_data[0].reshape(1, -1),
+                    metric=distance_metric
+            ).ravel()
 
-        yss = predict_fn(inverse)
+            yss = predict_fn(inverse)
+            
+        else:
+            scaled_data, yss = self.active_sampling(data_row, predict_fn, num_samples, k = 10, distance_metric)
+            '''
+            This will update the dataset with batch increments to retrain the explainable model
+            '''
+            if self.scaled_data != None:
+                scaled_data = np.concatenate(self.scaled_data, scaled_data)
+                yss = np.concatenate(self.yss, yss)
+            self.scaled_data = scaled_data
+            self.yss = yss
 
         # for classification, the model needs to provide a list of tuples - classes
         # along with prediction probabilities
@@ -456,7 +474,7 @@ def explain_instance(self,
             (ret_exp.intercept[label],
              ret_exp.local_exp[label],
              ret_exp.score[label],
-             ret_exp.local_pred[label]) = self.base.explain_instance_with_data(
+             ret_exp.local_pred[label], self.explainable_model) = self.base.explain_instance_with_data(
                     scaled_data,
                     yss,
                     distances,
@@ -471,6 +489,62 @@ def explain_instance(self,
             ret_exp.local_exp[0] = [(i, -1 * j) for i, j in ret_exp.local_exp[1]]
 
         return ret_exp
+        
+    def perturbed_predictions(self, perturbed_point):
+    '''
+    Returns prediction of the explainable model or an arbitrary perturbed point. Should be useful for focussed sampling techniques used in active learning.
+    perturbed_point : a data point from the perturbed set
+    '''
+        return self.explainable_model.predict(perturbed_point)
+        
+    def generate_samples(self, data_row, predict_fn, num_samples, distance_metric = 'euclidean'):
+    
+    '''
+    Generate random samples
+    '''
+
+        if sp.sparse.issparse(data_row) and not sp.sparse.isspmatrix_csr(data_row):
+            # Preventative code: if sparse, convert to csr format if not in csr format already
+            data_row = data_row.tocsr()
+        data, inverse = self.__data_inverse(data_row, num_samples)
+        if sp.sparse.issparse(data):
+            # Note in sparse case we don't subtract mean since data would become dense
+            scaled_data = data.multiply(self.scaler.scale_)
+            # Multiplying with csr matrix can return a coo sparse matrix
+            if not sp.sparse.isspmatrix_csr(scaled_data):
+                scaled_data = scaled_data.tocsr()
+        else:
+            scaled_data = (data - self.scaler.mean_) / self.scaler.scale_
+        distances = sklearn.metrics.pairwise_distances(
+                scaled_data,
+                scaled_data[0].reshape(1, -1),
+                metric=distance_metric
+        ).ravel()
+
+        yss = predict_fn(inverse)
+
+        return scaled_data, yss, distances
+        
+    def active_sampling(data_row, predict_fn, num_samples, k, distance_metric = 'euclidean'):
+        '''
+        Active Learning approach to update the explainable AI model.
+        '''
+    
+        scaled_data, yss, distances = self.generate_samples(data_row, predict_fn, num_samples, distance_metric)
+        y_perturbations = self.perturbed_predictions(scaled_data)
+        '''
+        Select samples based on distance between predictions and original labels. This is done by treating perturbed predictions as
+        model predictions and black box predictions as original labels.
+        '''
+        uncertainty = np.abs(y_perturbations-yss)
+        sorted_indices = np.argsort(-uncertainty)
+        '''
+        Select top k samples based on distance
+        '''
+        top_k = sorted_indices[:k]
+        final_batch = scaled_data[top_k, :]
+        return final_batch, yss[top_k]
+        
 
     def __data_inverse(self,
                        data_row,