{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![MLU Logo](../../data/MLU_Logo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Responsible AI - SageMaker Clarify\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Amazon SageMaker Clarify](https://aws.amazon.com/sagemaker/clarify/) helps improve your machine learning models by detecting potential bias and helping explain how these models make predictions. The fairness and explainability functionality provided by SageMaker Clarify takes a step towards enabling AWS customers to build trustworthy and understandable machine learning models. \n", "\n", "In this notebook, we highlight how you can use SageMaker to train models, host them an inference endpoint, and provide bias detection and explainability to analyze data and understand prediction outcomes from the model.\n", "\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. Amazon SageMaker Clarify" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This notebook assumes availability of the SageMaker kernel `conda_pyhon3`. In addition, install folktables and sklearn:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "!pip install -U -q scikit-learn==1.1.3\n", "!pip install -U -q --no-deps folktables==0.0.11" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "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", "\n", "# Operational libraries\n", "import sys\n", "from io import StringIO\n", "import os\n", "import time\n", "import sys\n", "import IPython\n", "from time import gmtime, strftime\n", "from datetime import datetime, timedelta\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\")\n", "\n", "\n", "# SageMaker and connection libraries\n", "import boto3\n", "import urllib\n", "import sagemaker\n", "from sagemaker import get_execution_role\n", "from sagemaker import Session\n", "from sagemaker.amazon.amazon_estimator import get_image_uri\n", "from sagemaker.inputs import TrainingInput\n", "from sagemaker.serializers import CSVSerializer\n", "from sagemaker.s3 import S3Downloader, S3Uploader\n", "from sagemaker import clarify\n", "from sagemaker import model_monitor\n", "from datetime import date\n", "\n", "today = date.today()\n", "bucket = sagemaker.Session().default_bucket()\n", "prfx = \"sagemaker/sagemaker-clarify-income-model\"\n", "region = boto3.Session().region_name\n", "client = boto3.client('sagemaker')" ] }, { "cell_type": "markdown", "metadata": {}, "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": {}, "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 granchildren\n", " \"SCH\", # school enrollment\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": {}, "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": {}, "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", " \n", " \n", " \n", " \n", " \n", " \n", "
AGEPCOWSCHLMAROCCPPOBPRELPWKHPSEXRAC1PPWGTPGCLSCH>50k
030.06.014.01.09610.06.016.040.01.08.032.02.01.00.0
2723.02.021.05.02545.0207.017.020.02.06.035.0NaN3.00.0
3318.01.016.05.09610.06.017.08.02.06.033.0NaN2.00.0
4640.01.015.03.04140.0303.016.022.01.08.038.02.01.00.0
4918.01.018.05.0725.06.017.012.02.06.060.0NaN2.00.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", " SCH >50k \n", "0 1.0 0.0 \n", "27 3.0 0.0 \n", "33 2.0 0.0 \n", "46 1.0 0.0 \n", "49 2.0 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": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the dataset is: (55502, 14)\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": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 55502 entries, 0 to 195664\n", "Data columns (total 14 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 SCH 55502 non-null float64\n", " 13 >50k 55502 non-null float64\n", "dtypes: float64(14)\n", "memory usage: 6.4 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": {}, "outputs": [], "source": [ "categorical_features = [\n", " \"COW\",\n", " \"SCHL\",\n", " \"MAR\",\n", " \"OCCP\",\n", " \"POBP\",\n", " \"RELP\",\n", " \"SEX\",\n", " \"GCL\",\n", " \"SCH\",\n", "]\n", "\n", "numerical_features = [\"AGEP\", \"WKHP\", \"PWGTP\"]\n", "\n", "sensitive_feature = [\"RAC1P\"]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# We cast categorical features to `category`\n", "df[categorical_features] = df[categorical_features].astype(\"object\")\n", "\n", "# We cast categorical features to `category`\n", "df[sensitive_feature] = df[sensitive_feature].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": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 55502 entries, 0 to 195664\n", "Data columns (total 14 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 SCH 55502 non-null object \n", " 13 >50k 55502 non-null float64\n", "dtypes: float64(1), int64(3), object(10)\n", "memory usage: 6.4+ 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": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model features: ['COW', 'SCHL', 'MAR', 'OCCP', 'POBP', 'RELP', 'SEX', 'GCL', 'SCH', 'AGEP', 'WKHP', 'PWGTP', 'RAC1P']\n", "Model target: >50k\n" ] } ], "source": [ "model_target = \">50k\"\n", "model_features = categorical_features + numerical_features + sensitive_feature\n", "\n", "print(\"Model features: \", model_features)\n", "print(\"Model target: \", model_target)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "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": {}, "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", "SCH 0\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": [ "No missing values anywhere apart from GCL - we might need to drop this column." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Target distribution\n", "\n", "Let's check our target distribution." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "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. We want to use Seaborns' `pairplot` as this will provide a lot of information about distribution and correlation of features." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sns.pairplot(\n", " df[numerical_features + [\"RAC1P\"]].sample(1000),\n", " hue=\"RAC1P\",\n", " palette=sns.color_palette(\"husl\", 2),\n", ") # this will plot the numerical features and separate by sensitive attribute\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": 15, "metadata": {}, "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", " if ft in sensitive_feature:\n", " sensitive_feature.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 + [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. Before splitting the data, we need to correctly cast categorical and numerical values again. The transformation leads to casting everything as numerical values. We can simply copy the same code we were using in the beginning (make sure to update the dataframe name)." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train - Test - Validation datasets shapes: (42458, 11) (5551, 11) (7493, 11)\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.5 Data processing with Pipeline and ColumnTransformer\n", "(Go to Data Processing)\n", "\n", "Let's build a full model pipeline. We need pre-processing split per data type, and then combine everything back into a composite pipeline. 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", " " ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "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", " (\n", " \"cat_encoder\",\n", " OneHotEncoder(sparse=False, drop=\"if_binary\", handle_unknown=\"ignore\"),\n", " ),\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", ")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# Let's take a smaller sample of all datasets to speed up the next steps\n", "train_data = train_data.sample(frac=0.2, random_state=1)\n", "val_data = val_data.sample(frac=0.2, random_state=1)\n", "test_data = test_data.sample(frac=0.2, random_state=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We learn and apply the transformation. This will create new dataframes that have many more columns (due to the one hot encoding) and will contain normalized numerical features. Careful with the usage of transformation for models that are deployed (rather than single use); we will need a transformation job that can convert incoming data into the same shape as we used to train the model." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "transf_train = data_processor.fit_transform(train_data)\n", "transf_val = data_processor.transform(val_data)\n", "transf_test = data_processor.transform(test_data)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Get the column names for categorical features\n", "cat_ft_names = list(\n", " data_processor.transformers_[1][1]\n", " .named_steps[\"cat_encoder\"]\n", " .get_feature_names(categorical_features)\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have the different data splits, let's upload them to S3. Clarify requires all data to be stored in S3 and we will also need to use an in-built SageMaker model." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Assign file names\n", "train_file, val_file, test_file, = (\n", " \"train.csv\",\n", " \"val.csv\",\n", " \"test.csv\",\n", ")\n", "\n", "# Create dataframes (preprocessed data)\n", "raw_train = pd.DataFrame(transf_train)\n", "raw_val = pd.DataFrame(transf_val)\n", "raw_test = pd.DataFrame(transf_test)\n", "\n", "# Convert\n", "\n", "# Join with model target and sensitive column and save to CSV\n", "pd.concat(\n", " [\n", " train_data[model_target].astype(int).reset_index(drop=True),\n", " train_data[sensitive_feature].astype(object).reset_index(drop=True),\n", " raw_train,\n", " ],\n", " axis=1,\n", ").to_csv(train_file, index=False, header=False, sep=\",\")\n", "\n", "# Repeat for validation data\n", "pd.concat(\n", " [\n", " val_data[model_target].astype(int).reset_index(drop=True),\n", " val_data[sensitive_feature].astype(object).reset_index(drop=True),\n", " raw_val,\n", " ],\n", " axis=1,\n", ").to_csv(val_file, index=False, header=False, sep=\",\")\n", "\n", "# Repeat for test data\n", "pd.concat(\n", " [\n", " test_data[model_target].astype(int).reset_index(drop=True),\n", " test_data[sensitive_feature].astype(object).reset_index(drop=True),\n", " raw_test,\n", " ],\n", " axis=1,\n", ").to_csv(test_file, index=False, header=False, sep=\",\")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((8492, 62), (1110, 62), (1499, 62))" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check that all sets have same number of columns\n", "raw_train.shape, raw_test.shape, raw_val.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.5 Upload Data\n", "(Go to Data Processing)\n", "\n", "Here upload the data to S3." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "train_uri = S3Uploader.upload(train_file, \"s3://{}/{}/data/train\".format(bucket, prfx))\n", "val_uri = S3Uploader.upload(val_file, \"s3://{}/{}/data/train\".format(bucket, prfx))\n", "test_uri = S3Uploader.upload(test_file, \"s3://{}/{}/data/test\".format(bucket, prfx))" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# Delete the CSVs from the local instance\n", "os.remove(test_file)\n", "os.remove(train_file)\n", "os.remove(val_file)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Train a Classifier\n", "(Go to top)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up XGBoost Estimator\n", "\n", "Next, let us set up an XGBoost estimator from the Sklearn pre-built models.\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# Set an output path where the trained model will be saved\n", "output_path = \"s3://{}/{}/output\".format(bucket, prfx)\n", "\n", "# Set required XGboost hyperparameters\n", "hyperparams = {\n", " \"max_depth\": \"5\",\n", " \"subsample\": \"0.7\",\n", " \"verbosity\": \"1\",\n", " \"objective\": \"binary:logistic\",\n", " \"num_round\": \"10\",\n", "}\n", "\n", "# Create a container with XGBoost\n", "container = sagemaker.image_uris.retrieve(\"xgboost\", region, \"latest\")\n", "\n", "# Specify name for training job\n", "job_name = \"clarify-model-xgb-training\"\n", "\n", "# Call the XGBoost estimator object\n", "XGBoost_estimator = sagemaker.estimator.Estimator(\n", " container,\n", " get_execution_role(),\n", " hyperparameters=hyperparams,\n", " disable_profiler=True,\n", " instance_count=1,\n", " base_job_name=job_name,\n", " instance_type=\"ml.m5.2xlarge\",\n", " output_path=output_path,\n", " sagemaker_session=sagemaker.Session(),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Specify the inputs for the model and fit." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker:Creating training-job with name: clarify-model-xgb-training-2023-04-26-05-34-54-986\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "2023-04-26 05:34:57 Starting - Starting the training job..\n", "2023-04-26 05:35:13 Starting - Preparing the instances for training........\n", "2023-04-26 05:35:57 Downloading - Downloading input data....\n", "2023-04-26 05:36:22 Training - Downloading the training image...\n", "2023-04-26 05:36:43 Training - Training image download completed. Training in progress.....\n", "2023-04-26 05:37:09 Uploading - Uploading generated training model.\n", "2023-04-26 05:37:20 Completed - Training job completed\n" ] } ], "source": [ "# Specify the training data\n", "train_input = TrainingInput(train_uri, content_type=\"csv\")\n", "\n", "# Specify the validation data - not necessary, but can be used if tuning desired\n", "validation_input = TrainingInput(val_uri, content_type=\"csv\")\n", "\n", "XGBoost_estimator.fit(\n", " {\"train\": train_input}, logs=False\n", ") # if desired \"validation\": validation_input" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We are almost ready to deploy the model. One final setting we want to specify is `DataCaptureConfig`. This setting will allow us later to check if the data that is submitted to the model endpoint follows a similar distribution as the data that was used for training." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "s3_capture_upload_path = \"s3://{}/{}/datacapture\".format(bucket, prfx)\n", "\n", "data_capture_config = model_monitor.DataCaptureConfig(\n", " enable_capture=True,\n", " sampling_percentage=100,\n", " destination_s3_uri=s3_capture_upload_path,\n", ")" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker:Creating model with name: clarify-model-xgb\n", "INFO:sagemaker:Creating endpoint-config with name clarify-model-xgb-20230426Apr\n", "INFO:sagemaker:Creating endpoint with name clarify-model-xgb-20230426Apr\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "-------!" ] } ], "source": [ "endpointname = \"clarify-model-xgb-%s\" % today.strftime(\"%Y%m%d%h\")\n", "modelname = \"clarify-model-xgb\"\n", "\n", "XGBoost_predictor = XGBoost_estimator.deploy(\n", " initial_instance_count=1,\n", " instance_type=\"ml.t2.medium\",\n", " serializer=CSVSerializer(),\n", " endpoint_name=endpointname,\n", " model_name=modelname,\n", " data_capture_config=data_capture_config,\n", ") # endpoint_name needs to be unique! Use AWS account number as part of name, or at least timestamp" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "b'0.20109091699123383,0.1581142097711563,0.13745033740997314,0.10564066469669342,0.1926421970129013,0.1260198950767517,0.05225953087210655,0.24344408512115479,0.08050476759672165,0.1260198950767517,0.18747873604297638,0.14705978333950043,0.1926421970129013,0.1325863152742386,0.1926421970129013,0.09346900880336761,0.2527164816856384,0.1926421970129013,0.08050476759672165,0.41217148303985596'" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check that endpoint works by getting some predictions of the test data\n", "XGBoost_predictor.predict(raw_test.to_numpy()[:20, :])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, create a model in SageMaker (optional). This can be helpful if you want to see the model in the AWS console. Another option at this point is to compile the model (optimize for performance). " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "model = XGBoost_estimator.create_model()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Amazon SageMaker Clarify\n", "(Go to top)\n", "\n", "Now that you have your model set up, let's say hello to SageMaker Clarify!" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.image_uris:Defaulting to the only supported framework/algorithm version: 1.0.\n", "INFO:sagemaker.image_uris:Ignoring unnecessary instance type: None.\n" ] } ], "source": [ "clarify_processor = clarify.SageMakerClarifyProcessor(\n", " role=get_execution_role(),\n", " instance_count=1,\n", " instance_type=\"ml.c4.xlarge\",\n", " sagemaker_session=Session(),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A ModelConfig object communicates information about your trained model. To avoid additional traffic to your production models, SageMaker Clarify sets up and tears down a dedicated endpoint when processing. \n", "The parameters `instance_type` and `instance_count` specify your preferred instance type and instance count used to run your model on during SageMaker Clarify’s processing." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "model_config = clarify.ModelConfig(\n", " model_name=modelname,\n", " instance_type=\"ml.m5.xlarge\",\n", " instance_count=1,\n", " accept_type=\"text/csv\",\n", " content_type=\"text/csv\",\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A `ModelPredictedLabelConfig` provides information on the format of your predictions. XGBoost classifier produces output probabilities of samples, so SageMaker Clarify invokes the endpoint then uses `probability_threshold` to convert the probability to binary labels for bias analysis. Prediction above the threshold is interpreted as label value 1 and below or equal as label value 0." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "predictions_config = clarify.ModelPredictedLabelConfig(probability_threshold=0.6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.1. Bias Reporting\n", "(Go to top)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A `DataConfig` object communicates some basic information about data to SageMaker Clarify. We specify where to find the input dataset, where to store the output, the target column (label), the header names, and the dataset type." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "bias_report_output_path = \"s3://{}/{}/clarify-bias\".format(bucket, prfx)\n", "\n", "bias_data_config = clarify.DataConfig(\n", " s3_data_input_path=train_uri,\n", " s3_output_path=bias_report_output_path,\n", " label=model_target,\n", " headers=[model_target] + sensitive_feature + numerical_features + cat_ft_names,\n", " dataset_type=\"text/csv\",\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "SageMaker Clarify also needs information on what the sensitive columns (`facets`) are, what the sensitive features (`facet_values_or_threshold`) may be, and what the desirable outcomes are `label_values_or_threshold`. Here `facet_name = RAC1P` and we want to look for bias against group 6. The desired outcome is with earnings $\\geq$ 50k. If you wanted to include another facet to analyze, provide a list; e.g., `facet_name = [\"RAC1P\", \"AGEP\"]`. Have a look at the documentation [here](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "# Set up bias config\n", "bias_config = clarify.BiasConfig(\n", " label_values_or_threshold=[1],\n", " facet_name=\"RAC1P\",\n", " facet_values_or_threshold=[6],\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We are ready to run the bias report. This type of report expects a trained model. There is also the option to evaluate for pre-training bias using:\n", "```\n", "clarify_processor.run_pre_training_bias(\n", " data_config=bias_data_config,\n", " data_bias_config=bias_config,\n", " methods=[\"CI\", \"DPL\"],\n", ")\n", "```\n", "The pre-training bias can be evaluated as soon as the data is uploaded to S3." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.clarify:Analysis Config: {'dataset_type': 'text/csv', 'headers': ['>50k', 'RAC1P', 'AGEP', 'WKHP', 'PWGTP', 'COW_1.0', 'COW_2.0', 'COW_3.0', 'COW_4.0', 'COW_5.0', 'COW_6.0', 'COW_7.0', 'COW_8.0', 'SCHL_1.0', 'SCHL_2.0', 'SCHL_3.0', 'SCHL_4.0', 'SCHL_5.0', 'SCHL_6.0', 'SCHL_7.0', 'SCHL_8.0', 'SCHL_9.0', 'SCHL_10.0', 'SCHL_11.0', 'SCHL_12.0', 'SCHL_13.0', 'SCHL_14.0', 'SCHL_15.0', 'SCHL_16.0', 'SCHL_17.0', 'SCHL_18.0', 'SCHL_19.0', 'SCHL_20.0', 'SCHL_21.0', 'SCHL_22.0', 'SCHL_23.0', 'SCHL_24.0', 'MAR_1.0', 'MAR_2.0', 'MAR_3.0', 'MAR_4.0', 'MAR_5.0', 'RELP_0.0', 'RELP_1.0', 'RELP_2.0', 'RELP_3.0', 'RELP_4.0', 'RELP_5.0', 'RELP_6.0', 'RELP_7.0', 'RELP_8.0', 'RELP_9.0', 'RELP_10.0', 'RELP_11.0', 'RELP_12.0', 'RELP_13.0', 'RELP_14.0', 'RELP_15.0', 'RELP_16.0', 'RELP_17.0', 'SEX_2.0', 'SCH_1.0', 'SCH_2.0', 'SCH_3.0'], 'label': '>50k', 'label_values_or_threshold': [1], 'facet': [{'name_or_index': 'RAC1P', 'value_or_threshold': [6]}], 'methods': {'report': {'name': 'report', 'title': 'Analysis Report'}, 'pre_training_bias': {'methods': 'all'}, 'post_training_bias': {'methods': 'all'}}, 'predictor': {'model_name': 'clarify-model-xgb', 'instance_type': 'ml.m5.xlarge', 'initial_instance_count': 1, 'accept_type': 'text/csv', 'content_type': 'text/csv'}, 'probability_threshold': 0.6}\n", "INFO:sagemaker:Creating processing-job with name Clarify-Bias-2023-04-26-05-41-25-016\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ ".......................................\u001b[34m2023-04-26 05:47:56,947 logging.conf not found when configuring logging, using default logging configuration.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,947 Starting SageMaker Clarify Processing job\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,948 Analysis config path: /opt/ml/processing/input/config/analysis_config.json\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,948 Analysis result path: /opt/ml/processing/output\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,949 This host is algo-1.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,949 This host is the leader.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:56,949 Number of hosts in the cluster is 1.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,300 Running Python / Pandas based analyzer.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,300 Dataset type: text/csv uri: /opt/ml/processing/input/data\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,312 Loading dataset...\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/analyzer/data_loading/csv_data_loader.py:330: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " df = df.append(df_tmp, ignore_index=True)\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,371 Loaded dataset. Dataset info:\u001b[0m\n", "\u001b[34m\u001b[0m\n", "\u001b[34mRangeIndex: 8492 entries, 0 to 8491\u001b[0m\n", "\u001b[34mData columns (total 63 columns):\n", " # Column Non-Null Count Dtype \u001b[0m\n", "\u001b[34m--- ------ -------------- ----- \n", " 0 RAC1P 8492 non-null float64\n", " 1 AGEP 8492 non-null float64\n", " 2 WKHP 8492 non-null float64\n", " 3 PWGTP 8492 non-null float64\n", " 4 COW_1.0 8492 non-null float64\n", " 5 COW_2.0 8492 non-null float64\n", " 6 COW_3.0 8492 non-null float64\n", " 7 COW_4.0 8492 non-null float64\n", " 8 COW_5.0 8492 non-null float64\n", " 9 COW_6.0 8492 non-null float64\n", " 10 COW_7.0 8492 non-null float64\n", " 11 COW_8.0 8492 non-null float64\n", " 12 SCHL_1.0 8492 non-null float64\n", " 13 SCHL_2.0 8492 non-null float64\n", " 14 SCHL_3.0 8492 non-null float64\n", " 15 SCHL_4.0 8492 non-null float64\n", " 16 SCHL_5.0 8492 non-null float64\n", " 17 SCHL_6.0 8492 non-null float64\n", " 18 SCHL_7.0 8492 non-null float64\n", " 19 SCHL_8.0 8492 non-null float64\n", " 20 SCHL_9.0 8492 non-null float64\n", " 21 SCHL_10.0 8492 non-null float64\n", " 22 SCHL_11.0 8492 non-null float64\n", " 23 SCHL_12.0 8492 non-null float64\n", " 24 SCHL_13.0 8492 non-null float64\n", " 25 SCHL_14.0 8492 non-null float64\n", " 26 SCHL_15.0 8492 non-null float64\n", " 27 SCHL_16.0 8492 non-null float64\n", " 28 SCHL_17.0 8492 non-null float64\n", " 29 SCHL_18.0 8492 non-null float64\n", " 30 SCHL_19.0 8492 non-null float64\n", " 31 SCHL_20.0 8492 non-null float64\n", " 32 SCHL_21.0 8492 non-null float64\n", " 33 SCHL_22.0 8492 non-null float64\n", " 34 SCHL_23.0 8492 non-null float64\n", " 35 SCHL_24.0 8492 non-null float64\n", " 36 MAR_1.0 8492 non-null float64\n", " 37 MAR_2.0 8492 non-null float64\n", " 38 MAR_3.0 8492 non-null float64\n", " 39 MAR_4.0 8492 non-null float64\n", " 40 MAR_5.0 8492 non-null float64\n", " 41 RELP_0.0 8492 non-null float64\n", " 42 RELP_1.0 8492 non-null float64\n", " 43 RELP_2.0 8492 non-null float64\n", " 44 RELP_3.0 8492 non-null float64\n", " 45 RELP_4.0 8492 non-null float64\n", " 46 RELP_5.0 8492 non-null float64\n", " 47 RELP_6.0 8492 non-null float64\n", " 48 RELP_7.0 8492 non-null float64\n", " 49 RELP_8.0 8492 non-null float64\n", " 50 RELP_9.0 8492 non-null float64\n", " 51 RELP_10.0 8492 non-null float64\n", " 52 RELP_11.0 8492 non-null float64\n", " 53 RELP_12.0 8492 non-null float64\n", " 54 RELP_13.0 8492 non-null float64\n", " 55 RELP_14.0 8492 non-null float64\n", " 56 RELP_15.0 8492 non-null float64\n", " 57 RELP_16.0 8492 non-null float64\n", " 58 RELP_17.0 8492 non-null float64\n", " 59 SEX_2.0 8492 non-null float64\n", " 60 SCH_1.0 8492 non-null float64\n", " 61 SCH_2.0 8492 non-null float64\n", " 62 SCH_3.0 8492 non-null float64\u001b[0m\n", "\u001b[34mdtypes: float64(63)\u001b[0m\n", "\u001b[34mmemory usage: 4.1 MB\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,456 Spinning up shadow endpoint\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,456 Creating endpoint-config with name sm-clarify-config-1682488077-3c99\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,748 Creating endpoint: 'sm-clarify-clarify-model-xgb-1682488077-118d'\u001b[0m\n", "\u001b[34m2023-04-26 05:47:57,803 No endpoints ruleset found for service sagemaker-internal, falling back to legacy endpoint routing.\u001b[0m\n", "\u001b[34m2023-04-26 05:47:58,261 Using endpoint name: sm-clarify-clarify-model-xgb-1682488077-118d\u001b[0m\n", "\u001b[34m2023-04-26 05:47:58,261 Waiting for endpoint ...\u001b[0m\n", "\u001b[34m2023-04-26 05:47:58,261 Checking endpoint status:\u001b[0m\n", "\u001b[34mLegend:\u001b[0m\n", "\u001b[34m(OutOfService: x, Creating: -, Updating: -, InService: !, RollingBack: <, Deleting: o, Failed: *)\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,834 Endpoint is in service after 181 seconds\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,835 Endpoint ready.\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,835 ======================================\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,835 Calculating post-training bias metrics\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,835 ======================================\u001b[0m\n", "\u001b[34m2023-04-26 05:50:58,835 Getting predictions from the endpoint\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,920 We assume a prediction above 0.600 indicates 1 and below or equal indicates 0.\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,921 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,923 Column RAC1P with data uniqueness fraction 0.00023551577955723034 is classifed as a CONTINUOUS column\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/smclarify/bias/report.py:591: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only.\n", " df = df.drop(facet_column.name, 1)\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,925 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,927 Column None with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:50:59,928 Threshold Interval indices: IntervalIndex([(6.0, 8.0]], dtype='interval[float64, right]')\u001b[0m\n", "\u001b[34m2023-04-26 05:51:00,027 CDDPL metrics failed\u001b[0m\n", "\u001b[34mTraceback (most recent call last):\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/report.py\", line 357, in _continuous_metric_call_wrapper\n", " metric_value = smclarify.bias.metrics.call_metric(\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/__init__.py\", line 27, in call_metric\n", " return metric(**{key: kwargs[key] for key in inspect.signature(metric).parameters.keys()})\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/posttraining.py\", line 277, in CDDPL\n", " return common.CDD(feature, sensitive_facet_index, positive_predicted_label_index, group_variable)\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/common.py\", line 100, in CDD\n", " raise ValueError(\"Group variable is empty or not provided\")\u001b[0m\n", "\u001b[34mValueError: Group variable is empty or not provided\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,007 Calculated global analysis with predictor\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,007 Stop using endpoint: sm-clarify-clarify-model-xgb-1682488077-118d\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,008 Deleting endpoint configuration with name: sm-clarify-config-1682488077-3c99\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,167 Deleting endpoint with name: sm-clarify-clarify-model-xgb-1682488077-118d\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,342 Model endpoint delivered 0.92049 requests per second and a total of 2 requests over 2 seconds\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,343 =====================================\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,343 Calculating pre-training bias metrics\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,343 =====================================\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,343 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,346 Column RAC1P with data uniqueness fraction 0.00023551577955723034 is classifed as a CONTINUOUS column\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/smclarify/bias/report.py:591: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only.\n", " df = df.drop(facet_column.name, 1)\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,349 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,351 Threshold Interval indices: IntervalIndex([(6.0, 8.0]], dtype='interval[float64, right]')\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,399 CDDL metrics failed\u001b[0m\n", "\u001b[34mTraceback (most recent call last):\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/report.py\", line 357, in _continuous_metric_call_wrapper\n", " metric_value = smclarify.bias.metrics.call_metric(\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/__init__.py\", line 27, in call_metric\n", " return metric(**{key: kwargs[key] for key in inspect.signature(metric).parameters.keys()})\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/pretraining.py\", line 195, in CDDL\n", " return common.CDD(feature, sensitive_facet_index, positive_label_index, group_variable)\n", " File \"/usr/local/lib/python3.9/site-packages/smclarify/bias/metrics/common.py\", line 100, in CDD\n", " raise ValueError(\"Group variable is empty or not provided\")\u001b[0m\n", "\u001b[34mValueError: Group variable is empty or not provided\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,775 ======================================\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,776 Calculating bias statistics for report\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,776 ======================================\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,776 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,778 Column RAC1P with data uniqueness fraction 0.00023551577955723034 is classifed as a CONTINUOUS column\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/smclarify/bias/report.py:591: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only.\n", " df = df.drop(facet_column.name, 1)\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,780 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,781 Column None with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,783 Threshold Interval indices: IntervalIndex([(6.0, 8.0]], dtype='interval[float64, right]')\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,931 Column >50k with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,933 Column None with data uniqueness fraction 0.00023551577955723034 is classifed as a CATEGORICAL column\u001b[0m\n", "\u001b[34m2023-04-26 05:51:01,942 Converting Pandas DataFrame to SparkDataFrame for computing report metadata\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[34m--!05:51:04.519 [main] WARN o.a.hadoop.util.NativeCodeLoader - Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\u001b[0m\n", "\u001b[34m05:51:11.335 [Thread-4] WARN o.a.spark.sql.catalyst.util.package - Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\u001b[0m\n", "\u001b[34m05:51:12.722 [dispatcher-event-loop-2] WARN o.a.spark.scheduler.TaskSetManager - Stage 0 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:14.644 [dispatcher-event-loop-2] WARN o.a.spark.scheduler.TaskSetManager - Stage 3 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:15.538 [dispatcher-event-loop-1] WARN o.a.spark.scheduler.TaskSetManager - Stage 9 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:15.814 [dispatcher-event-loop-2] WARN o.a.spark.scheduler.TaskSetManager - Stage 12 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:16.218 [dispatcher-event-loop-1] WARN o.a.spark.scheduler.TaskSetManager - Stage 13 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:16.554 [dispatcher-event-loop-3] WARN o.a.spark.scheduler.TaskSetManager - Stage 19 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:16.787 [dispatcher-event-loop-3] WARN o.a.spark.scheduler.TaskSetManager - Stage 22 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:17.090 [dispatcher-event-loop-0] WARN o.a.spark.scheduler.TaskSetManager - Stage 23 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:17.614 [dispatcher-event-loop-0] WARN o.a.spark.scheduler.TaskSetManager - Stage 29 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m05:51:17.838 [dispatcher-event-loop-1] WARN o.a.spark.scheduler.TaskSetManager - Stage 32 contains a task of very large size (1152 KiB). The maximum recommended task size is 1000 KiB.\u001b[0m\n", "\u001b[34m#015[Stage 0:> (0 + 4) / 4]#015#015[Stage 0:==============> (1 + 3) / 4]#015#015 #0152023-04-26 05:51:17,993 Calculated global analysis without predictor\u001b[0m\n", "\u001b[34m2023-04-26 05:51:17,993 Stop using endpoint: None\u001b[0m\n", "\u001b[34m2023-04-26 05:51:18,948 ['jupyter', 'nbconvert', '--to', 'html', '--output', '/opt/ml/processing/output/report.html', '/opt/ml/processing/output/report.ipynb', '--template', 'sagemaker-xai']\u001b[0m\n", "\u001b[34m[NbConvertApp] Converting notebook /opt/ml/processing/output/report.ipynb to html\u001b[0m\n", "\u001b[34m[NbConvertApp] Writing 750340 bytes to /opt/ml/processing/output/report.html\u001b[0m\n", "\u001b[34m2023-04-26 05:51:20,022 ['wkhtmltopdf', '-q', '--enable-local-file-access', '/opt/ml/processing/output/report.html', '/opt/ml/processing/output/report.pdf']\u001b[0m\n", "\u001b[34m2023-04-26 05:51:21,397 Collected analyses: \u001b[0m\n", "\u001b[34m{\n", " \"version\": \"1.0\",\n", " \"post_training_bias_metrics\": {\n", " \"label\": \">50k\",\n", " \"facets\": {\n", " \"RAC1P\": [\n", " {\n", " \"value_or_threshold\": \"(6.0, 8.0]\",\n", " \"metrics\": [\n", " {\n", " \"name\": \"AD\",\n", " \"description\": \"Accuracy Difference (AD)\",\n", " \"value\": -0.060298268619563\n", " },\n", " {\n", " \"name\": \"CDDPL\",\n", " \"description\": \"Conditional Demographic Disparity in Predicted Labels (CDDPL)\",\n", " \"value\": null,\n", " \"error\": \"Group variable is empty or not provided\"\n", " },\n", " {\n", " \"name\": \"DAR\",\n", " \"description\": \"Difference in Acceptance Rates (DAR)\",\n", " \"value\": 0.03853525992080209\n", " },\n", " {\n", " \"name\": \"DCA\",\n", " \"description\": \"Difference in Conditional Acceptance (DCA)\",\n", " \"value\": -3.465972280731317\n", " },\n", " {\n", " \"name\": \"DCR\",\n", " \"description\": \"Difference in Conditional Rejection (DCR)\",\n", " \"value\": -0.019338711280181053\n", " },\n", " {\n", " \"name\": \"DI\",\n", " \"description\": \"Disparate Impact (DI)\",\n", " \"value\": 0.10435167424972934\n", " },\n", " {\n", " \"name\": \"DPPL\",\n", " \"description\": \"Difference in Positive Proportions in Predicted Labels (DPPL)\",\n", " \"value\": 0.3546276018474536\n", " },\n", " {\n", " \"name\": \"DRR\",\n", " \"description\": \"Difference in Rejection Rates (DRR)\",\n", " \"value\": 0.09243844488199526\n", " },\n", " {\n", " \"name\": \"FT\",\n", " \"description\": \"Flip Test (FT)\",\n", " \"value\": -0.09188095926032938\n", " },\n", " {\n", " \"name\": \"GE\",\n", " \"description\": \"Generalized Entropy (GE)\",\n", " \"value\": 0.1227562795261298\n", " },\n", " {\n", " \"name\": \"RD\",\n", " \"description\": \"Recall Difference (RD)\",\n", " \"value\": 0.506130406929783\n", " },\n", " {\n", " \"name\": \"SD\",\n", " \"description\": \"Specificity Difference (SD)\",\n", " \"value\": 0.12959372781998368\n", " },\n", " {\n", " \"name\": \"TE\",\n", " \"description\": \"Treatment Equality (TE)\",\n", " \"value\": 15.291158536585366\n", " }\n", " ]\n", " }\n", " ]\n", " },\n", " \"label_value_or_threshold\": \"1\"\n", " },\n", " \"pre_training_bias_metrics\": {\n", " \"label\": \">50k\",\n", " \"facets\": {\n", " \"RAC1P\": [\n", " {\n", " \"value_or_threshold\": \"(6.0, 8.0]\",\n", " \"metrics\": [\n", " {\n", " \"name\": \"CDDL\",\n", " \"description\": \"Conditional Demographic Disparity in Labels (CDDL)\",\n", " \"value\": null,\n", " \"error\": \"Group variable is empty or not provided\"\n", " },\n", " {\n", " \"name\": \"CI\",\n", " \"description\": \"Class Imbalance (CI)\",\n", " \"value\": 0.18487988695242583\n", " },\n", " {\n", " \"name\": \"DPL\",\n", " \"description\": \"Difference in Positive Proportions in Labels (DPL)\",\n", " \"value\": 0.2867271170692013\n", " },\n", " {\n", " \"name\": \"JS\",\n", " \"description\": \"Jensen-Shannon Divergence (JS)\",\n", " \"value\": 0.047136886083804404\n", " },\n", " {\n", " \"name\": \"KL\",\n", " \"description\": \"Kullback-Liebler Divergence (KL)\",\n", " \"value\": 0.2082746966374284\n", " },\n", " {\n", " \"name\": \"KS\",\n", " \"description\": \"Kolmogorov-Smirnov Distance (KS)\",\n", " \"value\": 0.2867271170692013\n", " },\n", " {\n", " \"name\": \"LP\",\n", " \"description\": \"L-p Norm (LP)\",\n", " \"value\": 0.40549337765940263\n", " },\n", " {\n", " \"name\": \"TVD\",\n", " \"description\": \"Total Variation Distance (TVD)\",\n", " \"value\": 0.2867271170692013\n", " }\n", " ]\n", " }\n", " ]\n", " },\n", " \"label_value_or_threshold\": \"1\"\n", " }\u001b[0m\n", "\u001b[34m}\u001b[0m\n", "\u001b[34m2023-04-26 05:51:21,398 exit_message: Completed: SageMaker XAI Analyzer ran successfully\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "clarify_processor.run_bias(\n", " data_config=bias_data_config,\n", " bias_config=bias_config,\n", " model_config=model_config,\n", " model_predicted_label_config=predictions_config,\n", " pre_training_methods=\"all\",\n", " post_training_methods=\"all\",\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.2. Explainability Reporting\n", "(Go to top)\n", "\n", "Let's move on to explainability concepts. We start with a test value and baseline." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "baseline = (\n", " pd.concat(\n", " [\n", " test_data[sensitive_feature].astype(object).reset_index(drop=True),\n", " raw_test,\n", " ],\n", " axis=1,\n", " )\n", " .iloc[0]\n", " .values.tolist()\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similar to the bias report, we first need to provide some specifications." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Set up path for where explainability output should be stored\n", "explainability_report_output_path = \"s3://{}/{}/clarify-explainability\".format(\n", " bucket, prfx\n", ")\n", "\n", "# Initialize configuration for SHAP\n", "shap_config = clarify.SHAPConfig(\n", " baseline=[baseline],\n", " num_samples=15,\n", " agg_method=\"mean_abs\",\n", " save_local_shap_values=True,\n", ")\n", "\n", "# Provide details about the data used for the explainability example\n", "explainability_data_config = clarify.DataConfig(\n", " s3_data_input_path=train_uri,\n", " s3_output_path=explainability_report_output_path,\n", " label=model_target,\n", " headers=[model_target] + sensitive_feature + numerical_features + cat_ft_names,\n", " dataset_type=\"text/csv\",\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can run the explainability report." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.clarify:Analysis Config: {'dataset_type': 'text/csv', 'headers': ['>50k', 'RAC1P', 'AGEP', 'WKHP', 'PWGTP', 'COW_1.0', 'COW_2.0', 'COW_3.0', 'COW_4.0', 'COW_5.0', 'COW_6.0', 'COW_7.0', 'COW_8.0', 'SCHL_1.0', 'SCHL_2.0', 'SCHL_3.0', 'SCHL_4.0', 'SCHL_5.0', 'SCHL_6.0', 'SCHL_7.0', 'SCHL_8.0', 'SCHL_9.0', 'SCHL_10.0', 'SCHL_11.0', 'SCHL_12.0', 'SCHL_13.0', 'SCHL_14.0', 'SCHL_15.0', 'SCHL_16.0', 'SCHL_17.0', 'SCHL_18.0', 'SCHL_19.0', 'SCHL_20.0', 'SCHL_21.0', 'SCHL_22.0', 'SCHL_23.0', 'SCHL_24.0', 'MAR_1.0', 'MAR_2.0', 'MAR_3.0', 'MAR_4.0', 'MAR_5.0', 'RELP_0.0', 'RELP_1.0', 'RELP_2.0', 'RELP_3.0', 'RELP_4.0', 'RELP_5.0', 'RELP_6.0', 'RELP_7.0', 'RELP_8.0', 'RELP_9.0', 'RELP_10.0', 'RELP_11.0', 'RELP_12.0', 'RELP_13.0', 'RELP_14.0', 'RELP_15.0', 'RELP_16.0', 'RELP_17.0', 'SEX_2.0', 'SCH_1.0', 'SCH_2.0', 'SCH_3.0'], 'label': '>50k', 'predictor': {'model_name': 'clarify-model-xgb', 'instance_type': 'ml.m5.xlarge', 'initial_instance_count': 1, 'accept_type': 'text/csv', 'content_type': 'text/csv'}, 'methods': {'report': {'name': 'report', 'title': 'Analysis Report'}, 'shap': {'use_logit': False, 'save_local_shap_values': True, 'baseline': [[6.0, 0.3766233766233767, 0.39795918367346933, 0.07665260196905767, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0]], 'num_samples': 15, 'agg_method': 'mean_abs'}}}\n", "INFO:sagemaker:Creating processing-job with name Clarify-Explainability-2023-04-26-05-52-02-339\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "........................................\u001b[34m2023-04-26 05:58:41,018 logging.conf not found when configuring logging, using default logging configuration.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,019 Starting SageMaker Clarify Processing job\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,024 Analysis config path: /opt/ml/processing/input/config/analysis_config.json\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,024 Analysis result path: /opt/ml/processing/output\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,025 This host is algo-1.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,026 This host is the leader.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,026 Number of hosts in the cluster is 1.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,294 Running Python / Pandas based analyzer.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,294 Dataset type: text/csv uri: /opt/ml/processing/input/data\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,306 Loading dataset...\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/analyzer/data_loading/csv_data_loader.py:330: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", " df = df.append(df_tmp, ignore_index=True)\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,364 Loaded dataset. Dataset info:\u001b[0m\n", "\u001b[34m\u001b[0m\n", "\u001b[34mRangeIndex: 8492 entries, 0 to 8491\u001b[0m\n", "\u001b[34mData columns (total 63 columns):\n", " # Column Non-Null Count Dtype \u001b[0m\n", "\u001b[34m--- ------ -------------- ----- \n", " 0 RAC1P 8492 non-null float64\n", " 1 AGEP 8492 non-null float64\n", " 2 WKHP 8492 non-null float64\n", " 3 PWGTP 8492 non-null float64\n", " 4 COW_1.0 8492 non-null float64\n", " 5 COW_2.0 8492 non-null float64\n", " 6 COW_3.0 8492 non-null float64\n", " 7 COW_4.0 8492 non-null float64\n", " 8 COW_5.0 8492 non-null float64\n", " 9 COW_6.0 8492 non-null float64\n", " 10 COW_7.0 8492 non-null float64\n", " 11 COW_8.0 8492 non-null float64\n", " 12 SCHL_1.0 8492 non-null float64\n", " 13 SCHL_2.0 8492 non-null float64\n", " 14 SCHL_3.0 8492 non-null float64\n", " 15 SCHL_4.0 8492 non-null float64\n", " 16 SCHL_5.0 8492 non-null float64\n", " 17 SCHL_6.0 8492 non-null float64\n", " 18 SCHL_7.0 8492 non-null float64\n", " 19 SCHL_8.0 8492 non-null float64\n", " 20 SCHL_9.0 8492 non-null float64\n", " 21 SCHL_10.0 8492 non-null float64\n", " 22 SCHL_11.0 8492 non-null float64\n", " 23 SCHL_12.0 8492 non-null float64\n", " 24 SCHL_13.0 8492 non-null float64\n", " 25 SCHL_14.0 8492 non-null float64\n", " 26 SCHL_15.0 8492 non-null float64\n", " 27 SCHL_16.0 8492 non-null float64\n", " 28 SCHL_17.0 8492 non-null float64\n", " 29 SCHL_18.0 8492 non-null float64\n", " 30 SCHL_19.0 8492 non-null float64\n", " 31 SCHL_20.0 8492 non-null float64\n", " 32 SCHL_21.0 8492 non-null float64\n", " 33 SCHL_22.0 8492 non-null float64\n", " 34 SCHL_23.0 8492 non-null float64\n", " 35 SCHL_24.0 8492 non-null float64\n", " 36 MAR_1.0 8492 non-null float64\n", " 37 MAR_2.0 8492 non-null float64\n", " 38 MAR_3.0 8492 non-null float64\n", " 39 MAR_4.0 8492 non-null float64\n", " 40 MAR_5.0 8492 non-null float64\n", " 41 RELP_0.0 8492 non-null float64\n", " 42 RELP_1.0 8492 non-null float64\n", " 43 RELP_2.0 8492 non-null float64\n", " 44 RELP_3.0 8492 non-null float64\n", " 45 RELP_4.0 8492 non-null float64\n", " 46 RELP_5.0 8492 non-null float64\n", " 47 RELP_6.0 8492 non-null float64\n", " 48 RELP_7.0 8492 non-null float64\n", " 49 RELP_8.0 8492 non-null float64\n", " 50 RELP_9.0 8492 non-null float64\n", " 51 RELP_10.0 8492 non-null float64\n", " 52 RELP_11.0 8492 non-null float64\n", " 53 RELP_12.0 8492 non-null float64\n", " 54 RELP_13.0 8492 non-null float64\n", " 55 RELP_14.0 8492 non-null float64\n", " 56 RELP_15.0 8492 non-null float64\n", " 57 RELP_16.0 8492 non-null float64\n", " 58 RELP_17.0 8492 non-null float64\n", " 59 SEX_2.0 8492 non-null float64\n", " 60 SCH_1.0 8492 non-null float64\n", " 61 SCH_2.0 8492 non-null float64\n", " 62 SCH_3.0 8492 non-null float64\u001b[0m\n", "\u001b[34mdtypes: float64(63)\u001b[0m\n", "\u001b[34mmemory usage: 4.1 MB\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,454 Spinning up shadow endpoint\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,454 Creating endpoint-config with name sm-clarify-config-1682488721-ed87\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,767 Creating endpoint: 'sm-clarify-clarify-model-xgb-1682488721-365f'\u001b[0m\n", "\u001b[34m2023-04-26 05:58:41,823 No endpoints ruleset found for service sagemaker-internal, falling back to legacy endpoint routing.\u001b[0m\n", "\u001b[34m2023-04-26 05:58:42,284 Using endpoint name: sm-clarify-clarify-model-xgb-1682488721-365f\u001b[0m\n", "\u001b[34m2023-04-26 05:58:42,284 Waiting for endpoint ...\u001b[0m\n", "\u001b[34m2023-04-26 05:58:42,284 Checking endpoint status:\u001b[0m\n", "\u001b[34mLegend:\u001b[0m\n", "\u001b[34m(OutOfService: x, Creating: -, Updating: -, InService: !, RollingBack: <, Deleting: o, Failed: *)\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,834 Endpoint is in service after 181 seconds\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,835 Endpoint ready.\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,840 The number of requested samples 15 is too small given the number of features 63\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,840 SHAP n_samples 15\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,940 =====================================================\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,941 Shap analyzer: explaining 8492 rows, 63 columns...\u001b[0m\n", "\u001b[34m2023-04-26 06:01:42,941 =====================================================\n", " 0% (0 of 8492) | | Elapsed Time: 0:00:00 ETA: --:--:--\u001b[0m\n", "\u001b[34m 36% (3101 of 8492) |####### | Elapsed Time: 0:00:30 ETA: 0:00:52\u001b[0m\n", "\u001b[34m 74% (6314 of 8492) |############## | Elapsed Time: 0:01:00 ETA: 0:00:20\u001b[0m\n", "\u001b[34m100% (8492 of 8492) |####################| Elapsed Time: 0:01:19 Time: 0:01:19\u001b[0m\n", "\u001b[34m2023-04-26 06:03:02,292 getting explanations took 79.35 seconds.\u001b[0m\n", "\u001b[34m2023-04-26 06:03:02,292 ===================================================\u001b[0m\n", "\u001b[34m2023-04-26 06:03:02,293 Falling back to generic labels: label0, label1, ...\u001b[0m\n", "\u001b[34m2023-04-26 06:03:03,569 converting explanations to tabular took 1.28 seconds.\u001b[0m\n", "\u001b[34m2023-04-26 06:03:03,569 ===================================================\u001b[0m\n", "\u001b[34m2023-04-26 06:03:03,573 Wrote baseline used to compute explanations to: /opt/ml/processing/output/explanations_shap/baseline.csv\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,291 Wrote 8492 local explanations to: /opt/ml/processing/output/explanations_shap/out.csv\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,291 writing local explanations took 0.72 seconds.\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,291 ===================================================\u001b[0m\n", "\u001b[34m/usr/local/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3430: FutureWarning: In a future version, DataFrame.mean(axis=None) will return a scalar mean over the entire DataFrame. To retain the old behavior, use 'frame.mean(axis=0)' or just 'frame.mean()'\n", " return mean(axis=axis, dtype=dtype, out=out, **kwargs)\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,296 aggregating local explanations took 0.00 seconds.\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,296 ===================================================\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,296 Shap analysis finished.\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,296 Calculated global analysis with predictor\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,298 Stop using endpoint: sm-clarify-clarify-model-xgb-1682488721-365f\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,298 Deleting endpoint configuration with name: sm-clarify-config-1682488721-ed87\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,483 Deleting endpoint with name: sm-clarify-clarify-model-xgb-1682488721-365f\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,619 Model endpoint delivered 104.26802 requests per second and a total of 8494 requests over 81 seconds\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,619 Calculated global analysis without predictor\u001b[0m\n", "\u001b[34m2023-04-26 06:03:04,858 Stop using endpoint: None\u001b[0m\n", "\u001b[34m2023-04-26 06:03:21,818 ['jupyter', 'nbconvert', '--to', 'html', '--output', '/opt/ml/processing/output/report.html', '/opt/ml/processing/output/report.ipynb', '--template', 'sagemaker-xai']\u001b[0m\n", "\u001b[34m[NbConvertApp] Converting notebook /opt/ml/processing/output/report.ipynb to html\u001b[0m\n", "\u001b[34m[NbConvertApp] Writing 494434 bytes to /opt/ml/processing/output/report.html\u001b[0m\n", "\u001b[34m2023-04-26 06:03:22,895 ['wkhtmltopdf', '-q', '--enable-local-file-access', '/opt/ml/processing/output/report.html', '/opt/ml/processing/output/report.pdf']\u001b[0m\n", "\u001b[34m2023-04-26 06:03:23,876 Collected analyses: \u001b[0m\n", "\u001b[34m{\n", " \"version\": \"1.0\",\n", " \"explanations\": {\n", " \"kernel_shap\": {\n", " \"label0\": {\n", " \"global_shap_values\": {\n", " \"RAC1P\": 0.010994280314049993,\n", " \"AGEP\": 0.011343420142187187,\n", " \"WKHP\": 0.019087475974209695,\n", " \"PWGTP\": 0.008927441671942444,\n", " \"COW_1.0\": 0.008444419414047668,\n", " \"COW_2.0\": 0.008376523074323839,\n", " \"COW_3.0\": 0.008396849503578146,\n", " \"COW_4.0\": 0.008540521601942217,\n", " \"COW_5.0\": 0.00857102657913103,\n", " \"COW_6.0\": 0.00951128484658168,\n", " \"COW_7.0\": 0.00854089973103888,\n", " \"COW_8.0\": 0.008346755968380127,\n", " \"SCHL_1.0\": 0.00879904379519125,\n", " \"SCHL_2.0\": 0.008494733836321057,\n", " \"SCHL_3.0\": 0.00844835745360474,\n", " \"SCHL_4.0\": 0.008417146158685067,\n", " \"SCHL_5.0\": 0.008448953273449305,\n", " \"SCHL_6.0\": 0.008453068220061696,\n", " \"SCHL_7.0\": 0.008160942280178095,\n", " \"SCHL_8.0\": 0.00863995538256826,\n", " \"SCHL_9.0\": 0.008580852489928993,\n", " \"SCHL_10.0\": 0.008496855400146278,\n", " \"SCHL_11.0\": 0.008697984291176335,\n", " \"SCHL_12.0\": 0.008533599178488446,\n", " \"SCHL_13.0\": 0.008486842509976384,\n", " \"SCHL_14.0\": 0.008411687836710854,\n", " \"SCHL_15.0\": 0.008528468174722343,\n", " \"SCHL_16.0\": 0.009559579139739337,\n", " \"SCHL_17.0\": 0.008531130991807252,\n", " \"SCHL_18.0\": 0.008519639440666535,\n", " \"SCHL_19.0\": 0.008447328794949452,\n", " \"SCHL_20.0\": 0.008366112915286722,\n", " \"SCHL_21.0\": 0.009453603015700147,\n", " \"SCHL_22.0\": 0.03275036939570261,\n", " \"SCHL_23.0\": 0.00856912950796835,\n", " \"SCHL_24.0\": 0.0085400461975767,\n", " \"MAR_1.0\": 0.008918630466031481,\n", " \"MAR_2.0\": 0.008537189382931677,\n", " \"MAR_3.0\": 0.008531051077413095,\n", " \"MAR_4.0\": 0.008633503201661882,\n", " \"MAR_5.0\": 0.00848991253024193,\n", " \"RELP_0.0\": 0.015203430947751962,\n", " \"RELP_1.0\": 0.008916140166072607,\n", " \"RELP_2.0\": 0.008964632867267322,\n", " \"RELP_3.0\": 0.008456441376363678,\n", " \"RELP_4.0\": 0.008420626087893995,\n", " \"RELP_5.0\": 0.008452286955398066,\n", " \"RELP_6.0\": 0.008476895746459845,\n", " \"RELP_7.0\": 0.00847441291148814,\n", " \"RELP_8.0\": 0.008655640523320596,\n", " \"RELP_9.0\": 0.00831696548109121,\n", " \"RELP_10.0\": 0.008496757951377954,\n", " \"RELP_11.0\": 0.008381340632098968,\n", " \"RELP_12.0\": 0.00849438730870199,\n", " \"RELP_13.0\": 0.008541061519077133,\n", " \"RELP_14.0\": 0.008474709347469715,\n", " \"RELP_15.0\": 0.008671917901277498,\n", " \"RELP_16.0\": 0.008493318879756559,\n", " \"RELP_17.0\": 0.008592975591119463,\n", " \"SEX_2.0\": 0.010532953246517304,\n", " \"SCH_1.0\": 0.00937221399479256,\n", " \"SCH_2.0\": 0.008609507268384031,\n", " \"SCH_3.0\": 0.14263266193518473\n", " },\n", " \"expected_value\": 0.8636011481285095\n", " }\n", " }\n", " }\u001b[0m\n", "\u001b[34m}\u001b[0m\n", "\u001b[34m2023-04-26 06:03:23,876 exit_message: Completed: SageMaker XAI Analyzer ran successfully\u001b[0m\n", "\u001b[34m--!\u001b[0m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "# Run the explainability job\n", "clarify_processor.run_explainability(\n", " data_config=explainability_data_config,\n", " model_config=model_config,\n", " explainability_config=shap_config,\n", ")" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:botocore.credentials:Found credentials from IAM Role: BaseNotebookInstanceEc2InstanceRole\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Example number: 111 \n", "with model prediction: False\n", "\n", "Feature values -- Label 0 0.207792\n", "1 0.397959\n", "2 0.120253\n", "3 1.000000\n", "4 0.000000\n", " ... \n", "57 0.000000\n", "58 0.000000\n", "59 1.000000\n", "60 0.000000\n", "61 0.000000\n", "Name: 111, Length: 62, dtype: float64\n" ] } ], "source": [ "# Specify path to save explanations\n", "local_explanations_out = pd.read_csv(\n", " explainability_report_output_path + \"/explanations_shap/out.csv\"\n", ")\n", "\n", "# Extract and update feature names\n", "feature_names = [\n", " str.replace(c, \"_label0\", \"\") for c in local_explanations_out.columns.to_series()\n", "]\n", "local_explanations_out.columns = feature_names\n", "\n", "# Show selected example\n", "selected_example = 111\n", "print(\n", " \"Example number:\",\n", " selected_example,\n", " \"\\nwith model prediction:\",\n", " sum(local_explanations_out.iloc[selected_example]) > 0,\n", ")\n", "print(\"\\nFeature values -- Label\", raw_train.iloc[selected_example])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Amazon Model Monitor\n", "(Go to top)\n", "\n", "A lot of the steps we took above, can immediately be used to set up monitoring too. With the existing model and data configuration we can set up a baseline job for example." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.image_uris:Defaulting to the only supported framework/algorithm version: 1.0.\n", "INFO:sagemaker.image_uris:Ignoring unnecessary instance type: None.\n" ] } ], "source": [ "model_bias_monitor = model_monitor.ModelBiasMonitor(\n", " role=get_execution_role(),\n", " sagemaker_session=Session(),\n", " max_runtime_in_seconds=1800,\n", " base_job_name=\"bias-model-monitoring\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The method `suggest_baseline` suggests a set of baseline constraints and generate descriptive statistics that characterize the data in a training dataset stored in Amazon S3. It starts a Processing Job using a Model Monitor container provided by Amazon SageMaker to generate the constraints." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.image_uris:Defaulting to the only supported framework/algorithm version: 1.0.\n", "INFO:sagemaker.image_uris:Ignoring unnecessary instance type: None.\n", "INFO:sagemaker.clarify:Analysis Config: {'dataset_type': 'text/csv', 'headers': ['>50k', 'RAC1P', 'AGEP', 'WKHP', 'PWGTP', 'COW_1.0', 'COW_2.0', 'COW_3.0', 'COW_4.0', 'COW_5.0', 'COW_6.0', 'COW_7.0', 'COW_8.0', 'SCHL_1.0', 'SCHL_2.0', 'SCHL_3.0', 'SCHL_4.0', 'SCHL_5.0', 'SCHL_6.0', 'SCHL_7.0', 'SCHL_8.0', 'SCHL_9.0', 'SCHL_10.0', 'SCHL_11.0', 'SCHL_12.0', 'SCHL_13.0', 'SCHL_14.0', 'SCHL_15.0', 'SCHL_16.0', 'SCHL_17.0', 'SCHL_18.0', 'SCHL_19.0', 'SCHL_20.0', 'SCHL_21.0', 'SCHL_22.0', 'SCHL_23.0', 'SCHL_24.0', 'MAR_1.0', 'MAR_2.0', 'MAR_3.0', 'MAR_4.0', 'MAR_5.0', 'RELP_0.0', 'RELP_1.0', 'RELP_2.0', 'RELP_3.0', 'RELP_4.0', 'RELP_5.0', 'RELP_6.0', 'RELP_7.0', 'RELP_8.0', 'RELP_9.0', 'RELP_10.0', 'RELP_11.0', 'RELP_12.0', 'RELP_13.0', 'RELP_14.0', 'RELP_15.0', 'RELP_16.0', 'RELP_17.0', 'SEX_2.0', 'SCH_1.0', 'SCH_2.0', 'SCH_3.0'], 'label': '>50k', 'label_values_or_threshold': [1], 'facet': [{'name_or_index': 'RAC1P', 'value_or_threshold': [6]}], 'methods': {'report': {'name': 'report', 'title': 'Analysis Report'}, 'pre_training_bias': {'methods': 'all'}, 'post_training_bias': {'methods': 'all'}}, 'predictor': {'model_name': 'clarify-model-xgb', 'instance_type': 'ml.m5.xlarge', 'initial_instance_count': 1, 'accept_type': 'text/csv', 'content_type': 'text/csv'}, 'probability_threshold': 0.6}\n", "INFO:sagemaker:Creating processing-job with name bias-model-monitoring-2023-04-26-06-04-17-328\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "ModelBiasMonitor baselining job: bias-model-monitoring-2023-04-26-06-04-17-328\n" ] } ], "source": [ "model_bias_monitor.suggest_baseline(\n", " model_config=model_config,\n", " data_config=bias_data_config,\n", " bias_config=bias_config,\n", " model_predicted_label_config=predictions_config,\n", ")\n", "\n", "print(\n", " f\"ModelBiasMonitor baselining job: {model_bias_monitor.latest_baselining_job_name}\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Besides captures, model bias monitoring execution also requires ground truth data. In real use cases, ground truth data should be regularly collected and uploaded to designated S3 location. In this example notebook, we assume that the train data is acting as ground truth." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "ground_truth_data = train_uri" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that you have a baseline and ground truth data, you can call the `create_monitoring_schedule()` method to schedule an hourly monitor to analyze the data with a monitoring schedule. " ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:sagemaker.model_monitor.clarify_model_monitoring:Uploading analysis config to {s3_uri}.\n", "INFO:sagemaker.model_monitor.model_monitoring:Creating Monitoring Schedule with name: bias-model-monitoring-2023-04-26-06-04-17-704\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Model bias monitoring schedule: bias-model-monitoring-2023-04-26-06-04-17-704\n" ] } ], "source": [ "# Set up path for where monitor output should be stored\n", "model_monitor_output_path = \"s3://{}/{}/clarify-monitor\".format(\n", " bucket, prfx\n", ")\n", "\n", "model_bias_analysis_config = None\n", "if not model_bias_monitor.latest_baselining_job:\n", " model_bias_analysis_config = model_monitor.BiasAnalysisConfig(\n", " bias_data_config,\n", " label=model_target,\n", " headers=[model_target] + sensitive_feature + numerical_features + cat_ft_names,\n", " )\n", "\n", "model_bias_monitor.create_monitoring_schedule(\n", " analysis_config=model_bias_analysis_config,\n", " output_s3_uri=model_monitor_output_path,\n", " ground_truth_input=ground_truth_data, \n", " endpoint_input=endpointname,\n", " schedule_cron_expression=model_monitor.CronExpressionGenerator.hourly(),\n", ")\n", "print(f\"Model bias monitoring schedule: {model_bias_monitor.monitoring_schedule_name}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Clean Up\n", "Finally, don't forget to clean up the resources we set up and used for this notebook!" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Stopping Monitoring Schedule with name: bias-model-monitoring-2023-04-26-06-04-17-704\n" ] } ], "source": [ "try:\n", " model_bias_monitor.stop_monitoring_schedule()\n", " model_bias_monitor.delete_monitoring_schedule()\n", " Session().delete_endpoint(endpointname)\n", " Session().delete_endpoint_config(endpointname)\n", " Session().delete_model(modelname)\n", "except:\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the end of the notebook." ] } ], "metadata": { "instance_type": "ml.t3.medium", "kernelspec": { "display_name": "conda_python3", "language": "python", "name": "conda_python3" }, "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.10.8" } }, "nbformat": 4, "nbformat_minor": 4 }