FEA-Bench / testbed /fairlearn__fairlearn /test /unit /postprocessing /test_threshold_optimization.py
| # Copyright (c) Microsoft Corporation. All rights reserved. | |
| # Licensed under the MIT License. | |
| import copy | |
| import numpy as np | |
| import pandas as pd | |
| import pytest | |
| from fairlearn.postprocessing._constants import DEMOGRAPHIC_PARITY, EQUALIZED_ODDS | |
| from fairlearn.postprocessing import ThresholdOptimizer | |
| from fairlearn.postprocessing._threshold_optimizer import \ | |
| (_vectorized_prediction, | |
| _threshold_optimization_demographic_parity, | |
| _threshold_optimization_equalized_odds, | |
| DIFFERENT_INPUT_LENGTH_ERROR_MESSAGE, | |
| EMPTY_INPUT_ERROR_MESSAGE, | |
| NON_BINARY_LABELS_ERROR_MESSAGE, | |
| INPUT_DATA_FORMAT_ERROR_MESSAGE, | |
| NOT_SUPPORTED_CONSTRAINTS_ERROR_MESSAGE, | |
| PREDICT_BEFORE_FIT_ERROR_MESSAGE, | |
| MULTIPLE_DATA_COLUMNS_ERROR_MESSAGE) | |
| from fairlearn.postprocessing._postprocessing import \ | |
| PREDICTOR_OR_ESTIMATOR_REQUIRED_ERROR_MESSAGE, EITHER_PREDICTOR_OR_ESTIMATOR_ERROR_MESSAGE, \ | |
| MISSING_FIT_PREDICT_ERROR_MESSAGE, MISSING_PREDICT_ERROR_MESSAGE | |
| from fairlearn.postprocessing._roc_curve_utilities import DEGENERATE_LABELS_ERROR_MESSAGE | |
| from .test_utilities import (sensitive_features_ex1, sensitive_features_ex2, labels_ex, | |
| degenerate_labels_ex, scores_ex, sensitive_feature_names_ex1, | |
| sensitive_feature_names_ex2, _get_predictions_by_sensitive_feature, | |
| _format_as_list_of_lists, ExamplePredictor, ExampleEstimator, | |
| ExampleNotPredictor, ExampleNotEstimator1, ExampleNotEstimator2) | |
| ALLOWED_INPUT_DATA_TYPES = [lambda x: x, np.array, pd.DataFrame, pd.Series] | |
| def test_predict_before_fit_error(X_transform, sensitive_features_transform, predict_method_name, | |
| constraints): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features_ex1)) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| with pytest.raises(ValueError, match=PREDICT_BEFORE_FIT_ERROR_MESSAGE): | |
| getattr(adjusted_predictor, predict_method_name)(X, sensitive_features=sensitive_features) | |
| def test_both_predictor_and_estimator_error(constraints): | |
| with pytest.raises(ValueError, match=EITHER_PREDICTOR_OR_ESTIMATOR_ERROR_MESSAGE): | |
| ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| estimator=ExampleEstimator(), | |
| constraints=constraints) | |
| def test_no_predictor_or_estimator_error(constraints): | |
| with pytest.raises(ValueError, match=PREDICTOR_OR_ESTIMATOR_REQUIRED_ERROR_MESSAGE): | |
| ThresholdOptimizer(constraints=constraints) | |
| def test_constraints_not_supported(): | |
| with pytest.raises(ValueError, match=NOT_SUPPORTED_CONSTRAINTS_ERROR_MESSAGE): | |
| ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints="UnsupportedConstraints") | |
| def test_not_estimator(not_estimator, constraints): | |
| with pytest.raises(ValueError, match=MISSING_FIT_PREDICT_ERROR_MESSAGE): | |
| ThresholdOptimizer(estimator=not_estimator, | |
| constraints=constraints) | |
| def test_not_predictor(constraints): | |
| with pytest.raises(ValueError, match=MISSING_PREDICT_ERROR_MESSAGE): | |
| ThresholdOptimizer(unconstrained_predictor=ExampleNotPredictor(), | |
| constraints=constraints) | |
| def test_inconsistent_input_data_types(X, y, sensitive_features, constraints): | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| error_message = INPUT_DATA_FORMAT_ERROR_MESSAGE.format(type(X).__name__, | |
| type(y).__name__, | |
| type(sensitive_features).__name__) | |
| if X is None or y is None and sensitive_features is None: | |
| with pytest.raises(TypeError) as exception: | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features) | |
| assert str(exception.value) == error_message | |
| def test_threshold_optimization_non_binary_labels(X_transform, y_transform, | |
| sensitive_features_transform, constraints): | |
| non_binary_labels = copy.deepcopy(labels_ex) | |
| non_binary_labels[0] = 2 | |
| X = X_transform(_format_as_list_of_lists(sensitive_features_ex1)) | |
| y = y_transform(non_binary_labels) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| with pytest.raises(ValueError, match=NON_BINARY_LABELS_ERROR_MESSAGE): | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features) | |
| def test_threshold_optimization_degenerate_labels(X_transform, y_transform, | |
| sensitive_features_transform, constraints): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features_ex1)) | |
| y = y_transform(degenerate_labels_ex) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| with pytest.raises(ValueError, match=DEGENERATE_LABELS_ERROR_MESSAGE.format('A')): | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features) | |
| def test_threshold_optimization_different_input_lengths(X_transform, y_transform, | |
| sensitive_features_transform, | |
| constraints): | |
| n = len(sensitive_features_ex1) | |
| for permutation in [(0, 1), (1, 0)]: | |
| with pytest.raises(ValueError, match=DIFFERENT_INPUT_LENGTH_ERROR_MESSAGE | |
| .format("X, sensitive_features, and y")): | |
| X = X_transform(_format_as_list_of_lists( | |
| sensitive_features_ex1)[:n - permutation[0]]) | |
| y = y_transform(labels_ex[:n - permutation[1]]) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features) | |
| # try providing empty lists in all combinations | |
| for permutation in [(0, n), (n, 0)]: | |
| X = X_transform(_format_as_list_of_lists( | |
| sensitive_features_ex1)[:n - permutation[0]]) | |
| y = y_transform(labels_ex[:n - permutation[1]]) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| with pytest.raises(ValueError, match=EMPTY_INPUT_ERROR_MESSAGE): | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features) | |
| def test_threshold_optimization_demographic_parity(score_transform, y_transform, | |
| sensitive_features_transform): | |
| y = y_transform(labels_ex) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| scores = score_transform(scores_ex) | |
| adjusted_predictor = create_adjusted_predictor(_threshold_optimization_demographic_parity, | |
| sensitive_features, y, scores) | |
| # For Demographic Parity we can ignore p_ignore since it's always 0. | |
| # sensitive feature value A | |
| value_for_less_than_2_5 = 0.8008 | |
| assert np.isclose(value_for_less_than_2_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[0]], [0])) | |
| assert np.isclose(value_for_less_than_2_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[0]], [2.499])) | |
| assert 0 == adjusted_predictor([sensitive_feature_names_ex1[0]], [2.5]) | |
| assert 0 == adjusted_predictor([sensitive_feature_names_ex1[0]], [100]) | |
| # sensitive feature value B | |
| value_for_less_than_0_5 = 0.00133333333333 | |
| assert np.isclose(value_for_less_than_0_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[1]], [0])) | |
| assert np.isclose(value_for_less_than_0_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[1]], [0.5])) | |
| assert 1 == adjusted_predictor([sensitive_feature_names_ex1[1]], [0.51]) | |
| assert 1 == adjusted_predictor([sensitive_feature_names_ex1[1]], [1]) | |
| assert 1 == adjusted_predictor([sensitive_feature_names_ex1[1]], [100]) | |
| # sensitive feature value C | |
| value_between_0_5_and_1_5 = 0.608 | |
| assert 0 == adjusted_predictor([sensitive_feature_names_ex1[2]], [0]) | |
| assert 0 == adjusted_predictor([sensitive_feature_names_ex1[2]], [0.5]) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [0.51])) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [1])) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [1.5])) | |
| assert 1 == adjusted_predictor([sensitive_feature_names_ex1[2]], [1.51]) | |
| assert 1 == adjusted_predictor([sensitive_feature_names_ex1[2]], [100]) | |
| # Assert Demographic Parity actually holds | |
| predictions_by_sensitive_feature = _get_predictions_by_sensitive_feature( | |
| adjusted_predictor, sensitive_features_ex1, scores_ex, labels_ex) | |
| def _average_prediction(sensitive_feature_value, predictions_by_sensitive_feature): | |
| relevant_predictions = predictions_by_sensitive_feature[sensitive_feature_value] | |
| predictions = [lp.prediction for lp in relevant_predictions] | |
| return np.sum(predictions) / len(relevant_predictions) | |
| average_probabilities_by_sensitive_feature = [] | |
| for sensitive_feature_value in sorted(predictions_by_sensitive_feature): | |
| average_probabilities_by_sensitive_feature \ | |
| .append(_average_prediction(sensitive_feature_value, | |
| predictions_by_sensitive_feature)) | |
| assert np.isclose(average_probabilities_by_sensitive_feature, [0.572] * 3).all() | |
| def test_threshold_optimization_equalized_odds(score_transform, y_transform, | |
| sensitive_features_transform): | |
| y = y_transform(labels_ex) | |
| sensitive_features = sensitive_features_transform(sensitive_features_ex1) | |
| scores = score_transform(scores_ex) | |
| adjusted_predictor = create_adjusted_predictor(_threshold_optimization_equalized_odds, | |
| sensitive_features, y, scores) | |
| # For Equalized Odds we need to factor in that the output is calculated by | |
| # p_ignore * prediction_constant + (1 - p_ignore) * (p0 * pred0(x) + p1 * pred1(x)) | |
| # with p_ignore != 0 and prediction_constant != 0 for at least some sensitive feature values. | |
| prediction_constant = 0.334 | |
| # sensitive feature value A | |
| # p_ignore is almost 0 which means there's almost no adjustment | |
| p_ignore = 0.001996007984031716 | |
| base_value = prediction_constant * p_ignore | |
| value_for_less_than_2_5 = base_value + (1 - p_ignore) * 0.668 | |
| assert np.isclose(value_for_less_than_2_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[0]], [0])) | |
| assert np.isclose(value_for_less_than_2_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[0]], [2.499])) | |
| assert base_value == adjusted_predictor([sensitive_feature_names_ex1[0]], [2.5]) | |
| assert base_value == adjusted_predictor([sensitive_feature_names_ex1[0]], [100]) | |
| # sensitive feature value B | |
| # p_ignore is the largest among the three classes indicating a large adjustment | |
| p_ignore = 0.1991991991991991 | |
| base_value = prediction_constant * p_ignore | |
| value_for_less_than_0_5 = base_value + (1 - p_ignore) * 0.001 | |
| assert np.isclose(value_for_less_than_0_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[1]], [0])) | |
| assert np.isclose(value_for_less_than_0_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[1]], [0.5])) | |
| assert base_value + 1 - \ | |
| p_ignore == adjusted_predictor([sensitive_feature_names_ex1[1]], [0.51]) | |
| assert base_value + 1 - \ | |
| p_ignore == adjusted_predictor([sensitive_feature_names_ex1[1]], [1]) | |
| assert base_value + 1 - \ | |
| p_ignore == adjusted_predictor([sensitive_feature_names_ex1[1]], [100]) | |
| # sensitive feature value C | |
| # p_ignore is 0 which means there's no adjustment | |
| p_ignore = 0 | |
| base_value = prediction_constant * p_ignore | |
| value_between_0_5_and_1_5 = base_value + (1 - p_ignore) * 0.501 | |
| assert base_value == adjusted_predictor([sensitive_feature_names_ex1[2]], [0]) | |
| assert base_value == adjusted_predictor([sensitive_feature_names_ex1[2]], [0.5]) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [0.51])) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [1])) | |
| assert np.isclose(value_between_0_5_and_1_5, | |
| adjusted_predictor([sensitive_feature_names_ex1[2]], [1.5])) | |
| assert base_value + 1 - \ | |
| p_ignore == adjusted_predictor([sensitive_feature_names_ex1[2]], [1.51]) | |
| assert base_value + 1 - \ | |
| p_ignore == adjusted_predictor([sensitive_feature_names_ex1[2]], [100]) | |
| # Assert Equalized Odds actually holds | |
| predictions_by_sensitive_feature = _get_predictions_by_sensitive_feature( | |
| adjusted_predictor, sensitive_features_ex1, scores_ex, labels_ex) | |
| def _average_prediction_for_label(label, sensitive_feature_value, | |
| predictions_by_sensitive_feature): | |
| relevant_predictions = predictions_by_sensitive_feature[sensitive_feature_value] | |
| predictions_for_label = [lp.prediction for lp in relevant_predictions if lp.label == label] | |
| sum_of_predictions_for_label = np.sum(predictions_for_label) | |
| n_predictions_for_label = len([lp for lp in relevant_predictions if lp.label == label]) | |
| return sum_of_predictions_for_label / n_predictions_for_label | |
| predictions_based_on_label = {0: [], 1: []} | |
| for label in [0, 1]: | |
| for sensitive_feature_value in sorted(predictions_by_sensitive_feature): | |
| predictions_based_on_label[label] \ | |
| .append(_average_prediction_for_label(label, sensitive_feature_value, | |
| predictions_by_sensitive_feature)) | |
| # assert counts of positive predictions for negative labels | |
| assert np.isclose(predictions_based_on_label[0], [0.334] * 3).all() | |
| # assert counts of positive predictions for positive labels | |
| assert np.isclose(predictions_based_on_label[1], [0.66733333] * 3).all() | |
| def test_threshold_optimization_demographic_parity_e2e(sensitive_features, | |
| sensitive_feature_names, | |
| expected_p0, expected_p1, | |
| X_transform, y_transform, | |
| sensitive_features_transform): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features)) | |
| y = y_transform(labels_ex) | |
| sensitive_features_ = sensitive_features_transform(sensitive_features) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=DEMOGRAPHIC_PARITY) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features_) | |
| predictions = adjusted_predictor._pmf_predict(X, sensitive_features=sensitive_features_) | |
| # assert demographic parity | |
| for sensitive_feature_name in sensitive_feature_names: | |
| average_probs = np.average( | |
| predictions[np.array(sensitive_features) == sensitive_feature_name], axis=0) | |
| assert np.isclose(average_probs[0], expected_p0) | |
| assert np.isclose(average_probs[1], expected_p1) | |
| def test_threshold_optimization_equalized_odds_e2e( | |
| sensitive_features, sensitive_feature_names, expected_positive_p0, expected_positive_p1, | |
| expected_negative_p0, expected_negative_p1, X_transform, y_transform, | |
| sensitive_features_transform): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features)) | |
| y = y_transform(labels_ex) | |
| sensitive_features_ = sensitive_features_transform(sensitive_features) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=EQUALIZED_ODDS) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features_) | |
| predictions = adjusted_predictor._pmf_predict(X, sensitive_features=sensitive_features_) | |
| # assert equalized odds | |
| for a in sensitive_feature_names: | |
| positive_indices = (np.array(sensitive_features) == a) * \ | |
| (np.array(labels_ex) == 1) | |
| negative_indices = (np.array(sensitive_features) == a) * \ | |
| (np.array(labels_ex) == 0) | |
| average_probs_positive_indices = np.average( | |
| predictions[positive_indices], axis=0) | |
| average_probs_negative_indices = np.average( | |
| predictions[negative_indices], axis=0) | |
| assert np.isclose( | |
| average_probs_positive_indices[0], expected_positive_p0) | |
| assert np.isclose( | |
| average_probs_positive_indices[1], expected_positive_p1) | |
| assert np.isclose( | |
| average_probs_negative_indices[0], expected_negative_p0) | |
| assert np.isclose( | |
| average_probs_negative_indices[1], expected_negative_p1) | |
| def test_predict_output_0_or_1(sensitive_features, sensitive_feature_names, X_transform, | |
| y_transform, sensitive_features_transform, constraints): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features)) | |
| y = y_transform(labels_ex) | |
| sensitive_features_ = sensitive_features_transform(sensitive_features) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features_) | |
| predictions = adjusted_predictor.predict(X, sensitive_features=sensitive_features_) | |
| for prediction in predictions: | |
| assert prediction in [0, 1] | |
| def test_predict_multiple_sensitive_features_columns_error( | |
| sensitive_features, sensitive_feature_names, X_transform, y_transform, constraints): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features)) | |
| y = y_transform(labels_ex) | |
| sensitive_features_ = pd.DataFrame({"A1": sensitive_features, "A2": sensitive_features}) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features_) | |
| with pytest.raises(ValueError, | |
| match=MULTIPLE_DATA_COLUMNS_ERROR_MESSAGE.format("sensitive_features")): | |
| adjusted_predictor.predict(X, sensitive_features=sensitive_features_) | |
| def test_predict_different_argument_lengths(sensitive_features, sensitive_feature_names, | |
| X_transform, y_transform, | |
| sensitive_features_transform, constraints): | |
| X = X_transform(_format_as_list_of_lists(sensitive_features)) | |
| y = y_transform(labels_ex) | |
| sensitive_features_ = sensitive_features_transform(sensitive_features) | |
| adjusted_predictor = ThresholdOptimizer(unconstrained_predictor=ExamplePredictor(), | |
| constraints=constraints) | |
| adjusted_predictor.fit(X, y, sensitive_features=sensitive_features_) | |
| with pytest.raises(ValueError, match=DIFFERENT_INPUT_LENGTH_ERROR_MESSAGE | |
| .format("X and sensitive_features")): | |
| adjusted_predictor.predict( | |
| X, sensitive_features=sensitive_features_transform(sensitive_features[:-1])) | |
| with pytest.raises(ValueError, match=DIFFERENT_INPUT_LENGTH_ERROR_MESSAGE | |
| .format("X and sensitive_features")): | |
| adjusted_predictor.predict(X_transform(_format_as_list_of_lists(sensitive_features))[:-1], | |
| sensitive_features=sensitive_features_) | |
| def create_adjusted_predictor(threshold_optimization_method, sensitive_features, labels, scores): | |
| post_processed_predictor_by_sensitive_feature = threshold_optimization_method( | |
| sensitive_features, labels, scores) | |
| return lambda sensitive_features_, scores: _vectorized_prediction( | |
| post_processed_predictor_by_sensitive_feature, sensitive_features_, scores) | |