import numpy as np
import scipy.optimize as optim
from aif360.algorithms import Transformer
from aif360.algorithms.preprocessing.lfr_helpers import helpers as lfr_helpers
class LFR(Transformer):
"""Learning fair representations is a pre-processing technique that finds a
latent representation which encodes the data well but obfuscates information
about protected attributes [2]_.
References:
.. [2] R. Zemel, Y. Wu, K. Swersky, T. Pitassi, and C. Dwork, "Learning
Fair Representations." International Conference on Machine Learning,
2013.
Based on code from https://github.com/zjelveh/learning-fair-representations
"""
def __init__(self,
unprivileged_groups,
privileged_groups,
k=5,
Ax=0.01,
Ay=1.0,
Az=50.0,
print_interval=250,
verbose=0,
seed=None):
"""
Args:
unprivileged_groups (tuple): Representation for unprivileged group.
privileged_groups (tuple): Representation for privileged group.
k (int, optional): Number of prototypes.
Ax (float, optional): Input recontruction quality term weight.
Az (float, optional): Fairness constraint term weight.
Ay (float, optional): Output prediction error.
print_interval (int, optional): Print optimization objective value
every print_interval iterations.
verbose (int, optional): If zero, then no output.
seed (int, optional): Seed to make `predict` repeatable.
"""
super(LFR, self).__init__(
unprivileged_groups=unprivileged_groups,
privileged_groups=privileged_groups)
self.seed = seed
self.unprivileged_groups = unprivileged_groups
self.privileged_groups = privileged_groups
if len(self.unprivileged_groups) > 1 or len(self.privileged_groups) > 1:
raise ValueError("Only one unprivileged_group or privileged_group supported.")
self.protected_attribute_name = list(self.unprivileged_groups[0].keys())[0]
self.unprivileged_group_protected_attribute_value = self.unprivileged_groups[0][self.protected_attribute_name]
self.privileged_group_protected_attribute_value = self.privileged_groups[0][self.protected_attribute_name]
self.k = k
self.Ax = Ax
self.Ay = Ay
self.Az = Az
self.print_interval = print_interval
self.verbose = verbose
self.w = None
self.prototypes = None
self.learned_model = None
def fit(self, dataset, maxiter=5000, maxfun=5000):
"""Compute the transformation parameters that leads to fair representations.
Args:
dataset (BinaryLabelDataset): Dataset containing true labels.
maxiter (int): Maximum number of iterations.
maxfun (int): Maxinum number of function evaluations.
Returns:
LFR: Returns self.
"""
if self.seed is not None:
np.random.seed(self.seed)
num_train_samples, self.features_dim = np.shape(dataset.features)
protected_attributes = np.reshape(
dataset.protected_attributes[:, dataset.protected_attribute_names.index(self.protected_attribute_name)],
[-1, 1])
unprivileged_sample_ids = np.array(np.where(protected_attributes == self.unprivileged_group_protected_attribute_value))[0].flatten()
privileged_sample_ids = np.array(np.where(protected_attributes == self.privileged_group_protected_attribute_value))[0].flatten()
features_unprivileged = dataset.features[unprivileged_sample_ids]
features_privileged = dataset.features[privileged_sample_ids]
labels_unprivileged = dataset.labels[unprivileged_sample_ids]
labels_privileged = dataset.labels[privileged_sample_ids]
# Initialize the LFR optim objective parameters
parameters_initialization = np.random.uniform(size=self.k + self.features_dim * self.k)
bnd = [(0, 1)]*self.k + [(None, None)]*self.features_dim*self.k
lfr_helpers.LFR_optim_objective.steps = 0
self.learned_model = optim.fmin_l_bfgs_b(lfr_helpers.LFR_optim_objective, x0=parameters_initialization, epsilon=1e-5,
args=(features_unprivileged, features_privileged,
labels_unprivileged[:, 0], labels_privileged[:, 0], self.k, self.Ax,
self.Ay, self.Az, self.print_interval, self.verbose),
bounds=bnd, approx_grad=True, maxfun=maxfun,
maxiter=maxiter, disp=self.verbose)[0]
self.w = self.learned_model[:self.k]
self.prototypes = self.learned_model[self.k:].reshape((self.k, self.features_dim))
return self
def transform(self, dataset, threshold=0.5):
"""Transform the dataset using learned model parameters.
Args:
dataset (BinaryLabelDataset): Dataset containing labels that needs to be transformed.
threshold(float, optional): threshold parameter used for binary label prediction.
Returns:
dataset (BinaryLabelDataset): Transformed Dataset.
"""
if self.seed is not None:
np.random.seed(self.seed)
protected_attributes = np.reshape(
dataset.protected_attributes[:, dataset.protected_attribute_names.index(self.protected_attribute_name)],
[-1, 1])
unprivileged_sample_ids = \
np.array(np.where(protected_attributes == self.unprivileged_group_protected_attribute_value))[0].flatten()
privileged_sample_ids = \
np.array(np.where(protected_attributes == self.privileged_group_protected_attribute_value))[0].flatten()
features_unprivileged = dataset.features[unprivileged_sample_ids]
features_privileged = dataset.features[privileged_sample_ids]
_, features_hat_unprivileged, labels_hat_unprivileged = lfr_helpers.get_xhat_y_hat(self.prototypes, self.w, features_unprivileged)
_, features_hat_privileged, labels_hat_privileged = lfr_helpers.get_xhat_y_hat(self.prototypes, self.w, features_privileged)
transformed_features = np.zeros(shape=np.shape(dataset.features))
transformed_labels = np.zeros(shape=np.shape(dataset.labels))
transformed_features[unprivileged_sample_ids] = features_hat_unprivileged
transformed_features[privileged_sample_ids] = features_hat_privileged
transformed_labels[unprivileged_sample_ids] = np.reshape(labels_hat_unprivileged, [-1, 1])
transformed_labels[privileged_sample_ids] = np.reshape(labels_hat_privileged,[-1, 1])
transformed_bin_labels = (np.array(transformed_labels) > threshold).astype(np.float64)
# Mutated, fairer dataset with new labels
dataset_new = dataset.copy(deepcopy=True)
dataset_new.features = transformed_features
dataset_new.labels = transformed_bin_labels
dataset_new.scores = np.array(transformed_labels)
return dataset_new
def fit_transform(self, dataset, maxiter=5000, maxfun=5000, threshold=0.5):
"""Fit and transform methods sequentially.
Args:
dataset (BinaryLabelDataset): Dataset containing labels that needs to be transformed.
maxiter (int): Maximum number of iterations.
maxfun (int): Maxinum number of function evaluations.
threshold(float, optional): threshold parameter used for binary label prediction.
Returns:
dataset (BinaryLabelDataset): Transformed Dataset.
"""
return self.fit(dataset, maxiter=maxiter, maxfun=maxfun).transform(dataset, threshold=threshold)