{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![MLU Logo](../../data/MLU_Logo.png)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# Responsible AI - Logistic Regression \n", "\n", "\n", "This notebook shows how to build a [LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) model to predict whether an individuals' income is $\\leq$ 50k or not using US census data.\n", "\n", "__Dataset:__ \n", "You will download a dataset for this exercise using [folktables](https://github.com/zykls/folktables). Folktables provides an API to download data from the American Community Survey (ACS) Public Use Microdata Sample (PUMS) files which are 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", "\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", " * Train - Validation - Test Datasets\n", " * Data processing with Pipeline and ColumnTransformer\n", "3. Train (and Tune) a Classifier\n", "4. Test the Classifier\n", "5. Accuracy Difference and DPPL\n", "\n", "\n", "Before building the logistic regression model, let's have a quick look at how a linear regression can be turned into a classifier.\n", "\n", "Let's assume we want to use a feature (e.g. Class of Worker) to build a model that can predict the income class. A first step could be to plot the feature vs the model target. As class of worker is a categorical feature we introduce a little jitter to see the data points more easily.\n", "\n", "\"drawing\"\n", "\n", "Now that we have a plot, we can fit a linear regression through the data points.\n", "\n", "\"drawing\"\n", "\n", "As we notice, the linear regression line extends beyond the target values. This is not ideal as we can end up making predictions that are outside the model target range (0 or 1); a linear regression can predict values in the range ($-\\inf$, $+\\inf$). To squish the linear regression values into a range of 0 to 1, we need to use a helper function. For this, we can use the sigmoid function:\n", "\n", "
\n", "$\\frac{1}{1 + \\exp(- (w_{0} + w_{1}\\cdot x_{1}+ w_{2}\\cdot x_{2} + ...))}$\n", "
\n", "


\n", "\n", "Wrapping the linear regression in a sigmoid function will create a so-called Logistic Regression and allow us to make binary predictions as the resulting values will be in the rage 0-1.\n", "\n", "\"drawing\"\n", "\n", "We can simply read out the values on the line now to get a probability for a certain individual obtaining a certain outcome. This covers the basics of Logistic Regression and it's time to code!" ] }, { "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": { "tags": [] }, "outputs": [], "source": [ "!pip install --no-deps -U -q -r ../../requirements.txt" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "tags": [] }, "outputs": [], "source": [ "# Reshaping/basic libraries\n", "import pandas as pd\n", "import numpy as np\n", "\n", "# Plotting libraries\n", "import matplotlib.pyplot as plt\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", "from sklearn.utils import resample\n", "\n", "# Operational libraries\n", "import sys\n", "\n", "sys.path.append(\"..\")\n", "\n", "# Fairness libraries\n", "from folktables.acs import *\n", "from folktables.folktables import *\n", "from folktables.load_acs import *\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 we want to use only 2 groups (see DATAPREP notebook for details)\n", "df = df[df[\"RAC1P\"].isin([6, 8])].copy(deep=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Data Processing\n", "(Go to top)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "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", " \"RAC1P\",\n", " \"GCL\",\n", "]\n", "\n", "numerical_features = [\"AGEP\", \"WKHP\", \"PWGTP\"]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "tags": [] }, "outputs": [], "source": [ "# We cast categorical features to `category`\n", "df[categorical_features] = df[categorical_features].astype(\"object\")\n", "\n", "# We 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 object \n", " 10 PWGTP 55502 non-null int64 \n", " 11 GCL 41987 non-null object \n", " 12 >50k 55502 non-null float64\n", "dtypes: float64(1), int64(3), object(9)\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 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', 'RAC1P', 'GCL', 'AGEP', 'WKHP', 'PWGTP']\n", "Model target: >50k\n" ] } ], "source": [ "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", "RAC1P 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": { "tags": [] }, "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)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# Let's also clean up the dataframe and only keep the features and columns we need\n", "df = df[model_features + [model_target]].copy(deep=True)" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### 2.3 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": 18, "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", "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": { "tags": [] }, "source": [ "### 2.4 Data processing with Pipeline and ColumnTransformer\n", "(Go to Data Processing)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's build a full model pipeline. We need pre-processing 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": 19, "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', 'RAC1P'])])),\n",
       "                ('lg', LogisticRegression(penalty='none'))])
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', 'RAC1P'])])),\n", " ('lg', LogisticRegression(penalty='none'))])" ] }, "execution_count": 19, "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", "### 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(solver=\"lbfgs\", penalty=\"none\")),\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": { "tags": [] }, "source": [ "## 3. Train a Classifier\n", "(Go to top)\n", "\n", "We use the pipeline with the desired data transformers, along with a Logistic Regression estimator for training.\n" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### Model Training\n", "\n", "We train the classifier with`.fit()` on our training dataset. " ] }, { "cell_type": "code", "execution_count": 20, "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', 'RAC1P'])])),\n",
       "                ('lg', LogisticRegression(penalty='none'))])
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', 'RAC1P'])])),\n", " ('lg', LogisticRegression(penalty='none'))])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "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)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We won't tune the classifier at this point, and simply use the validation set as additional test:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model performance on the validation set:\n", "Validation accuracy: 0.8070198852262112\n" ] } ], "source": [ "# Get validation data to tune the classifier\n", "X_val = val_data[model_features]\n", "y_val = val_data[model_target]\n", "\n", "y_val_pred = pipeline.predict(X_val)\n", "\n", "print(\"Model performance on the validation set:\")\n", "print(\"Validation accuracy:\", accuracy_score(y_val, y_val_pred))" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "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. \n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model performance on the test set:\n", "Test accuracy: 0.7957124842370744\n" ] } ], "source": [ "# Get test data to evaluate the performance of the classifier\n", "X_test = test_data[model_features]\n", "y_test = test_data[model_target]\n", "\n", "# Use the fitted model to make predictions on the test dataset\n", "# Test 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 make predictions\n", "test_predictions = pipeline.predict(X_test)\n", "\n", "print(\"Model performance on the test set:\")\n", "print(\"Test accuracy:\", accuracy_score(y_test, test_predictions))" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## 5. Accuracy Difference and DPPL\n", "(Go to top)\n", "\n", "### DPPL\n", "DPPL (Difference in Proportion of Predicted Labels) is an extension of DPL where the outcome we compare is the prediction the model creates (rather than the ground truth value). The equation remains basically the same, only we are counting positive outcomes as per model prediction:\n", "\n", "\n", "$\\large DPPL = \\frac{\\hat{n}_{pred>50k \\wedge RAC1P=6}}{n_{RAC1P=6}} - \\frac{\\hat{n}_{pred>50k \\wedge RAC1P=8}}{n_{RAC1P=8}}$\n", "\n", "To calculate DPPL more easily, let's write a function for it that can take different parameters." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "tags": [] }, "outputs": [], "source": [ "def dpl(sensitive_attribute_name, attr_val, target, dataframe):\n", " \"\"\"Function to calculate DPL or DPPL (depending on specified target).\"\"\"\n", " for val in attr_val:\n", " globals()[f\"n_pos_gr{val}\"] = len(\n", " dataframe[\n", " (dataframe[target] == 1) & (dataframe[sensitive_attribute_name] == val)\n", " ]\n", " )\n", " globals()[f\"n_gr{val}\"] = len(\n", " dataframe[dataframe[sensitive_attribute_name] == val]\n", " )\n", "\n", " dpl = n_pos_gr6 / n_gr6 - n_pos_gr8 / n_gr8\n", " return dpl" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "0.39042883346074" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create dataframe that contains predictions and the sensitive attribute\n", "dpl_df = pd.concat(\n", " [\n", " test_data.reset_index(drop=True)[[\"RAC1P\", \">50k\"]],\n", " pd.Series(test_predictions, name=\"y_test_pred\"),\n", " ],\n", " axis=1,\n", ")\n", "\n", "dpl(\"RAC1P\", [6, 8], \"y_test_pred\", dpl_df)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's compare this to the original DPL value (the difference in proportion of labels in the original dataframe):" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "0.25824245532436" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dpl(\"RAC1P\", [6, 8], \">50k\", test_data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The DPL value is smaller than the DPPL value. It seems that the model is producing a more biased output compared to the ground truth data. This could be due to the different success rates for the different groups in our model. Generally, models will make better predictions for the larger group (meaning, the larger group drives the overall model performance and whatever outcome is dominant in the larger group, will occur more frequently in the predictions).\n", "\n", "Let's see if we can observe this behavior in our model predictions and calculate overall accuracy first." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "0.7957124842370744" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Accuracy score across all groups\n", "accuracy_score(dpl_df[\">50k\"], dpl_df[\"y_test_pred\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's also have a look at the accuracy difference between `RAC1P=6` and `RAC1P=8`." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "0.7746350364963503" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Accuracy score for RAC1P=1\n", "acc_gr6 = accuracy_score(\n", " dpl_df[dpl_df[\"RAC1P\"] == 6][\">50k\"], dpl_df[dpl_df[\"RAC1P\"] == 6][\"y_test_pred\"]\n", ")\n", "\n", "acc_gr6" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "0.8263367211665931" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Accuracy score for RAC1P=8\n", "acc_gr8 = accuracy_score(\n", " dpl_df[dpl_df[\"RAC1P\"] == 8][\">50k\"], dpl_df[dpl_df[\"RAC1P\"] == 8][\"y_test_pred\"]\n", ")\n", "\n", "acc_gr8" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Accuracy Difference\n", "We calculate the Accuracy Difference by subtracting the two values we calculated above:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "-0.05170168467024272" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "acc_gr6 - acc_gr8" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, the accuracy for the group we assume to be at an advantage is higher than the accuracy for the disfavored group. We can dive deeper to see what's going on and plot the confusion matrix and we should also look at confidence intervals." ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "array([1723, 81, 312, 147])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Confusion matrix for RAC1P=8\n", "confusion_matrix(\n", " dpl_df[dpl_df[\"RAC1P\"] == 8][\">50k\"], dpl_df[dpl_df[\"RAC1P\"] == 8][\"y_test_pred\"]\n", ").ravel()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's compare this confusion matrix with the one for the favored group." ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "array([1352, 420, 321, 1195])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Confusion matrix for RAC1P=1\n", "confusion_matrix(\n", " dpl_df[dpl_df[\"RAC1P\"] == 6][\">50k\"], dpl_df[dpl_df[\"RAC1P\"] == 6][\"y_test_pred\"]\n", ").ravel()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To create confidence intervals, we need to create samples first. We can then repeatedly calculate the metric that interests us from the new sample and eventually summarize in aggregate (or visualize in e.g., box plots)." ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "tags": [] }, "outputs": [], "source": [ "def sampling(n_iter=10, group=1):\n", " tn_ls, fp_ls, fn_ls, tp_ls = [], [], [], []\n", " output = {}\n", " for i in range(0, n_iter):\n", " sample = resample(test_data, replace=True, n_samples=5551, stratify=None)\n", " sample = sample[sample[\"RAC1P\"] == group]\n", " tn, fp, fn, tp = confusion_matrix(\n", " sample[model_target], pipeline.predict(sample[model_features])\n", " ).ravel()\n", " tn_ls.append(tn), fp_ls.append(fp), fn_ls.append(fn), tp_ls.append(tp)\n", " output[\"tn\"] = tn_ls\n", " output[\"fp\"] = fp_ls\n", " output[\"fn\"] = fn_ls\n", " output[\"tp\"] = tp_ls\n", " return pd.DataFrame.from_dict(output, orient=\"columns\", dtype=None, columns=None)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "# Initialize figure\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\n", "\n", "# Set title of figure\n", "fig.suptitle(\"Comparison of Classification Errors\")\n", "\n", "# Set title\n", "ax1.title.set_text(\"Group 6\")\n", "ax2.title.set_text(\"Group 8\")\n", "\n", "# Create boxplot\n", "sns.boxplot(data=sampling(n_iter=100, group=6), ax=ax1)\n", "sns.boxplot(data=sampling(n_iter=100, group=8), ax=ax2)\n", "\n", "# Align y-axis\n", "ax1.sharey(ax2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Generally we can see that group 6 has a much higher share of positive predictions than group 8 (add FP + TP for total positive predictions). Furthermore, we observe that the errors are not balanced between false positives and false negatives for the disfavored group (whereas they are within the error bounds for the favored group). For group 8 there is a larger share of false negatives (predicted salary as $\\leq$ 50k, when it was actually higher) than false positives. \n", "This is concerning:\n", "- The model is penalizing individuals that should have been predicted as positive $\\rightarrow$ if this model is used to show job ads based on a 50k salary threshold, a lot of individuals that should have been eligible to see the ad, won't receive it. This causes a negative reinforcement of existing bias.\n", "- The imbalance is not as drastic for the favored group. For this group, we observe more false positives, than false negatives. This means that people are incorrectly predicted positive for the favored group. This causes further amplification of the bias." ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "# Initialize figure\n", "fig, (ax1, ax2) = plt.subplots(1, 2, 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 distribution\")\n", "\n", "# Create plots\n", "dpl_df.groupby([\"RAC1P\", model_target]).size().unstack().plot(\n", " kind=\"bar\", stacked=True, color=sns.husl_palette(2), ax=ax1\n", ")\n", "dpl_df.groupby([\"RAC1P\", \"y_test_pred\"]).size().unstack().plot(\n", " kind=\"bar\", stacked=True, color=sns.husl_palette(2), ax=ax2\n", ")\n", "# Align y-axis\n", "ax2.sharey(ax1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We notice that the predictions are less favorable for the disfavored group with even more '0' outcomes than the baseline (which itself was already very biased)." ] }, { "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 }