{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![MLU Logo](../../data/MLU_Logo.png)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# Responsible AI - Equalized Odds\n", "\n", "This notebook shows how to process outputs produced by a probabilistic model to generate fairer results. We will use a logistic regression model to predict whether an individuals' income is $\\leq$ 50k or not using US census data.\n", "\n", "__Dataset:__ \n", "The dataset we will use for this exercise is coming from [folktables](https://github.com/zykls/folktables). Folktables provide code to download data from the American Community Survey (ACS) Public Use Microdata Sample (PUMS) files managed by the US Census Bureau. The data itself is governed by the terms of use provided by the Census Bureau. For more information, see the [Terms of Service](https://www.census.gov/data/developers/about/terms-of-service.html).\n", "\n", "__ML Problem:__ \n", "Ultimately, the goal will be to predict whether an individual's income is above \\\\$50,000. We will filter the ACS PUMS data sample to only include individuals above the age of 16, who reported usual working hours of at least 1 hour per week in the past year, and an income of at least \\\\$100. The threshold of \\\\$50,000 was chosen so that this dataset can serve as a comparable substitute to the [UCI Adult dataset](https://archive.ics.uci.edu/ml/datasets/adult). The income threshold can be changed easily to define new prediction tasks.\n", "\n", "\n", "1. Read the dataset\n", "2. Data Processing\n", " * Exploratory Data Analysis\n", " * Select features to build the model\n", " * Feature Transformation\n", " * Train - Validation - Test Datasets\n", " * Data processing with Pipeline and ColumnTransformer\n", "3. Train (and Tune) a Classifier\n", "4. Test the Classifier" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This notebook assumes an installation of the SageMaker kernel `conda_pytorch_p39`. In addition, libraries from a requirements.txt need to be installed:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "!pip install --no-deps -U -q -r ../../requirements.txt" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "tags": [] }, "outputs": [], "source": [ "%%capture\n", "\n", "# Reshaping/basic libraries\n", "import pandas as pd\n", "import numpy as np\n", "\n", "# Plotting libraries\n", "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline\n", "import seaborn as sns\n", "\n", "sns.set_style(\"darkgrid\", {\"axes.facecolor\": \".9\"})\n", "\n", "# ML libraries\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import confusion_matrix, accuracy_score\n", "from sklearn.impute import SimpleImputer\n", "from sklearn.preprocessing import OneHotEncoder, MinMaxScaler\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.compose import ColumnTransformer\n", "from sklearn.linear_model import LogisticRegression\n", "\n", "# Operational libraries\n", "import sys\n", "\n", "sys.path.append(\"..\")\n", "sys.path.insert(1, \"..\")\n", "\n", "# Fairness libraries\n", "from folktables.acs import *\n", "from folktables.folktables import *\n", "from folktables.load_acs import *\n", "from fairlearn.reductions import EqualizedOdds\n", "from fairlearn.postprocessing import ThresholdOptimizer\n", "from fairlearn.metrics import MetricFrame, selection_rate\n", "\n", "# Jupyter(lab) libraries\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## 1. Read the dataset\n", "(Go to top)\n", "\n", "To read in the dataset, we will be using [folktables](https://github.com/zykls/folktables) which provides access to the US Census dataset. Folktables contains predefined prediction tasks but also allows the user to specify the problem type.\n", "\n", "The US Census dataset distinguishes between household and individuals. To obtain data on individuals, we use `ACSDataSource` with `survey=person`. The feature names for the US Census data follow the same distinction and use `P` for `person` and `H` for `household`, e.g.: `AGEP` refers to age of an individual." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "tags": [] }, "outputs": [], "source": [ "income_features = [\n", " \"AGEP\", # age individual\n", " \"COW\", # class of worker\n", " \"SCHL\", # educational attainment\n", " \"MAR\", # marital status\n", " \"OCCP\", # occupation\n", " \"POBP\", # place of birth\n", " \"RELP\", # relationship\n", " \"WKHP\", # hours worked per week past 12 months\n", " \"SEX\", # sex\n", " \"RAC1P\", # recorded detailed race code\n", " \"PWGTP\", # persons weight\n", " \"GCL\", # grand parents living with grandchildren\n", "]\n", "\n", "# Define the prediction problem and features\n", "ACSIncome = folktables.BasicProblem(\n", " features=income_features,\n", " target=\"PINCP\", # total persons income\n", " target_transform=lambda x: x > 50000,\n", " group=\"RAC1P\",\n", " preprocess=adult_filter, # applies the following conditions; ((AAGE>16) && (AGI>100) && (AFNLWGT>1)&& (HRSWK>0))\n", " postprocess=lambda x: x, # applies post processing, e.g. fill all NAs\n", ")\n", "\n", "# Initialize year, duration (\"1-Year\" or \"5-Year\") and granularity (household or person)\n", "data_source = ACSDataSource(survey_year=\"2018\", horizon=\"1-Year\", survey=\"person\")\n", "# Specify region (here: California) and load data\n", "ca_data = data_source.get_data(states=[\"CA\"], download=True)\n", "# Apply transformation as per problem statement above\n", "ca_features, ca_labels, ca_group = ACSIncome.df_to_numpy(ca_data)\n", "\n", "# Convert numpy array to dataframe\n", "df = pd.DataFrame(\n", " np.concatenate((ca_features, ca_labels.reshape(-1, 1)), axis=1),\n", " columns=income_features + [\">50k\"],\n", ")\n", "\n", "# For further modelling you want to use only 2 groups\n", "df = df[df[\"RAC1P\"].isin([6, 8])].copy(deep=True)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## 2. Data Processing\n", "(Go to top)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 Exploratory Data Analysis\n", "(Go to Data Processing)\n", "\n", "We look at number of rows, columns, and some simple statistics of the dataset." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
AGEPCOWSCHLMAROCCPPOBPRELPWKHPSEXRAC1PPWGTPGCL>50k
030.06.014.01.09610.06.016.040.01.08.032.02.00.0
2723.02.021.05.02545.0207.017.020.02.06.035.0NaN0.0
3318.01.016.05.09610.06.017.08.02.06.033.0NaN0.0
4640.01.015.03.04140.0303.016.022.01.08.038.02.00.0
4918.01.018.05.0725.06.017.012.02.06.060.0NaN0.0
\n", "
" ], "text/plain": [ " AGEP COW SCHL MAR OCCP POBP RELP WKHP SEX RAC1P PWGTP GCL \\\n", "0 30.0 6.0 14.0 1.0 9610.0 6.0 16.0 40.0 1.0 8.0 32.0 2.0 \n", "27 23.0 2.0 21.0 5.0 2545.0 207.0 17.0 20.0 2.0 6.0 35.0 NaN \n", "33 18.0 1.0 16.0 5.0 9610.0 6.0 17.0 8.0 2.0 6.0 33.0 NaN \n", "46 40.0 1.0 15.0 3.0 4140.0 303.0 16.0 22.0 1.0 8.0 38.0 2.0 \n", "49 18.0 1.0 18.0 5.0 725.0 6.0 17.0 12.0 2.0 6.0 60.0 NaN \n", "\n", " >50k \n", "0 0.0 \n", "27 0.0 \n", "33 0.0 \n", "46 0.0 \n", "49 0.0 " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the first five rows\n", "# NaN means missing data\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the dataset is: (55502, 13)\n" ] } ], "source": [ "# Check how many rows and columns we have in the data frame\n", "print(\"The shape of the dataset is:\", df.shape)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 55502 entries, 0 to 195664\n", "Data columns (total 13 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 AGEP 55502 non-null float64\n", " 1 COW 55502 non-null float64\n", " 2 SCHL 55502 non-null float64\n", " 3 MAR 55502 non-null float64\n", " 4 OCCP 55502 non-null float64\n", " 5 POBP 55502 non-null float64\n", " 6 RELP 55502 non-null float64\n", " 7 WKHP 55502 non-null float64\n", " 8 SEX 55502 non-null float64\n", " 9 RAC1P 55502 non-null float64\n", " 10 PWGTP 55502 non-null float64\n", " 11 GCL 41987 non-null float64\n", " 12 >50k 55502 non-null float64\n", "dtypes: float64(13)\n", "memory usage: 5.9 MB\n" ] } ], "source": [ "# Let's see the data types and non-null values for each column\n", "df.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can clearly see that all columns are numerical (`dtype = float64`). However, when checking the column headers (and information at top of the notebook), we should notice that we are actually dealing with multimodal data. We expect to see a mix of categorical, numerical and potentially even text information.\n", "\n", "Let's cast the features accordingly. We start by creating list for each feature type." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "tags": [] }, "outputs": [], "source": [ "categorical_features = [\n", " \"COW\",\n", " \"SCHL\",\n", " \"MAR\",\n", " \"OCCP\",\n", " \"POBP\",\n", " \"RELP\",\n", " \"SEX\",\n", " \"GCL\",\n", "]\n", "\n", "numerical_features = [\"AGEP\", \"WKHP\", \"PWGTP\"]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Cast categorical features to `category`\n", "df[categorical_features] = df[categorical_features].astype(\"object\")\n", "\n", "# Cast numerical features to `int`\n", "df[numerical_features] = df[numerical_features].astype(\"int\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's check with `.info()` again to make sure the changes took effect." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 55502 entries, 0 to 195664\n", "Data columns (total 13 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 AGEP 55502 non-null int64 \n", " 1 COW 55502 non-null object \n", " 2 SCHL 55502 non-null object \n", " 3 MAR 55502 non-null object \n", " 4 OCCP 55502 non-null object \n", " 5 POBP 55502 non-null object \n", " 6 RELP 55502 non-null object \n", " 7 WKHP 55502 non-null int64 \n", " 8 SEX 55502 non-null object \n", " 9 RAC1P 55502 non-null float64\n", " 10 PWGTP 55502 non-null int64 \n", " 11 GCL 41987 non-null object \n", " 12 >50k 55502 non-null float64\n", "dtypes: float64(2), int64(3), object(8)\n", "memory usage: 5.9+ MB\n" ] } ], "source": [ "df.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looks good, so we can now separate model features from model target and sensitive feature to explore them separately." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model features: ['COW', 'SCHL', 'MAR', 'OCCP', 'POBP', 'RELP', 'SEX', 'GCL', 'AGEP', 'WKHP', 'PWGTP']\n", "Model target: >50k\n" ] } ], "source": [ "sensitive_feature = \"RAC1P\"\n", "\n", "model_target = \">50k\"\n", "model_features = categorical_features + numerical_features\n", "\n", "print(\"Model features: \", model_features)\n", "print(\"Model target: \", model_target)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Double check that that target is not accidentally part of the features\n", "model_target in model_features" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All good here. We made sure that the target is not in the feature list. If we find the above statement showing `True` we need to remove the target by calling `model_features.remove(model_target)`.\n", "\n", "Let's have a look at missing values next.\n", "\n", "\n", "#### Missing values\n", "The quickest way to check for missing values is to use `.isna().sum()`. This will provide a count of how many missing values we have. In fact, we can also see the count of missing values with `.info()` as it provided a count of non-null values." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "AGEP 0\n", "COW 0\n", "SCHL 0\n", "MAR 0\n", "OCCP 0\n", "POBP 0\n", "RELP 0\n", "WKHP 0\n", "SEX 0\n", "RAC1P 0\n", "PWGTP 0\n", "GCL 13515\n", ">50k 0\n", "dtype: int64" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Show missing values\n", "df.isna().sum()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before starting with the plots, let's have a look at how many unique instances we have per column. This helps us avoid plotting charts with hundreds of unique values. Let's filter for columns with fewer than 10 unique instances." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "COW 8.0\n", "MAR 5.0\n", "SEX 2.0\n", "GCL 2.0\n", "dtype: float64\n" ] } ], "source": [ "shortlist_fts = (\n", " df[model_features]\n", " .apply(lambda col: col.nunique())\n", " .where(df[model_features].apply(lambda col: col.nunique()) < 10)\n", " .dropna()\n", ")\n", "\n", "print(shortlist_fts)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Target distribution\n", "\n", "Let's check our target distribution." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df[model_target].value_counts().plot.bar(color=\"black\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We notice that we are dealing with an imbalanced dataset. This means there are more examples for one type of results (here: 0; meaning individuals earning $\\leq$ 50k). This is relevant for model choice and potential up-sampling or down-sampling to balance out the classes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Feature distribution(s)\n", "\n", "Let's now plot bar charts for the shortlist features of our dataset (as per above: shortlist - feature columns with less than 10 unique instance classes)." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(nrows=2, ncols=3, figsize=(15, 10))\n", "fig.suptitle(\"Feature Bar Plots\")\n", "\n", "fts = range(len(shortlist_fts.index.tolist()))\n", "for i, ax in zip(fts, axs.ravel()):\n", " df[shortlist_fts.index.tolist()[i]].value_counts().plot.bar(color=\"black\", ax=ax)\n", " ax.set_title(shortlist_fts.index.tolist()[i])\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 Select features to build the model\n", "(Go to Data Processing)\n", "\n", "During the extended EDA in the DATAPREP notebook, we learned that `GCL` is a feature that is equally present for both outcome types and also contains a lot of missing values. Therefore, we can drop it from the list of features we want to use for model build. We also drop `OCCP` and `POBP` as those features have too many unique categories." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [] }, "outputs": [], "source": [ "to_remove = [\"GCL\", \"OCCP\", \"POBP\"]\n", "\n", "# Drop to_remove features from the respective list(s) - if applicable\n", "for ft in to_remove:\n", " if ft in model_features:\n", " model_features.remove(ft)\n", " if ft in categorical_features:\n", " categorical_features.remove(ft)\n", " if ft in numerical_features:\n", " numerical_features.remove(ft)\n", "\n", "# Let's also clean up the dataframe and only keep the features and columns we need\n", "df = df[model_features + [sensitive_feature] + [model_target]].copy(deep=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.3 Feature transformation\n", "(Go to Data Processing)\n", "\n", "In this notebook, we won't perform any transformation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.4 Train - Validation - Test Datasets\n", "(Go to Data Processing)\n", "\n", "To get a training, test and validation set, we will use sklearn's [train_test_split()](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) function." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train - Test - Validation datasets shapes: (42458, 10) (5551, 10) (7493, 10)\n" ] } ], "source": [ "train_data, test_data = train_test_split(\n", " df, test_size=0.1, shuffle=True, random_state=23\n", ")\n", "\n", "train_data, val_data = train_test_split(\n", " train_data, test_size=0.15, shuffle=True, random_state=23\n", ")\n", "\n", "# Print the shapes of the Train - Test Datasets\n", "print(\n", " \"Train - Test - Validation datasets shapes: \",\n", " train_data.shape,\n", " test_data.shape,\n", " val_data.shape,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.4 Data processing with Pipeline and ColumnTransformer\n", "(Go to Data Processing)\n", "\n", "Let's build a full model pipeline. We need preprocessing split per data type, and then combine everything back into a composite pipeline along with a model. To achieve this, we will use sklearns `Pipeline` and `ColumnTransformer`.\n", "\n", "__Step 1 (set up pre-processing per data type):__\n", "> For the numerical features pipeline, the __numerical_processor__ below, we impute missing values with the mean using sklearn's `SimpleImputer`, followed by a `MinMaxScaler` (don't have to scale features when using Decision Trees, but it's a good idea to see how to use more data transforms). If different processing is desired for different numerical features, different pipelines should be built - just like shown below for the two text features.\n", "\n", " > In the categorical features pipeline, the __categorical_processor__ below, we impute with a placeholder value and encode with sklearn's `OneHotEncoder`. If computing memory is an issue, it is a good idea to check categoricals' unique values, to get an estimate of many dummy features will be created by one-hot encoding. Note the __handle_unknown__ parameter that tells the encoder to ignore (rather than throw an error for) any unique value that might show in the validation/and or test set that was not present in the initial training set.\n", " \n", "__Step 2 (combining pre-processing methods into a transformer):__ \n", " > The selective preparations of the dataset features are then put together into a collective `ColumnTransformer`, to be finally used in a Pipeline along with an estimator. This ensures that the transforms are performed automatically on the raw data when fitting the model and when making predictions, such as when evaluating the model on a validation dataset via cross-validation or making predictions on a test dataset in the future.\n", " \n", "__Step 3 (combining transformer with a model):__ \n", "> Combine `ColumnTransformer` from Step 2 with a selected algorithm in a new pipeline. For example, the algorithm could be a [LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) for classification problems." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "
Pipeline(steps=[('data_processing',\n",
       "                 ColumnTransformer(transformers=[('numerical_processing',\n",
       "                                                  Pipeline(steps=[('num_imputer',\n",
       "                                                                   SimpleImputer()),\n",
       "                                                                  ('num_scaler',\n",
       "                                                                   MinMaxScaler())]),\n",
       "                                                  ['AGEP', 'WKHP', 'PWGTP']),\n",
       "                                                 ('categorical_processing',\n",
       "                                                  Pipeline(steps=[('cat_imputer',\n",
       "                                                                   SimpleImputer(fill_value='missing',\n",
       "                                                                                 strategy='constant')),\n",
       "                                                                  ('cat_encoder',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore'))]),\n",
       "                                                  ['COW', 'SCHL', 'MAR', 'RELP',\n",
       "                                                   'SEX'])])),\n",
       "                ('lg', LogisticRegression(random_state=0))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "Pipeline(steps=[('data_processing',\n", " ColumnTransformer(transformers=[('numerical_processing',\n", " Pipeline(steps=[('num_imputer',\n", " SimpleImputer()),\n", " ('num_scaler',\n", " MinMaxScaler())]),\n", " ['AGEP', 'WKHP', 'PWGTP']),\n", " ('categorical_processing',\n", " Pipeline(steps=[('cat_imputer',\n", " SimpleImputer(fill_value='missing',\n", " strategy='constant')),\n", " ('cat_encoder',\n", " OneHotEncoder(handle_unknown='ignore'))]),\n", " ['COW', 'SCHL', 'MAR', 'RELP',\n", " 'SEX'])])),\n", " ('lg', LogisticRegression(random_state=0))])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "### STEP 1 ###\n", "##############\n", "\n", "# Preprocess the numerical features\n", "numerical_processor = Pipeline(\n", " [(\"num_imputer\", SimpleImputer(strategy=\"mean\")), (\"num_scaler\", MinMaxScaler())]\n", ")\n", "# Preprocess the categorical features\n", "categorical_processor = Pipeline(\n", " [\n", " (\"cat_imputer\", SimpleImputer(strategy=\"constant\", fill_value=\"missing\")),\n", " (\"cat_encoder\", OneHotEncoder(handle_unknown=\"ignore\")),\n", " ]\n", ")\n", "\n", "### STEP 2 ###\n", "##############\n", "\n", "# Combine all data preprocessors from above\n", "data_processor = ColumnTransformer(\n", " [\n", " (\"numerical_processing\", numerical_processor, numerical_features),\n", " (\"categorical_processing\", categorical_processor, categorical_features),\n", " ]\n", ")\n", "\n", "\n", "### STEP 3 ###\n", "##############\n", "\n", "# Pipeline desired all data transformers, along with an estimator at the end\n", "# Later you can set/reach the parameters using the names issued - for hyperparameter tuning, for example\n", "pipeline = Pipeline(\n", " [\n", " (\"data_processing\", data_processor),\n", " (\"lg\", LogisticRegression(random_state=0)),\n", " ]\n", ")\n", "\n", "# Visualize the pipeline\n", "# This will come in handy especially when building more complex pipelines, stringing together multiple preprocessing steps\n", "from sklearn import set_config\n", "\n", "set_config(display=\"diagram\")\n", "pipeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Train a Classifier\n", "(Go to top)\n", "\n", "We use the pipeline, along with a Logistic Regression estimator for training and Equalized Odds postprocessing." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model Training\n", "\n", "We train the classifier with __.fit()__ on our training dataset. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Get train data to train the classifier\n", "X_train = train_data[model_features]\n", "y_train = train_data[model_target]\n", "\n", "# Fit the classifier to the train data\n", "# Train data going through the Pipeline is imputed (with means from the train data),\n", "# scaled (with the min/max from the train data),\n", "# and finally used to fit the model\n", "pipeline.fit(X_train, y_train)\n", "\n", "y_train_pred = pipeline.predict(X_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we want to enforce Equalized Odds. To do so, we are going to use fairlearns `ThresholdOptimzer` to implement Equality of Opportunity. It is a postprocessing algorithm based on the paper [Equality of Opportunity in Supervised Learning](https://proceedings.neurips.cc/paper/2016/file/9d2682367c3935defcb1f9e247a97c0d-Paper.pdf). This technique takes an existing classifier and the sensitive feature as inputs, and derives a transformation of the classifier's prediction to enforce the specified parity constraints." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "
ThresholdOptimizer(constraints='equalized_odds',\n",
       "                   estimator=LogisticRegression(random_state=0))
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "ThresholdOptimizer(constraints='equalized_odds',\n", " estimator=LogisticRegression(random_state=0))" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set up ThresholdOptimizer\n", "eo_model = ThresholdOptimizer(\n", " estimator=pipeline[-1],\n", " constraints=\"equalized_odds\",\n", " objective=\"accuracy_score\",\n", " grid_size=1000,\n", " flip=False,\n", " prefit=False,\n", " predict_method=\"deprecated\",\n", ")\n", "\n", "# Learn the transformation & extract feature names\n", "data_processor.fit(X_train)\n", "\n", "# To extract feature names we first need to fit the data processor as this will generate the one hot encoding\n", "ft_names = numerical_features + list(\n", " data_processor.transformers_[1][1]\n", " .named_steps[\"cat_encoder\"]\n", " .get_feature_names(categorical_features)\n", ")\n", "\n", "# Add column names and convert to data frame\n", "X_train_prep = pd.DataFrame(\n", " data_processor.transform(X_train).todense(), columns=ft_names\n", " )\n", "\n", "# Adjust the results that the classifier would produce by letting ThresholdOptimizer know what the sensitive features are\n", "eo_model.fit(X_train_prep, y_train, sensitive_features=train_data[\"RAC1P\"].values)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "tags": [] }, "outputs": [], "source": [ "# You can now use the fitted equalized odds post-processor and use it to create adjusted outcomes (predictions)\n", "y_train_adjusted = eo_model.predict(\n", " X_train_prep, sensitive_features=train_data[\"RAC1P\"].values\n", ")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Join the data, adjusted predictions, original predictions, and the true outcome\n", "eop_df_train = pd.DataFrame(\n", " {\n", " \"RAC1P\": train_data[\"RAC1P\"].reset_index(drop=True),\n", " \"y_train_adjusted\": y_train_adjusted,\n", " \"y_train_pred\": y_train_pred,\n", " \"y_train_true\": train_data[model_target].reset_index(drop=True),\n", " }\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Test the Classifier\n", "(Go to top)\n", "\n", "Let's now evaluate the performance of the trained classifier on the test dataset. We use __.predict()__ this time. " ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 0 0 ... 1 1 0]\n" ] } ], "source": [ "# Create the adjusted predictions for test and convert to dataframe\n", "y_test_adjusted = eo_model.predict(\n", " data_processor.transform(test_data[model_features]).todense(),\n", " sensitive_features=test_data[\"RAC1P\"].values,\n", ")\n", "\n", "# Let's have a look at the adjusted outputs for the test dataset\n", "print(y_test_adjusted)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Join the data, adjusted predictions, original predictions, and the true outcome\n", "eop_df_test = pd.DataFrame(\n", " {\n", " \"RAC1P\": test_data[\"RAC1P\"].reset_index(drop=True),\n", " \"y_test_adjusted\": y_test_adjusted,\n", " \"y_test_true\": test_data[model_target].reset_index(drop=True),\n", " \"y_test_withoutEO\": pipeline.predict(test_data[model_features]),\n", " }\n", ")\n", "\n", "%matplotlib inline\n", "# Initialize figure\n", "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(16, 6))\n", "\n", "# Set title of figure\n", "fig.suptitle(\"Comparison of Model Predictions and Baseline\")\n", "\n", "# Set title\n", "ax1.title.set_text(\"Baseline target distribution\")\n", "ax2.title.set_text(\"Prediction EO adjusted\")\n", "ax3.title.set_text(\"Prediction without EO adjustment\")\n", "\n", "# Create plots\n", "eop_df_test.groupby([\"RAC1P\", \"y_test_true\"]).size().unstack().plot(\n", " kind=\"bar\", stacked=True, color=sns.husl_palette(2), ax=ax1\n", ")\n", "eop_df_test.groupby([\"RAC1P\", \"y_test_adjusted\"]).size().unstack().plot(\n", " kind=\"bar\", stacked=True, color=sns.husl_palette(2), ax=ax2\n", ")\n", "eop_df_test.groupby([\"RAC1P\", \"y_test_withoutEO\"]).size().unstack().plot(\n", " kind=\"bar\", stacked=True, color=sns.husl_palette(2), ax=ax3\n", ")\n", "# Align y-axis\n", "ax2.sharey(ax1)\n", "ax3.sharey(ax1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can clearly see that the ratios between the groups were adjusted drastically (compared to predictions without EO postprocessing). The question remains whether it was fair the reduce the number of positive outcomes for RAC1P group 6. The odds are equal now, but this came at the cost of placing a lot of outcomes that were actually positive into the negative bucket. You can see that if you hadn't enforced Equalized Odds, the model would have actually amplified the existing bias in the dataset." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the end of the notebook." ] } ], "metadata": { "kernelspec": { "display_name": "conda_pytorch_p39", "language": "python", "name": "conda_pytorch_p39" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.15" } }, "nbformat": 4, "nbformat_minor": 4 }