CFRL Feature condition autoencoder

[HeyItsBethany3]

Hi Team,

Firstly I want to say thank you so much for implementing a truly model-agnostic method for counterfactuals! I've been searching for many months now for a counterfactual tool I can easily use for GBMs and it made my day when I found this method.

I have implemented the CFRL method on a simple model with 12 features, but the counterfactuals are not very sparse, usually sparsity is around 9 or 10. I tried specifying more features to be immutable to enforce sparsity which is not ideal. Is there a way to add feature conditioning into the autoencoder? I am concerned that if I train the autoencoder on 12 variables and then fix 6 variables for instance, the autoencoder may have found important patterns in the variables that I then remove at a later stage.

Do you have any other advice on how to improve sparsity?
I have changed the loss function coefficients but results didn't vary too much. I don't have much experience with tuning autoencoders too. Do you have any advice on the best parameters to start with or focus on, that would make the most difference?

Thank you so much for your help!
Bethany

[RobertSamoilescu]

Hi @HeyItsBethany3. It would be ideal if you can share some code/notebook and the data to have more context and identify the problem. Thank you!

[HeyItsBethany3]

Hi @RobertSamoilescu. I can't show the code explicitly as it's confidential data. I'm predicting credit risk using a simple GBM model. The code is essentially exactly the same as the alibi example for the Adult CFLR dataset. https://docs.seldon.io/projects/alibi/en/latest/examples/cfrl_adult.html
I have restricted age to [0, 5] and I am varying the immutable features. Currently my HIDDEN_DIM is 10 and LATENT_DIM is 8. I have 2000 elements in my data (500 test data). There are 70 instances predicted as bad risk and 430 predicted as good risk so it is a relatively unbalanced dataset.
Let me know if there's any other specific information I can give to help. Thanks so much for your help!

[RobertSamoilescu]

One reason for poor sparsity would be a bad autoencoder. If the reconstruction is bad, I would expect the counterfactuals to be far from the input.

Some things to look for:

• make sure that the numerical features are standardized and the categorical ones are one-hot encoded.
• plot the mean reconstruction error over all numerical features and the mean accuracy over all categorical features for the train and validation dataset (make sure that you don't overfit on the training dataset).
• make sure that the reconstruction loss is small (low value for numerical features and high accuracy for categorical features)
• I would keep the hidden_dim=128 and play around first with the latent_dim (some small values 4, 5, 6, 7 ... ). If you overfit (see the validation loss going up) then try reducing the hidden_dim to 64, 32, ... .
• If you still overfit, you can drop the hidden_dim.

Let me know if this works and maybe you can share some plots with the training & validation error.

[HeyItsBethany3]

@RobertSamoilescu Thanks so much, this was very helpful.

Eventually I reduced the dimensions to hidden_dim=8 and latent_dim=4. This reduced sparsity from around 9 or 10 to around 6 and 7. It also reduced the distance between the counterfactual and the original instance. My dataset is unbalanced - there is more data for good credit risk than for bad credit risks, so the counterfactuals are better for the good risk instances.

A couple more questions:

• When I use the autoencoder, I pass in x_one_hot_encoded, with size (1,23). The autoencoder returns a reconstructed x of the same size (1,23). How do I then calculate the mean accuracy over all categorical features? How do you convert the reconstructed x back to meaningful categorical variables?
  I just found the mean reconstruction error for all of the features regardless of whether they were meant to be numerical or not.
• What do you mean by drop hidden_dim? I tried to create the autoencoder without it but it said it was a necessary parameter.
• Do you know if it's possible to specify in the autoencoder itself which features are immutable/restricted?

Thanks for your help!

[RobertSamoilescu]

1. When using a heterogeneous dataset (i.e., a dataset having both numerical and categorical variables) then you need to use the heterogenous autoencoder as in the adult example. The output of the heterogeneous autoencoder(HeAE) has a special format, as it returns a list where:
   • the first element in the list corresponds to a concatenation of the reconstruction for all numerical features
   • the rest of the elements correspond to each categorical features (one for each categorical feature).

For example, if we have 3 numerical features and 2 categorical features, where the categorical features can take 3 and 4 values respectively, then the output of the heterogeneous HeAE would look like: [[num1 num2 num3], [cat11, cat12, cat13], [cat21, cat22, cat23, cat24]] (remember that categorical variables are one-hot-encoded and hence this representation). To check how good the reconstruction is for a categorical variable, you can take the argmax of the corresponding head (i.e., for categorical variable 1, take argmax([cat11, cat12, cat13]) and check if it is a match with the input value). Note that using a heterogenous autoencoder is essential when having a mixture of numerical and categorical ones as the reconstruction for the numerical features is using the MeanSquaredError loss while for the categorical ones is using the SparseCorssentropy loss. From what I understand, you are dealing with a heterogeneous dataset but somehow the output of the autoencoder you are using does not correspond to what I described above, so I believe that there might be something wrong with your implementation.

2. The mapping of the reconstruction should now be clear:
   • Numerical variables should stay the same if you are using the standardized representation (which I recommend when checking the reconstruction error). Otherwise, you have to multiply by the standard deviation and add the mean if you want to work in the original input space.
   • For the categorical variables, you should just take the argmax to recover the original values (as described above)
   • As an extra step, you may want to rearange the columns in the original order.

Note that everything I am describing here can be done with the heae_preprocessor and the heae_inv_preprocessor (including, rearanging the columns). The heae_preprocessor should standardize numerical features and transform the categorical ones into a one-hot representation, while the heae_inv_preprocessor should map them back to the original input space.

3. If your dataset is unblanced, I recommend you to try to balance it.

4. It is true that the current implementation in alibi does not support to drop the hidden layer. Although you can define your own encoder/decoder modules to fit your problem as in here.

5. Note that there is no need to specify immutable features for the autoencoder. The autoencoder is just a tool that the main CFRL algorithm uses. The immutability should only be specified for the CFRL algorithm.

[HeyItsBethany3]

Thank you for this, this was so helpful. A couple more questions:

• When you use diverse=True to generate many counterfactuals eg.100 per instance, there is a different set of counterfactuals returned each time. Is there a way to set a seed for this randomness and what is determining this randomness?
• I've also been using anchors for the credit model with tabular data. Is there a way to generate multiple anchors for one instance? Is there a way to exclude features we wouldn't like to include in the anchor?
  Thank you so much for your help, it's been invaluable.

[RobertSamoilescu]

1. To make the diversity run deterministic, you can simply set the seed through numpy as follows:

np.random.seed(0)
explanation = explainer.explain(X=X, Y_t=Y_t, C=C, diversity=True, num_samples=100, batch_size=10)

As mentioned in the paper, at its core, the CF-RL is not really designed to generate a diverse counterfactual due to the determinstic nature of the DDPG. Although we can enforce some diversity by playing a bit with the conditional vector (please see the paper for a detailed explanation). The randomness comes from the construction of the conditional vector:

alibi/alibi/explainers/backends/cfrl_tabular.py

Lines 676 to 679 in e696906

	if diverse:
	# Note that this is still a feasible counterfactual
	X_low_ohe[:, i] *= np.random.rand(*X_low_ohe[:, i].shape)
	X_high_ohe[:, i] *= np.random.rand(*X_high_ohe[:, i].shape)

alibi/alibi/explainers/backends/cfrl_tabular.py

Lines 754 to 756 in e696906

	if diverse:
	# Note that by masking random entries we still have a feasible counterfactual
	mask *= np.random.randint(low=0, high=2, size=mask.shape)

2. Unfortunately, alibi does not support the generation of multiple anchor nor to exclude some features from the anchor. Although I believe that with a bit of engineering, you can do both. I will try to provide some guidance on how to achieve this if you are interested.

2.a. The implementation in alibi returns the anchor with the maximum coverage as it can be seen in here:

alibi/alibi/explainers/anchor_base.py

Lines 784 to 789 in e696906

	if better_anchors.size > 0:
	best_anchor_idx = better_anchors[np.argmax(coverages[better_anchors])]
	best_coverage = coverages[best_anchor_idx]
	best_anchor = anchors[candidate_anchors[best_anchor_idx]]
	if best_coverage == 1. or stop_on_first:
	break

I believe you can play around with this and retain all the anchors that might be of interest.
Furthermore, it is worth looking how those variables evolve throughout the runtime:

alibi/alibi/explainers/anchor_base.py

Lines 695 to 696 in e696906

	best_of_size = {0: []} # type: Dict[int, list]
	best_anchor = ()

2.b. The generation of potential anchor is performed in here:

alibi/alibi/explainers/anchor_base.py

Line 705 in e696906

anchors = self.propose_anchors(best_of_size[current_size - 1])

If you go inside the function, you can see that each anchor is constructed by adding one feature at a time:

alibi/alibi/explainers/anchor_base.py

Lines 386 to 387 in e696906

	tuples = [(x,) for x in all_features]
	for x in tuples:

alibi/alibi/explainers/anchor_base.py

Lines 399 to 403 in e696906

	for f in all_features:
	for t in previous_best:
	new_t = self._sort(t + (f,), allow_duplicates=False)
	if len(new_t) != len(t) + 1: # Avoid repeating the same feature ...
	continue

I think you can exclude some features by removing them from the all_features variable defined here:

alibi/alibi/explainers/anchor_base.py

Line 378 in e696906

all_features = range(state['n_features'])

You will have to check that those changes do not break something else. For example, reducing the number of features will reduce the size of the maximum anchor. Thus, you may need to change the following line:

alibi/alibi/explainers/anchor_base.py

Line 699 in e696906

max_anchor_size = self.state['n_features']

to something like:

max_anchor_size = self.state['n_features'] - number_excluded features

I haven't tested any of the suggested changes related to anchor, so there might be some potential issues that I did not consider.
It would be great if you can maybe open another issue related to those anchor extensions and provided a use case where you might need multiple anchors or exclude some features from the anchor.

[HeyItsBethany3]

Thank you so much for this - I will implement it and let you know how it goes.

[HeyItsBethany3]

Hi @RobertSamoilescu, I hope you are well!
I am implementing this method for a different model. The categorical columns are ordinal encoded but not one hot encoded.
Do I need to one hot encode them for the method to work?

I am getting an error trying to fit the autoencoder:

  File ".../cf_explainer.py", line 96, in autoencoder
    heae.fit(trainset, epochs=config.EPOCHS)
  File ".../python3.8/site-packages/keras/utils/traceback_utils.py", line 67, in error_handler
    raise e.with_traceback(filtered_tb) from None
  File ".../python3.8/site-packages/tensorflow/python/framework/func_graph.py", line 1129, in autograph_handler
    raise e.ag_error_metadata.to_exception(e)
ValueError: in user code:

    File ".../python3.8/site-packages/keras/engine/training.py", line 878, in train_function  *
        return step_function(self, iterator)
    File ".../python3.8/site-packages/keras/engine/training.py", line 867, in step_function  **
        outputs = model.distribute_strategy.run(run_step, args=(data,))
    File ".../python3.8/site-packages/keras/engine/training.py", line 860, in run_step  **
        outputs = model.train_step(data)
    File ".../python3.8/site-packages/keras/engine/training.py", line 809, in train_step
        loss = self.compiled_loss(
    File ".../python3.8/site-packages/keras/engine/compile_utils.py", line 201, in __call__
        loss_value = loss_obj(y_t, y_p, sample_weight=sw)
    File ".../python3.8/site-packages/keras/losses.py", line 141, in __call__
        losses = call_fn(y_true, y_pred)
    File ".../python3.8/site-packages/keras/losses.py", line 245, in call  **
        return ag_fn(y_true, y_pred, **self._fn_kwargs)
    File ".../python3.8/site-packages/keras/losses.py", line 1204, in mean_squared_error
        return backend.mean(tf.math.squared_difference(y_pred, y_true), axis=-1)

    ValueError: Dimensions must be equal, but are 110 and 108 for '{{node mean_squared_error/SquaredDifference}} = SquaredDifference[T=DT_FLOAT](he_ae/adult_decoder/dense_3/BiasAdd, Cast)' with input shapes: [128,110], [128,108].

Do you have any suggestions why this might be erroring?
Thank you

[RobertSamoilescu]

@HeyItsBethany3, I believe that you have two options:

1. treat ordinal features as categorical and use one-hot-encoding -- same as you did before.
2. since the features are ordinal, there exists an implicit ordering of their values. Thus, you can treat them as numerical features and the autoencoder will regress on them using MSE loss. Furthermore, the autoencoder allows you to specify the type of the numerical features (i.e., int or float). In your case, since the ordinal features have discrete values, you have to set them as int. Just do not forget to remove them from the list/dictionary of categorical variables (i.e., category_map) - that's where the error may come from.

For the second case, you should not worry about the range when applying the CFRL (i.e., the autoencoder may output a value of 8 for an ordinal feature, but the maximum is 7). It is guaranteed that the CFRL won't go outside the range and will consider only values from 0 to 7, where 0 is the minimum value.

[HeyItsBethany3]

@RobertSamoilescu Thanks so much, this is really helpful.
One more quick question - do missing values (NaN) need to be handled for use with Alibi packages, particularly with anchor_tabular?

[RobertSamoilescu]

@HeyItsBethany3, please check issues #391 and #516.

As you see in issue #391, AnchorTabular does not work with NaN values. You can either drop the rows or use your preferred imputation method (e.g., mean, median, etc) to replace the NaN values.

Categorical variables are expected to be labeled or one-hot encoded. In this situation, you can consider NaN as a possible value. For example, let's say that you have a categorical feature that can take 2 string values: ['a', 'b'], but you have some instances for which you have NaN. Instead of using an imputation method (e.g., mode), you can replace all NaN's with '?'. Thus your categorical features will have three values: ['a', 'b', '?']. Then you can label encode it and pass it AnchorTabular. Just keep in mind that your predictive model should be able to deal with this workaround as it will be queried many times by the AnchorTabular algorithm.

[HeyItsBethany3]

@RobertSamoilescu Thanks so much for your help. I decided to implement both approaches and compare them.
At the moment I one hot encoding my categorical variables before passing it through the model but am still getting a similar error as to above:
ValueError: Dimensions must be equal, but are 110 and 147 for '{{node mean_squared_error/SquaredDifference}} = SquaredDifference[T=DT_FLOAT](he_ae/adult_decoder/dense_3/BiasAdd, Cast)' with input shapes: [128,110], [128,147].
The number of categorical variables is 9 (so there are now 48 columns of this with it being one hot encoded).

I am a bit confused as to how to create the autoencoder given that this example encodes the categorical variable as part of the prediction function.
This is my code below:

       original_data = self.data.xTrain.reset_index()
        encoded_xTrain = self.encoder.encode(original_data)

        heae_preprocessor, heae_inv_preprocessor = get_he_preprocessor(X=encoded_xTrain,
                                                               feature_names=self.encoder.transformed_columns,
                                                               category_map=self.category_map,
                                                               feature_types=self.feature_types)

        trainset_input = heae_preprocessor(encoded_xTrain).astype(np.float32)
        trainset_outputs = {
            "output_1": encoded_xTrain[:, len(self.categorical_ids):] # Numerical data
        }
        for i, cat_id in enumerate(self.categorical_ids):
            trainset_outputs.update({
                f"output_{i+2}": encoded_xTrain[:, cat_id]
            })

        trainset = tf.data.Dataset.from_tensor_slices((trainset_input, trainset_outputs))
        trainset = trainset.shuffle(1024).batch(128, drop_remainder=True)

        # Define autoencoder path and create dir if it doesn't exist.
        heae_path = os.path.join("tensorflow", "credit_autoencoder")
        if not os.path.exists(heae_path):
            os.makedirs(heae_path)

        # Define the heterogeneous auto-encoder
        heae = HeAE(encoder=ADULTEncoder(hidden_dim=config.HIDDEN_DIM, latent_dim=config.LATENT_DIM),
                decoder=ADULTDecoder(hidden_dim=config.HIDDEN_DIM, output_dims=self.OUTPUT_DIMS))

        # Define loss functions
        he_loss = [keras.losses.MeanSquaredError()]
        he_loss_weights = [1.]

        # Add categorical losses
        for i in range(len(self.data.categorical_columns)):
            he_loss.append(keras.losses.SparseCategoricalCrossentropy(from_logits=True))
            he_loss_weights.append(1./len(self.data.categorical_columns))

        # Define metrics
        metrics = {}
        for i, cat_name in enumerate(self.data.categorical_columns):
            metrics.update({f"output_{i+2}": keras.metrics.SparseCategoricalAccuracy()})

        # Compile model.
        heae.compile(optimizer=keras.optimizers.Adam(learning_rate=1e-3),
                     loss=he_loss,
                     loss_weights=he_loss_weights,
                     metrics=metrics)

        if len(os.listdir(heae_path)) == 0:
            # Fit and save autoencoder.
            heae.fit(trainset, epochs=config.EPOCHS)
            heae.save(heae_path, save_format="tf")
        else:
            heae = keras.models.load_model(heae_path, compile=False)

I have also tried using the original data to generate the trainset_outputs, but this gives a TypeError.
Thanks so much for your help.