skfair.preprocessing¶

Bases: BaseSampler

Base class for fairness-aware samplers.

Extends imblearn's BaseSampler with common functionality for fair resampling algorithms. Ensures DataFrame inputs are preserved and provides utilities for sensitive attribute handling, KNN operations, and synthetic sample generation.

Bases: BaseEstimator

Reweighing preprocessing technique (Kamiran & Calders, 2012).

The Reweighing method assigns weights to training samples such that the weighted dataset exhibits less statistical dependence between a sensitive attribute and the label. It does not modify the feature matrix or the labels; instead, it outputs instance weights that can be passed to downstream learning algorithms via sample_weight.

P(A=a, Y=y)_expected = P(A=a) * P(Y=y)

P(A=a, Y=y)_observed

weight = P_expected / P_observed

W(s, c) :=

    |{X | S = s}| * |{X | Y = c}|

      |D| * |{X | S = s, Y = c}|

Bases: BaseEstimator

FairBalance preprocessing technique (Yu, Chakraborty & Menzies, 2024).

FairBalance assigns weights to training samples to achieve equalized odds by balancing the class distribution within each demographic group. It does not modify the feature matrix or labels; instead, it outputs instance weights that can be passed to downstream learning algorithms via sample_weight.

weight = |A=a| / |A=a, Y=y|

weight = 1 / |A=a, Y=y|

Bases: BaseEstimator, ClassifierMixin

Meta-estimator that combines Reweighing with any classifier.

This wrapper makes Reweighing compatible with sklearn Pipelines by encapsulating the weight computation and passing weights to the underlying classifier's fit method via sample_weight.

The workflow is: 1. fit(X, y): Compute fairness weights using Reweighing, then fit the classifier with those weights. 2. predict(X): Delegate to the fitted classifier.

Bases: BaseEstimator, ClassifierMixin

Meta-estimator that combines FairBalance with any classifier.

This wrapper makes FairBalance compatible with sklearn Pipelines by encapsulating the weight computation and passing weights to the underlying classifier's fit method via sample_weight.

The workflow is: 1. fit(X, y): Compute fairness weights using FairBalance, then fit the classifier with those weights. 2. predict(X): Delegate to the fitted classifier.

Bases: BaseFairSampler

Massaging preprocessing technique (Kamiran & Calders, 2012).

Modifies class labels of training samples to reduce the statistical dependence between the sensitive attribute and the label. Identifies candidates for promotion (unprivileged with negative label) and demotion (privileged with positive label), then swaps their labels.

Bases: BaseFairSampler

Removes 'ambiguous' data points that cause conflicting predictions between privileged and unprivileged group models.

Trains two separate models on privileged and unprivileged groups, then removes any samples where the models disagree on predictions.

Bases: BaseFairSampler

Fair Oversampling (FOS) by Dablan et al.

Balances class distributions within each sensitive group independently. For each group (privileged/unprivileged), oversamples the minority class to match the majority class count using SMOTE-style interpolation.

Bases: BaseFairSampler

Fair-SMOTE oversampler for fairness-aware data balancing.

Balances the dataset across all (class_label × sensitive_attribute) subgroups. Identifies the largest subgroup and oversamples all others to match that size using a Differential Evolution-style crossover.

Bases: BaseFairSampler

FAWOS: Fairness-Aware Oversampling by Salazar et al.

Balances the dataset by oversampling positive unprivileged instances to match the ratio of positive-to-negative in the privileged group. Uses typology-based weighted selection (Safe, Borderline, Rare, Outlier) to prioritize points that are harder to learn.

Bases: BaseFairSampler

Fair Oversampling using Heterogeneous Clusters by Sonoda et al. (2023).

Balances all (class_label x sensitive_group) subgroups to match the largest subgroup size. Uses heterogeneous clusters for interpolation: - H_y: samples with different class but same group (class-heterogeneous) - H_g: samples with same class but different group (group-heterogeneous)

A Bernoulli probability p_{y,g} determines which cluster to use for each synthetic sample, enabling generation of class-mix and group-mix features that improve classifier generalization and fairness.

Bases: BaseEstimator, TransformerMixin

Disparate Impact Remover (Feldman et al., 2015).

Transforms feature distributions to reduce correlation with a sensitive attribute while preserving within-group rank ordering. Uses the quantile bucket method to handle uneven group sizes.

The repair formula (Definition 5.2): ȳ = (1 - λ) * y + λ * F_A⁻¹(F_x(y))

Where: - y is the original feature value - λ (lambda_param) controls repair level: 0 = no change, 1 = full repair - F_x(y) maps y to its quantile rank within group x - F_A⁻¹ maps that rank to the median distribution value

Bases: BaseFairSampler

Optimized Pre-Processing for Discrimination Prevention.

Learns a randomised mapping P(X', Y' | D, X, Y) that transforms features and labels to reduce statistical parity disparity while controlling individual distortion, solved via convex optimisation (CVXPY).

Important: This algorithm operates on discrete/categorical features only. Continuous features must be discretised before use.

Bases: BaseEstimator, TransformerMixin

Learning Fair Representations (Zemel et al., 2013).

Learns a set of intermediate prototypes that simultaneously encode the data faithfully (low reconstruction error) while removing information about a sensitive attribute (statistical parity of prototype membership across groups).

The objective minimised during fit is::

L = Ax * L_x  +  Ay * L_y  +  Az * L_z

where L_x is reconstruction error, L_y is label-prediction cross-entropy, and L_z penalises differences in average prototype membership between the privileged and unprivileged groups.

transform replaces every numeric feature column with its prototype-based reconstruction, preserving the sensitive-attribute column unchanged.

Bases: BaseEstimator, ClassifierMixin

Meta-estimator that masks sensitive attributes at inference time.

FairMask trains an ensemble of extrapolation models to predict sensitive attributes from non-sensitive features. At inference time, it replaces actual sensitive attribute values with synthetic values predicted by the ensemble via weighted voting. This achieves "procedural fairness" - the classifier's decision is based on what non-sensitive features imply, not the actual sensitive attribute.

The workflow is: 1. fit(X, y): Train extrapolation models (sensitive attr predictors) and fit the underlying classifier on original data. 2. predict(X): Replace sensitive attributes with synthetic values from extrapolation models, then delegate to the fitted classifier.

Bases: BaseEstimator, TransformerMixin

Creates a single binary Protected Group feature (1=Privileged, 0=Unprivileged) from complex, user-defined intersectional criteria.

Privilege is defined by an OR condition over a list of AND conditions (rules). Supports equality, list inclusion, and threshold operators (>, <, >=, <=, !=).

Bases: BaseEstimator, TransformerMixin

Drop specified columns from a DataFrame in a sklearn pipeline.

Useful for removing sensitive attributes before an estimator while keeping them available earlier in the pipeline for fairness preprocessing or evaluation.

Examples:

>>> from skfair.preprocessing import DropColumns
>>> from skfair.datasets import load_adult
>>> from sklearn.pipeline import Pipeline
>>> from sklearn.linear_model import LogisticRegression
>>> X, y = load_adult()
>>> pipe = Pipeline([
...     ("drop_sensitive", DropColumns("sex")),
...     ("clf", LogisticRegression()),
... ])
>>> pipe.fit(X, y)