From ab7e52afbee844540a1a834339516132cad96937 Mon Sep 17 00:00:00 2001 From: Samuel Hoffman Date: Tue, 21 Nov 2023 14:33:43 -0500 Subject: [PATCH] remove deprecated bias scan metrics (#504) --- aif360/metrics/mdss_classification_metric.py | 50 ---- aif360/sklearn/detectors/detectors.py | 6 +- aif360/sklearn/metrics/metrics.py | 91 ++------ examples/demo_mdss_classifier_metric.ipynb | 38 ++- examples/sklearn/demo_mdss_bias_scan.ipynb | 219 +++++++----------- .../demo_mdss_classifier_metric_sklearn.ipynb | 70 +++--- 6 files changed, 153 insertions(+), 321 deletions(-) diff --git a/aif360/metrics/mdss_classification_metric.py b/aif360/metrics/mdss_classification_metric.py index 510d6420..aa90f932 100644 --- a/aif360/metrics/mdss_classification_metric.py +++ b/aif360/metrics/mdss_classification_metric.py @@ -7,7 +7,6 @@ from aif360.detectors.mdss.MDSS import MDSS import pandas as pd -from sklearn.utils.deprecation import deprecated class MDSSClassificationMetric(ClassificationMetric): @@ -116,52 +115,3 @@ def score_groups(self, privileged=True, penalty=1e-17): return scanner.score_current_subset( coordinates, expected, outcomes, dict(subset), penalty ) - - @deprecated('Change to new interface - aif360.detectors.mdss_detector.bias_scan by version 0.5.0.') - def bias_scan(self, privileged=True, num_iters=10, penalty=1e-17): - """ - scan to find the highest scoring subset of records - - :param privileged: flag for group to scan for - privileged group (True) or unprivileged group (False). - This abstract the need to explicitly specify the direction of bias to scan for which depends on what the favourable label is. - :param num_iters: number of iterations (random restarts) - :param penalty: penalty term. Should be positive. The penalty term as with any regularization parameter may need to be - tuned for ones use case. The higher the penalty, the less complex (number of features and feature values) the highest scoring - subset that gets returned is. - - :returns: the highest scoring subset and the score - """ - - coordinates = pd.DataFrame( - self.classified_dataset.features, - columns=self.classified_dataset.feature_names, - ) - - expected = pd.Series(self.classified_dataset.scores.flatten()) - outcomes = pd.Series(self.dataset.labels.flatten() == self.dataset.favorable_label, dtype=int) - - # In MDSS, we look for subset whose observations systematically deviates from expectations. - # Positive direction means observations are systematically higher than expectations - # (or expectations are systematically lower than observations) while - # Negative direction means observatons are systematically lower than expectations - # (or expectations are systematically higher than observations) - - # For a privileged group, we are looking for a subset whose expectations - # (where expectations is obtained from a model) is systematically higher than the observations. - # This means we scan in the negative direction. - - # For an uprivileged group, we are looking for a subset whose expectations - # (where expectations is obtained from a model) is systematically lower the observations. - # This means we scan in the position direction. - - self.kwargs['direction'] = "negative" if privileged else "positive" - - if self.scoring == "Bernoulli": - scoring_function = Bernoulli(**self.kwargs) - elif self.scoring == "BerkJones": - scoring_function = BerkJones(**self.kwargs) - else: - scoring_function = self.scoring(**self.kwargs) - - scanner = MDSS(scoring_function) - return scanner.scan(coordinates, expected, outcomes, penalty, num_iters) diff --git a/aif360/sklearn/detectors/detectors.py b/aif360/sklearn/detectors/detectors.py index 78e782ab..35617c4f 100644 --- a/aif360/sklearn/detectors/detectors.py +++ b/aif360/sklearn/detectors/detectors.py @@ -1,6 +1,6 @@ from typing import Union -from aif360.detectors import bias_scan +from aif360.detectors import bias_scan as _bias_scan from aif360.detectors.mdss.ScoringFunctions import ScoringFunction import pandas as pd @@ -50,7 +50,7 @@ def bias_scan( Returns: tuple: The highest scoring subset and the score or dict of the highest scoring subset and the score for each category in nominal mode """ - return bias_scan( + return _bias_scan( data=X, observations=y_true, expectations=y_pred, @@ -60,5 +60,5 @@ def bias_scan( num_iters=num_iters, penalty=penalty, mode=mode, - kwargs=kwargs + **kwargs ) diff --git a/aif360/sklearn/metrics/metrics.py b/aif360/sklearn/metrics/metrics.py index bce9e02c..bcbf9c16 100644 --- a/aif360/sklearn/metrics/metrics.py +++ b/aif360/sklearn/metrics/metrics.py @@ -1,5 +1,6 @@ from itertools import permutations from typing import Union +import warnings import numpy as np import pandas as pd @@ -9,7 +10,6 @@ from sklearn.metrics._classification import _prf_divide, _check_zero_division from sklearn.neighbors import NearestNeighbors from sklearn.utils import check_X_y -from sklearn.utils.deprecation import deprecated from aif360.metrics import ot_metric from aif360.sklearn.utils import check_inputs, check_groups @@ -31,7 +31,7 @@ 'equal_opportunity_difference', 'average_odds_difference', 'average_predictive_value_difference', 'average_odds_error', 'class_imbalance', 'kl_divergence', 'conditional_demographic_disparity', 'smoothed_edf', - 'df_bias_amplification', 'mdss_bias_scan', 'mdss_bias_score', + 'df_bias_amplification', 'mdss_bias_score', # individual fairness 'generalized_entropy_index', 'generalized_entropy_error', 'between_group_generalized_entropy_error', 'theil_index', @@ -946,7 +946,7 @@ def df_bias_amplification(y_true, y_pred, *, prot_attr=None, pos_label=1, return eps_pred - eps_true def mdss_bias_score(y_true, probas_pred, X=None, subset=None, *, pos_label=1, - scoring='Bernoulli', privileged=True, penalty=1e-17, + scoring='Bernoulli', overpredicted=True, penalty=1e-17, **kwargs): """Compute the bias score for a prespecified group of records using a given scoring function. @@ -966,10 +966,14 @@ def mdss_bias_score(y_true, probas_pred, X=None, subset=None, *, pos_label=1, scoring (str or class): One of 'Bernoulli' or 'BerkJones' or subclass of :class:`aif360.metrics.mdss.ScoringFunctions.ScoringFunction`. - privileged (bool): Flag for which direction to scan: privileged - (``True``) implies negative (observed worse than predicted outcomes) - while unprivileged (``False``) implies positive (observed better - than predicted outcomes). + overpredicted (bool): Flag for which direction to scan: `True` means we + scan for a group whose expectations/predictions are systematically + higher than observed. In other words, we scan for a group whose + observed is systematically lower than the expectations. `False` + means we scan for a group whose expectations/predictions are + systematically lower than observed (observed is systematically + higher than the expectations). + privileged (bool): Deprecated. Use overpredicted instead. penalty (scalar): Penalty coefficient. Should be positive. The higher the penalty, the less complex (number of features and feature values) the highest scoring subset that gets returned is. @@ -991,7 +995,12 @@ def mdss_bias_score(y_true, probas_pred, X=None, subset=None, *, pos_label=1, expected = pd.Series(probas_pred).reset_index(drop=True) outcomes = pd.Series(y_true == pos_label, dtype=int).reset_index(drop=True) - direction = 'negative' if privileged else 'positive' + # TODO: DEPRECATED. Remove in next version. + if 'privileged' in kwargs: + warnings.warn("privileged is deprecated. Use overpredicted instead.", + category=FutureWarning) + overpredicted = kwargs['privileged'] + direction = 'negative' if overpredicted else 'positive' kwargs['direction'] = direction if scoring == 'Bernoulli': @@ -1004,72 +1013,6 @@ def mdss_bias_score(y_true, probas_pred, X=None, subset=None, *, pos_label=1, return scanner.score_current_subset(X, expected, outcomes, subset or {}, penalty) -@deprecated('Change to new interface - aif360.sklearn.detectors.mdss_detector.bias_scan by version 0.5.0.') -def mdss_bias_scan(y_true, probas_pred, X=None, *, pos_label=1, - scoring='Bernoulli', privileged=True, n_iter=10, - penalty=1e-17, **kwargs): - """Scan to find the highest scoring subset of records. - - Bias scan is a technique to identify bias in predictive models using subset - scanning [#zhang16]_. - - Args: - y_true (array-like): Ground truth (correct) target values. - probas_pred (array-like): Probability estimates of the positive class. - X (dataframe, optional): The dataset (containing the features) that was - used to predict `probas_pred`. If not specified, the subset is - returned as indices. - pos_label (scalar): Label of the positive class. - scoring (str or class): One of 'Bernoulli' or 'BerkJones' or - subclass of - :class:`aif360.metrics.mdss.ScoringFunctions.ScoringFunction`. - privileged (bool): Flag for which direction to scan: privileged - (``True``) implies negative (observed worse than predicted outcomes) - while unprivileged (``False``) implies positive (observed better - than predicted outcomes). - n_iter (scalar): Number of iterations (random restarts). - penalty (scalar): Penalty coefficient. Should be positive. The higher - the penalty, the less complex (number of features and feature - values) the highest scoring subset that gets returned is. - **kwargs: Additional kwargs to be passed to `scoring` (not including - `direction`). - - Returns: - tuple: - Highest scoring subset and its bias score - - * **subset** (dict) -- Mapping of features to values defining the - highest scoring subset. - * **score** (float) -- Bias score for that group. - - See also: - :func:`mdss_bias_score` - - References: - .. [#zhang16] `Zhang, Z. and Neill, D. B., "Identifying significant - predictive bias in classifiers," arXiv preprint, 2016. - `_ - """ - if X is None: - X = pd.DataFrame({'index': range(len(y_true))}) - else: - X = X.reset_index(drop=True) # match all indices - - expected = pd.Series(probas_pred).reset_index(drop=True) - outcomes = pd.Series(y_true == pos_label, dtype=int).reset_index(drop=True) - - direction = 'negative' if privileged else 'positive' - kwargs['direction'] = direction - if scoring == 'Bernoulli': - scoring_function = Bernoulli(**kwargs) - elif scoring == 'BerkJones': - scoring_function = BerkJones(**kwargs) - else: - scoring_function = scoring(**kwargs) - scanner = MDSS(scoring_function) - - return scanner.scan(X, expected, outcomes, penalty, n_iter) - # ========================== INDIVIDUAL FAIRNESS =============================== def generalized_entropy_index(b, alpha=2): diff --git a/examples/demo_mdss_classifier_metric.ipynb b/examples/demo_mdss_classifier_metric.ipynb index 6e4b0d8a..004d2956 100644 --- a/examples/demo_mdss_classifier_metric.ipynb +++ b/examples/demo_mdss_classifier_metric.ipynb @@ -44,9 +44,8 @@ "import numpy as np\n", "import pandas as pd\n", "\n", - "from aif360.metrics import BinaryLabelDatasetMetric \n", - "from aif360.metrics.mdss_classification_metric import MDSSClassificationMetric\n", - "from aif360.detectors.mdss.ScoringFunctions.Bernoulli import Bernoulli\n", + "from aif360.metrics import BinaryLabelDatasetMetric, MDSSClassificationMetric\n", + "from aif360.detectors import bias_scan\n", "\n", "from aif360.algorithms.preprocessing.optim_preproc_helpers.data_preproc_functions import load_preproc_data_compas" ] @@ -88,9 +87,9 @@ "source": [ "dataset_orig_df = pd.DataFrame(dataset_orig.features, columns=dataset_orig.feature_names)\n", "\n", - "age_cat = np.argmax(dataset_orig_df[['age_cat=Less than 25', 'age_cat=25 to 45', \n", + "age_cat = np.argmax(dataset_orig_df[['age_cat=Less than 25', 'age_cat=25 to 45',\n", " 'age_cat=Greater than 45']].values, axis=1).reshape(-1, 1)\n", - "priors_count = np.argmax(dataset_orig_df[['priors_count=0', 'priors_count=1 to 3', \n", + "priors_count = np.argmax(dataset_orig_df[['priors_count=0', 'priors_count=1 to 3',\n", " 'priors_count=More than 3']].values, axis=1).reshape(-1, 1)\n", "c_charge_degree = np.argmax(dataset_orig_df[['c_charge_degree=M', 'c_charge_degree=F']].values, axis=1).reshape(-1, 1)\n", "\n", @@ -249,12 +248,12 @@ } ], "source": [ - "metric_train = BinaryLabelDatasetMetric(dataset_orig_train, \n", + "metric_train = BinaryLabelDatasetMetric(dataset_orig_train,\n", " unprivileged_groups=male_group,\n", " privileged_groups=female_group)\n", "\n", "print(\"Train set: Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_train.mean_difference())\n", - "metric_test = BinaryLabelDatasetMetric(dataset_orig_test, \n", + "metric_test = BinaryLabelDatasetMetric(dataset_orig_test,\n", " unprivileged_groups=male_group,\n", " privileged_groups=female_group)\n", "print(\"Test set: Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_test.mean_difference())\n" @@ -935,19 +934,14 @@ "cell_type": "code", "execution_count": 22, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Function bias_scan is deprecated; Change to new interface - aif360.detectors.mdss_detector.bias_scan by version 0.5.0.\n", - "Function bias_scan is deprecated; Change to new interface - aif360.detectors.mdss_detector.bias_scan by version 0.5.0.\n" - ] - } - ], + "outputs": [], "source": [ - "privileged_subset = mdss_classified.bias_scan(penalty=0.5, privileged=True)\n", - "unprivileged_subset = mdss_classified.bias_scan(penalty=0.5, privileged=False)" + "privileged_subset = bias_scan(df.iloc[:, :-2], df.observed, df.probabilities,\n", + " favorable_value=dataset_orig_test.favorable_label,\n", + " penalty=0.5, overpredicted=True)\n", + "unprivileged_subset = bias_scan(df.iloc[:, :-2], df.observed, df.probabilities,\n", + " favorable_value=dataset_orig_test.favorable_label,\n", + " penalty=0.5, overpredicted=False)" ] }, { @@ -1024,7 +1018,7 @@ "detected_privileged_groups = []\n", "for vals in subset_values:\n", " detected_privileged_groups.append((dict(zip(privileged_subset[0].keys(), vals))))\n", - " \n", + "\n", "a = list(unprivileged_subset[0].values())\n", "subset_values = list(itertools.product(*a))\n", "\n", @@ -1047,11 +1041,11 @@ } ], "source": [ - "metric_bias_test = BinaryLabelDatasetMetric(dataset_bias_test, \n", + "metric_bias_test = BinaryLabelDatasetMetric(dataset_bias_test,\n", " unprivileged_groups=detected_unprivileged_groups,\n", " privileged_groups=detected_privileged_groups)\n", "\n", - "print(\"Test set: Difference in mean outcomes between unprivileged and privileged groups = %f\" \n", + "print(\"Test set: Difference in mean outcomes between unprivileged and privileged groups = %f\"\n", " % metric_bias_test.mean_difference())" ] }, diff --git a/examples/sklearn/demo_mdss_bias_scan.ipynb b/examples/sklearn/demo_mdss_bias_scan.ipynb index b42bb4d6..05110d6f 100644 --- a/examples/sklearn/demo_mdss_bias_scan.ipynb +++ b/examples/sklearn/demo_mdss_bias_scan.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "id": "muU69Pg20JiY" }, @@ -49,11 +49,11 @@ "sns.set(context='talk', style='whitegrid')\n", "\n", "from sklearn.metrics import RocCurveDisplay\n", - "from sklearn.model_selection import train_test_split\n", "from sklearn.linear_model import LogisticRegression\n", "\n", "from aif360.sklearn.datasets import fetch_compas\n", - "from aif360.sklearn.metrics import mdss_bias_scan, mdss_bias_score" + "from aif360.sklearn.detectors import bias_scan\n", + "from aif360.sklearn.metrics import mdss_bias_score" ] }, { @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "id": "fGqb0ZGc0Jie", "outputId": "f090b129-0d8d-4573-e77d-69489bc16874" @@ -95,7 +95,6 @@ " \n", " \n", " \n", - " \n", " sex\n", " race\n", " age_cat\n", @@ -104,7 +103,6 @@ " decile_score\n", " \n", " \n", - " id\n", " sex\n", " race\n", " \n", @@ -117,8 +115,7 @@ " \n", " \n", " \n", - " 1\n", - " Male\n", + " Male\n", " Other\n", " Male\n", " Other\n", @@ -128,8 +125,6 @@ " 1\n", " \n", " \n", - " 3\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -139,8 +134,6 @@ " 3\n", " \n", " \n", - " 4\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -150,8 +143,6 @@ " 4\n", " \n", " \n", - " 7\n", - " Male\n", " Other\n", " Male\n", " Other\n", @@ -161,8 +152,6 @@ " 1\n", " \n", " \n", - " 8\n", - " Male\n", " Caucasian\n", " Male\n", " Caucasian\n", @@ -173,8 +162,6 @@ " \n", " \n", " ...\n", - " ...\n", - " ...\n", " ...\n", " ...\n", " ...\n", @@ -183,8 +170,6 @@ " ...\n", " \n", " \n", - " 10996\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -194,8 +179,6 @@ " 7\n", " \n", " \n", - " 10997\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -205,8 +188,6 @@ " 3\n", " \n", " \n", - " 10999\n", - " Male\n", " Other\n", " Male\n", " Other\n", @@ -216,8 +197,7 @@ " 1\n", " \n", " \n", - " 11000\n", - " Female\n", + " Female\n", " African-American\n", " Female\n", " African-American\n", @@ -227,8 +207,6 @@ " 2\n", " \n", " \n", - " 11001\n", - " Female\n", " Hispanic\n", " Female\n", " Hispanic\n", @@ -243,33 +221,33 @@ "" ], "text/plain": [ - " sex race age_cat \\\n", - "id sex race \n", - "1 Male Other Male Other Greater than 45 \n", - "3 Male African-American Male African-American 25 - 45 \n", - "4 Male African-American Male African-American Less than 25 \n", - "7 Male Other Male Other 25 - 45 \n", - "8 Male Caucasian Male Caucasian 25 - 45 \n", - "... ... ... ... \n", - "10996 Male African-American Male African-American Less than 25 \n", - "10997 Male African-American Male African-American Less than 25 \n", - "10999 Male Other Male Other Greater than 45 \n", - "11000 Female African-American Female African-American 25 - 45 \n", - "11001 Female Hispanic Female Hispanic Less than 25 \n", + " sex race age_cat \\\n", + "sex race \n", + "Male Other Male Other Greater than 45 \n", + " African-American Male African-American 25 - 45 \n", + " African-American Male African-American Less than 25 \n", + " Other Male Other 25 - 45 \n", + " Caucasian Male Caucasian 25 - 45 \n", + "... ... ... ... \n", + " African-American Male African-American Less than 25 \n", + " African-American Male African-American Less than 25 \n", + " Other Male Other Greater than 45 \n", + "Female African-American Female African-American 25 - 45 \n", + " Hispanic Female Hispanic Less than 25 \n", "\n", - " priors_count c_charge_degree decile_score \n", - "id sex race \n", - "1 Male Other 0 F 1 \n", - "3 Male African-American 0 F 3 \n", - "4 Male African-American 1 to 5 F 4 \n", - "7 Male Other 0 M 1 \n", - "8 Male Caucasian More than 5 F 6 \n", - "... ... ... ... \n", - "10996 Male African-American 0 F 7 \n", - "10997 Male African-American 0 F 3 \n", - "10999 Male Other 0 F 1 \n", - "11000 Female African-American 1 to 5 M 2 \n", - "11001 Female Hispanic 1 to 5 F 4 \n", + " priors_count c_charge_degree decile_score \n", + "sex race \n", + "Male Other 0 F 1 \n", + " African-American 0 F 3 \n", + " African-American 1 to 5 F 4 \n", + " Other 0 M 1 \n", + " Caucasian More than 5 F 6 \n", + "... ... ... ... \n", + " African-American 0 F 7 \n", + " African-American 0 F 3 \n", + " Other 0 F 1 \n", + "Female African-American 1 to 5 M 2 \n", + " Hispanic 1 to 5 F 4 \n", "\n", "[6172 rows x 6 columns]" ] @@ -299,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "V-oGf_Kr0Jig", "outputId": "b80bbe35-bae8-47f9-c6a4-0849d2f3994a" @@ -320,6 +298,7 @@ "dec = X[['decile_score']]\n", "northpointe = LogisticRegression(penalty='none').fit(dec, y)\n", "y_prob = northpointe.predict_proba(dec)[:, 1]\n", + "y_prob = pd.Series(y_prob, name='recid_prob', index=X.index)\n", "\n", "f, ax = plt.subplots(figsize=(6, 6))\n", "RocCurveDisplay.from_estimator(northpointe, dec, y, ax=ax);" @@ -327,14 +306,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "FdGrKX300Jig" }, "outputs": [], "source": [ - "df = pd.concat([X, pd.Series(1-y_prob, name='recid_prob', index=X.index)], axis=1)\n", - "orig_clf = df.groupby('decile_score').mean().recid_prob" + "df = pd.concat([X, 1-y_prob], axis=1)\n", + "orig_clf = df.groupby('decile_score').recid_prob.mean()" ] }, { @@ -350,19 +329,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "9okV_MYh0Jii", "outputId": "7d43e67c-99f9-4c96-dbe4-4ba7edb9f762" }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Function mdss_bias_scan is deprecated; Change to new interface - aif360.sklearn.detectors.mdss_detector.bias_scan by version 0.5.0.\n" - ] - }, { "data": { "text/plain": [ @@ -375,8 +347,8 @@ } ], "source": [ - "priv_sub, priv_score = mdss_bias_scan(y, y_prob, X=X, pos_label='Survived',\n", - " penalty=0.5, privileged=True)\n", + "priv_sub, priv_score = bias_scan(X, y, y_prob, pos_label='Survived',\n", + " penalty=0.5, overpredicted=True)\n", "priv = df[priv_sub.keys()].isin(priv_sub).all(axis=1)\n", "priv_sub, priv_score" ] @@ -392,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "7Twg3LBh0Jij", "outputId": "5b9dd4fa-cb5a-4f15-fee6-f494e59604ed" @@ -427,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "id": "TcmWF0oE0Jik", "outputId": "4797e9af-8df2-43b4-ae7e-50cd36830a3b" @@ -445,15 +417,15 @@ } ], "source": [ - "unpriv_sub, unpriv_score = mdss_bias_scan(y, y_prob, X=X, pos_label='Survived',\n", - " penalty=0.5, privileged=False)\n", + "unpriv_sub, unpriv_score = bias_scan(X, y, y_prob, pos_label='Survived',\n", + " penalty=0.5, overpredicted=False)\n", "unpriv = df[unpriv_sub.keys()].isin(unpriv_sub).all(axis=1)\n", "unpriv_sub, unpriv_score" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "id": "i5YcmHkL0Jik", "outputId": "15340c08-41c7-4043-9800-75b416891a00" @@ -486,7 +458,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "ECQzsBEJ0Jil" }, @@ -494,18 +466,19 @@ "source": [ "dec = dec.assign(priors_count=X['priors_count'].cat.codes)\n", "northpointe = LogisticRegression(penalty='none').fit(dec, y)\n", - "y_prob_pc = northpointe.predict_proba(dec)[:, 1]" + "y_prob_pc = northpointe.predict_proba(dec)[:, 1]\n", + "y_prob_pc = pd.Series(y_prob_pc, name='recid_prob', index=X.index)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "id": "soKsVOlK0Jim" }, "outputs": [], "source": [ - "df = pd.concat([X, pd.Series(1-y_prob_pc, name='recid_prob', index=X.index)], axis=1)" + "df = pd.concat([X, 1-y_prob_pc], axis=1)" ] }, { @@ -519,19 +492,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "id": "LUDfrmiG0Jim", "outputId": "3a4c7e5b-ade8-4083-bfb8-2145d5c5cffb" }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Function mdss_bias_scan is deprecated; Change to new interface - aif360.sklearn.detectors.mdss_detector.bias_scan by version 0.5.0.\n" - ] - }, { "data": { "text/plain": [ @@ -544,15 +510,15 @@ } ], "source": [ - "priv_sub, priv_score = mdss_bias_scan(y, y_prob_pc, X=X, pos_label='Survived',\n", - " penalty=1, privileged=True)\n", + "priv_sub, priv_score = bias_scan(X, y, y_prob_pc, pos_label='Survived',\n", + " penalty=1, overpredicted=True)\n", "priv = df[priv_sub.keys()].isin(priv_sub).all(axis=1)\n", "priv_sub, priv_score" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "id": "9QT8YdEY0Jin", "outputId": "39c3d98d-dbe7-4b9c-e37f-d77171ff4b3a" @@ -575,7 +541,7 @@ "print(f'n = {sum(priv)}')\n", "\n", "priv_unpen = mdss_bias_score(y, y_prob_pc, X=X, subset=priv_sub,\n", - " pos_label='Survived', privileged=True, penalty=0)\n", + " pos_label='Survived', overpredicted=True, penalty=0)\n", "print(f'unpenalized score: {priv_unpen:.2f}')" ] }, @@ -590,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "id": "ymoBNKwu0Jin", "outputId": "c9fa465a-560b-413d-abe2-3155ce2eab69" @@ -611,15 +577,15 @@ } ], "source": [ - "unpriv_sub, unpriv_score = mdss_bias_scan(y, y_prob_pc, X=X, pos_label='Survived',\n", - " penalty=0.25, privileged=False, n_iter=25)\n", + "unpriv_sub, unpriv_score = bias_scan(X, y, y_prob_pc, pos_label='Survived',\n", + " penalty=0.25, overpredicted=False, num_iters=25)\n", "unpriv = df[unpriv_sub.keys()].isin(unpriv_sub).all(axis=1)\n", "unpriv_sub, unpriv_score" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "id": "zFRvNXCH0Jio", "outputId": "2d54ade4-6b77-481f-d21f-59cdeb572580" @@ -642,7 +608,7 @@ "print(f'n = {sum(unpriv)}')\n", "\n", "unpriv_unpen = mdss_bias_score(y, y_prob_pc, X=X, subset=unpriv_sub,\n", - " pos_label='Survived', privileged=False, penalty=0)\n", + " pos_label='Survived', overpredicted=False, penalty=0)\n", "print(f'unpenalized score: {unpriv_unpen:.2f}')" ] }, @@ -657,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "id": "sKAh4tzZ0Jip", "outputId": "7bdba24a-d496-4dba-e137-22d82ab95b45" @@ -685,7 +651,6 @@ " \n", " \n", " \n", - " \n", " sex\n", " race\n", " age_cat\n", @@ -696,7 +661,6 @@ " group\n", " \n", " \n", - " id\n", " sex\n", " race\n", " \n", @@ -711,8 +675,7 @@ " \n", " \n", " \n", - " 1\n", - " Male\n", + " Male\n", " Other\n", " Male\n", " Other\n", @@ -724,8 +687,6 @@ " neither\n", " \n", " \n", - " 3\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -737,8 +698,6 @@ " neither\n", " \n", " \n", - " 4\n", - " Male\n", " African-American\n", " Male\n", " African-American\n", @@ -750,8 +709,6 @@ " under-estimated\n", " \n", " \n", - " 7\n", - " Male\n", " Other\n", " Male\n", " Other\n", @@ -763,8 +720,6 @@ " neither\n", " \n", " \n", - " 8\n", - " Male\n", " Caucasian\n", " Male\n", " Caucasian\n", @@ -780,29 +735,29 @@ "" ], "text/plain": [ - " sex race age_cat \\\n", - "id sex race \n", - "1 Male Other Male Other Greater than 45 \n", - "3 Male African-American Male African-American 25 - 45 \n", - "4 Male African-American Male African-American Less than 25 \n", - "7 Male Other Male Other 25 - 45 \n", - "8 Male Caucasian Male Caucasian 25 - 45 \n", + " sex race age_cat priors_count \\\n", + "sex race \n", + "Male Other Male Other Greater than 45 0 \n", + " African-American Male African-American 25 - 45 0 \n", + " African-American Male African-American Less than 25 1 to 5 \n", + " Other Male Other 25 - 45 0 \n", + " Caucasian Male Caucasian 25 - 45 More than 5 \n", "\n", - " priors_count c_charge_degree decile_score \\\n", - "id sex race \n", - "1 Male Other 0 F 1 \n", - "3 Male African-American 0 F 3 \n", - "4 Male African-American 1 to 5 F 4 \n", - "7 Male Other 0 M 1 \n", - "8 Male Caucasian More than 5 F 6 \n", + " c_charge_degree decile_score recid_prob \\\n", + "sex race \n", + "Male Other F 1 0.186358 \n", + " African-American F 3 0.265247 \n", + " African-American F 4 0.448002 \n", + " Other M 1 0.186358 \n", + " Caucasian F 6 0.696115 \n", "\n", - " recid_prob group \n", - "id sex race \n", - "1 Male Other 0.186358 neither \n", - "3 Male African-American 0.265247 neither \n", - "4 Male African-American 0.448002 under-estimated \n", - "7 Male Other 0.186358 neither \n", - "8 Male Caucasian 0.696115 neither " + " group \n", + "sex race \n", + "Male Other neither \n", + " African-American neither \n", + " African-American under-estimated \n", + " Other neither \n", + " Caucasian neither " ] }, "execution_count": 15, @@ -820,7 +775,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "id": "FITyXnKz0Jiq" }, @@ -834,7 +789,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "id": "HlB5K8ps0Jiq", "outputId": "262e523a-0ee6-4bf3-e75a-1de1cc8dfb1d" @@ -842,7 +797,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -852,7 +807,7 @@ } ], "source": [ - "p = sns.relplot(data=df.groupby(['decile_score', 'priors_count', 'group']).mean(),\n", + "p = sns.relplot(data=df.groupby(['decile_score', 'priors_count', 'group']).mean(numeric_only=True),\n", " x='decile_score', y='recid_prob', hue='priors_count',\n", " style='priors_count', palette=['r', 'g', 'b'],\n", " markers=['o', 's', '^'], col='group', s=250)\n", diff --git a/examples/sklearn/demo_mdss_classifier_metric_sklearn.ipynb b/examples/sklearn/demo_mdss_classifier_metric_sklearn.ipynb index fd9a5f89..a84e2169 100644 --- a/examples/sklearn/demo_mdss_classifier_metric_sklearn.ipynb +++ b/examples/sklearn/demo_mdss_classifier_metric_sklearn.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "id": "2oasn4AW0aED" }, @@ -69,7 +69,8 @@ "from sklearn.linear_model import LogisticRegression\n", "\n", "from aif360.sklearn.datasets import fetch_compas\n", - "from aif360.sklearn.metrics import mdss_bias_scan, mdss_bias_score" + "from aif360.sklearn.detectors import bias_scan\n", + "from aif360.sklearn.metrics import mdss_bias_score" ] }, { @@ -87,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "id": "FGRJcJP80aEH" }, @@ -113,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "Qz-mlm9Y0aEJ", "outputId": "469c0fbd-8a56-4eb5-99bf-2e401726d59c" @@ -235,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "Cf2FVBPx0aEM", "outputId": "e3816c51-94af-4086-ec6a-9ef641481e78" @@ -269,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "lXPEpsmt0aEP" }, @@ -280,7 +281,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "s_gzSzvf0aEQ", "outputId": "15b10052-2da0-4502-8385-16f3105684c2" @@ -421,7 +422,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "id": "ZN1YkR6x0aET", "outputId": "890421fa-0778-48e7-8f08-a2ffce372572" @@ -439,15 +440,15 @@ "source": [ "print(mdss_bias_score(df['observed'], df['probabilities'], pos_label='Survived',\n", " X=df.iloc[:, :-2], subset={'sex': ['Female']},\n", - " privileged=True))\n", + " overpredicted=True))\n", "print(mdss_bias_score(df['observed'], df['probabilities'], pos_label='Survived',\n", " X=df.iloc[:, :-2], subset={'sex': ['Male']},\n", - " privileged=False))" + " overpredicted=False))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "id": "r5W7-R-n0aEU", "outputId": "d140e34f-009f-4537-cb2a-544b1147d255" @@ -465,10 +466,10 @@ "source": [ "print(mdss_bias_score(df['observed'], df['probabilities'], pos_label='Survived',\n", " X=df.iloc[:, :-2], subset={'sex': ['Male']},\n", - " privileged=True))\n", + " overpredicted=True))\n", "print(mdss_bias_score(df['observed'], df['probabilities'], pos_label='Survived',\n", " X=df.iloc[:, :-2], subset={'sex': ['Female']},\n", - " privileged=False))" + " overpredicted=False))" ] }, { @@ -493,33 +494,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "bmxiLwWH0aEW", "outputId": "c1a5b76a-05b8-441a-a6fc-7219e48a298b" }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Function mdss_bias_scan is deprecated; Change to new interface - aif360.sklearn.detectors.mdss_detector.bias_scan by version 0.5.0.\n", - "Function mdss_bias_scan is deprecated; Change to new interface - aif360.sklearn.detectors.mdss_detector.bias_scan by version 0.5.0.\n" - ] - } - ], + "outputs": [], "source": [ - "privileged_subset = mdss_bias_scan(df['observed'], df['probabilities'],\n", - " X=df[df.columns[:-2]], pos_label='Survived',\n", - " penalty=0.5, privileged=True)\n", - "unprivileged_subset = mdss_bias_scan(df['observed'], df['probabilities'],\n", - " X=df[df.columns[:-2]], pos_label='Survived',\n", - " penalty=0.5, privileged=False)" + "privileged_subset = bias_scan(df[df.columns[:-2]], df['observed'], df['probabilities'],\n", + " pos_label='Survived', penalty=0.5, overpredicted=True)\n", + "unprivileged_subset = bias_scan(df[df.columns[:-2]], df['observed'], df['probabilities'],\n", + " pos_label='Survived', penalty=0.5, overpredicted=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "id": "BQVzouil0aEW", "outputId": "c10bf3fc-11f6-4d35-ca2d-a5b94ab54035" @@ -541,7 +531,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "id": "7VOBEZQF0aEX" }, @@ -574,7 +564,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "id": "8xR8re-50aEX" }, @@ -586,7 +576,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "id": "rPHME8hD0aEY", "outputId": "8df140b3-8c86-4c36-d2f9-61d46db861ed", @@ -614,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "id": "ELJWYT6h0aEY", "outputId": "59d16cf4-805d-42da-9be1-a5a409571426" @@ -638,7 +628,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "id": "HgbAKAXr0aEY" }, @@ -649,7 +639,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "id": "Kqo_xwTq0aEY" }, @@ -661,7 +651,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "id": "tzUpqGoS0aEZ", "outputId": "fbaf1373-dbd7-4adf-b4b5-08e016ad6a19" @@ -688,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "id": "abXJJzI70aEZ", "outputId": "79487689-714c-42ee-ec25-ce1ab098fe95" @@ -712,7 +702,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "id": "E1SgN9480aEZ" },