Sif develop

.travis.yml

@@ -6,7 +6,7 @@ python:
 install:
  - pip3 install --upgrade setuptools==41.0.0
  - pip3 install .
- #- pip3 install -r requirements.txt
+# - pip3 install -r requirements.txt
 
 # commands to run tes
 # before_script: redis-cli ping
@@ -22,7 +22,8 @@ script:
  - python3.6 ./tests/rbm/test_Logistic_Rule_Regression.py
  - python3.6 ./tests/lime/test_lime.py
  - python3.6 ./tests/shap/test_shap.py
-
+ - python3.6 ./tests/sif/test_SIF.py
+ - python3.6 ./tests/sif/test_SIF.py
 after_success:
 # - codecov
 

README.md

@@ -26,7 +26,7 @@ We have developed the package with extensibility in mind. This library is still
 - Contrastive Explanations Method with Monotonic Attribute Functions ([Luss et al., 2019](https://arxiv.org/abs/1905.12698))
 - LIME ([Ribeiro et al. 2016](https://arxiv.org/abs/1602.04938), [Github](https://github.com/marcotcr/lime))
 - SHAP ([Lundberg, et al. 2017](http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions), [Github](https://github.com/slundberg/shap))
-
+- SIF ([Jianbo, et al. 2021](https://ojs.aaai.org/index.php/AAAI/article/view/17379/17186))
 ### Local direct explanation
 
 - Teaching AI to Explain its Decisions ([Hind et al., 2019](https://doi.org/10.1145/3306618.3314273)) 

aix360/algorithms/sif/SIF_NN.py

@@ -0,0 +1,201 @@
+from __future__ import division
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import unicode_literals
+import tensorflow as tf
+from aix360.algorithms.sif.SIF import SIFExplainer
+from aix360.datasets.SIF_dataset import DataSet
+
+
+class AllAR(SIFExplainer):
+ def __init__(self, x_dim, y_dim, time_steps, share_param, **kwargs):
+ self.time_steps = time_steps
+ self.x_dim = x_dim
+ self.cells = None
+ self.y_dim = y_dim
+ self.share_param = share_param
+ if share_param:
+ self.out_weights = tf.Variable(tf.random_normal([self.time_steps, 1]))
+ else:
+ self.out_weights = tf.Variable(tf.random_normal([self.time_steps, self.y_dim]))
+ super().__init__(**kwargs)
+
+ def get_all_params(self):
+ all_params = []
+ all_params.append(self.out_weights)
+ return all_params
+
+ def retrain(self, num_steps, feed_dict):
+ retrain_dataset = DataSet(feed_dict[self.input_index_placeholder], feed_dict[self.labels_index_placeholder])
+ for step in range(num_steps):
+ iter_feed_dict = self.fill_feed_dict_with_batch(retrain_dataset)
+ self.sess.run(self.train_op, feed_dict=iter_feed_dict)
+
+ def placeholder_inputs(self):
+ input_index_placeholder = tuple([tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='input_index_placeholder_{}'.format(i)) for i in range(self.time_steps)])
+ labels_index_placeholder = tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='labels_index_placeholder')
+ ts_placeholder = tf.placeholder(
+ tf.float32,
+ shape=[None, self.y_dim],
+ name='input_ts')
+ return input_index_placeholder, labels_index_placeholder, ts_placeholder
+
+ def inference(self, input_x, labels_placeholder=None, keep_probs_placeholder=None):
+ if self.share_param:
+ weight = tf.tile(self.out_weights, [1, self.y_dim], name='Weight')
+ else:
+ weight = self.out_weights
+ x = tf.stack([x[:, 0] for x in input_x], axis=1, name='x')
+ y_hat = tf.einsum('ijk,jk->ik', x, weight, name='y_hat')
+ return y_hat
+
+ def predictions(self, logits):
+ preds = logits
+ return preds
+
+
+class AllLSTM(SIFExplainer):
+ def __init__(self, x_dim, y_dim, time_steps, num_units, share_param, **kwargs):
+ self.time_steps = time_steps
+ self.x_dim = x_dim
+ self.num_units = num_units
+ self.cells = None
+ self.y_dim = y_dim
+ self.share_param = share_param
+ if share_param:
+ self.out_weights = tf.Variable(tf.random_normal([self.num_units, 1]))
+ self.out_bias = tf.Variable(tf.random_normal([1, 1]))
+ else:
+ self.out_weights = tf.Variable(tf.random_normal([self.num_units, self.y_dim]))
+ self.out_bias = tf.Variable(tf.random_normal([1, self.y_dim]))
+ super().__init__(**kwargs)
+
+ def get_all_params(self):
+ all_params = []
+ lstm_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="LSTM")
+ all_params += lstm_variables
+ all_params.append(self.out_weights)
+ all_params.append(self.out_bias)
+ return all_params
+
+ def retrain(self, num_steps, feed_dict):
+ retrain_dataset = DataSet(feed_dict[self.input_index_placeholder], feed_dict[self.labels_index_placeholder])
+ for step in range(num_steps):
+ iter_feed_dict = self.fill_feed_dict_with_batch(retrain_dataset)
+ self.sess.run(self.train_op, feed_dict=iter_feed_dict)
+
+
+ def placeholder_inputs(self):
+ input_index_placeholder = tuple([tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='input_index_placeholder_{}'.format(i)) for i in range(self.time_steps)])
+ labels_index_placeholder = tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='labels_index_placeholder')
+ ts_placeholder = tf.placeholder(
+ tf.float32,
+ shape=[None, self.y_dim],
+ name='input_ts')
+ return input_index_placeholder, labels_index_placeholder, ts_placeholder
+
+ def inference(self, input_x, labels_placeholder=None, keep_probs_placeholder=None):
+ if isinstance(input_x, list) | isinstance(input_x, tuple):
+ n = input_x[0].shape[2]
+ x = [tuple(x0[:, :, i] for x0 in input_x) for i in range(n)]
+ else:
+ n = input_x.shape[2]
+ x = [input_x[:, :, i] for i in range(n)]
+ with tf.variable_scope("LSTM") as vs:
+ cell = tf.nn.rnn_cell.BasicLSTMCell(self.num_units, name='LSTM_Layer')
+ def run_lstm(x_n):
+ output, _ = tf.nn.static_rnn(cell, x_n, dtype=tf.float32)
+ return tf.matmul(output[-1], self.out_weights) + self.out_bias
+ res = tf.stack(list(map(run_lstm, x)), axis=1)[:, :, 0]
+ return res
+
+ def predictions(self, logits):
+ preds = logits
+ return preds
+
+
+class AllRNN(SIFExplainer):
+ def __init__(self, x_dim, y_dim, time_steps, num_units, share_param, **kwargs):
+ self.time_steps = time_steps
+ self.x_dim = x_dim
+ self.num_units = num_units
+ self.cells = None
+ self.y_dim = y_dim
+ self.share_param = share_param
+ if share_param:
+ self.out_weights = tf.Variable(tf.random_normal([self.num_units, 1]))
+ self.out_bias = tf.Variable(tf.random_normal([1, 1]))
+ else:
+ self.out_weights = tf.Variable(tf.random_normal([self.num_units, self.y_dim]))
+ self.out_bias = tf.Variable(tf.random_normal([1, self.y_dim]))
+ super().__init__(**kwargs)
+
+ def get_all_params(self):
+ all_params = []
+ rnn_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="RNN")
+ all_params += rnn_variables
+ all_params.append(self.out_weights)
+ all_params.append(self.out_bias)
+ return all_params
+
+ def retrain(self, num_steps, feed_dict):
+ retrain_dataset = DataSet(feed_dict[self.input_index_placeholder], feed_dict[self.labels_index_placeholder])
+ for step in range(num_steps):
+ iter_feed_dict = self.fill_feed_dict_with_batch(retrain_dataset)
+ self.sess.run(self.train_op, feed_dict=iter_feed_dict)
+
+ def placeholder_inputs(self):
+ input_index_placeholder = tuple([tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='input_index_placeholder_{}'.format(i)) for i in range(self.time_steps)])
+ labels_index_placeholder = tf.placeholder(
+ tf.int32,
+ shape=(None, 1),
+ name='labels_index_placeholder')
+ ts_placeholder = tf.placeholder(
+ tf.float32,
+ shape=[None, self.y_dim],
+ name='input_ts')
+ return input_index_placeholder, labels_index_placeholder, ts_placeholder
+
+ def inference(self, input_x, labels_placeholder=None, keep_probs_placeholder=None):
+ from tensorflow.keras import layers
+ model = tf.keras.Sequential()
+ model.add(layers.Embedding(input_dim=1000, output_dim=64))
+ # The output of GRU will be a 3D tensor of shape (batch_size, timesteps, 256)
+ model.add(layers.GRU(256, return_sequences=True))
+ # The output of SimpleRNN will be a 2D tensor of shape (batch_size, 128)
+ model.add(layers.SimpleRNN(128))
+ model.add(layers.Dense(10, activation='softmax'))
+ model.summary()
+ if isinstance(input_x, list) | isinstance(input_x, tuple):
+ n = input_x[0].shape[2]
+ x = [tuple(x0[:, :, i] for x0 in input_x) for i in range(n)]
+ else:
+ n = input_x.shape[2]
+ x = [input_x[:, :, i] for i in range(n)]
+ with tf.variable_scope("RNN") as vs:
+ cell = tf.nn.rnn_cell.BasicLSTMCell(self.num_units, name='RNN_Layer')
+ def run_rnn(x_n):
+ output, _ = tf.nn.static_rnn(cell, x_n, dtype=tf.float32)
+ return tf.matmul(output[-1], self.out_weights) + self.out_bias
+
+ res = tf.stack(list(map(run_rnn, x)), axis=1)[:, :, 0]
+ return res
+
+ def predictions(self, logits):
+ preds = logits
+ return preds