Takehome_TFCO_Oscillation_compas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Copyright 2018 The TensorFlow Constrained Optimization Authors. All Rights Reserved.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n",
    "\n",
    "> http://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "This notebook will show one of the challenges that arises in practice when training machine learning models to satisfy constraints such as fairness constraints: namely the difficulty that arises with non-convex models. Typical approaches to enforce such constraints are based on the classical method of the Lagrangian multipliers. It is well known that in the convex setting, under fairly general conditions, a saddle point to the Lagrangian will correspond to an optimal and feasible solution to the original constrained optimization problem. However, such no longer holds in the non-convex setting: a saddle point no longer necessarily corresponds to a desired solution to the constrained optimization problem. Even worse, there may not even be a stationary point to converge to in the non-convex setting thus causing gradient-based methods like SGD to possibly not converge and thus oscillate.\n",
    "\n",
    "\n",
    "We show that this problem appears with the [[ProPublica COMPAS dataset]](https://github.com/propublica/compas-analysis) when we train a simple neural network as the underlying model to predict 2-year recividism with equal opportunity constraints based on race and gender. This motivates why stochastic classifiers are necessary, as proposed in [[CoJiSr19]](https://arxiv.org/abs/1804.06500). In particular, there are four equal opportunity constraints: one for each of the 4 protected groups (White, Black, Female, Male). As a reminder, equal opportunity enforces that the true positive rate of our classifier on each protected group matches the true positive rate of our classifer on the overall dataset.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing required libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import warnings\n",
    "from six.moves import xrange\n",
    "import tensorflow.compat.v1 as tf\n",
    "import tensorflow_constrained_optimization as tfco\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "tf.disable_eager_execution()\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading and processing dataset.\n",
    "\n",
    "We load and download the dataset and do some pre-processing. We remove some of the datapoints for which some of the features are missing and then perform some feature transformation, including changing categorical features into binary features and bucketizing some of the continuous features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "LABEL_COLUMN = 'two_year_recid'\n",
    "PROTECTED_COLUMNS = ['sex_Female', 'sex_Male', 'race_Caucasian', 'race_African-American']\n",
    "\n",
    "def get_data():\n",
    "    data_path = 'https://raw.githubusercontent.com/propublica/compas-analysis/master/compas-scores-two-years.csv'\n",
    "    df = pd.read_csv(data_path)\n",
    "    FEATURES = [\n",
    "      'age', 'c_charge_degree', 'race', 'age_cat', 'score_text', 'sex',\n",
    "      'priors_count', 'days_b_screening_arrest', 'decile_score', 'is_recid',\n",
    "      'two_year_recid']\n",
    "    df = df[FEATURES]\n",
    "    df = df[df.days_b_screening_arrest <= 30]\n",
    "    df = df[df.days_b_screening_arrest >= -30]\n",
    "    df = df[df.is_recid != -1]\n",
    "    df = df[df.c_charge_degree != 'O']\n",
    "    df = df[df.score_text != 'N/A']\n",
    "    continuous_features = [\n",
    "      'priors_count', 'days_b_screening_arrest', 'is_recid', 'two_year_recid'\n",
    "    ]\n",
    "    continuous_to_categorical_features = ['age', 'decile_score', 'priors_count']\n",
    "    categorical_features = ['c_charge_degree', 'race', 'score_text', 'sex']\n",
    "\n",
    "    def binarize_categorical_columns(input_df, categorical_columns=[]):\n",
    "        binarized_df = pd.get_dummies(input_df, columns=categorical_columns)\n",
    "        return binarized_df\n",
    "    \n",
    "    def bucketize_continuous_column(input_df, continuous_column_name, bins=None):\n",
    "        input_df[continuous_column_name] = pd.cut(\n",
    "            input_df[continuous_column_name], bins, labels=False)\n",
    "\n",
    "    for c in continuous_to_categorical_features:\n",
    "        b = [0] + list(np.percentile(df[c], [20, 40, 60, 80, 90, 100]))\n",
    "        if c == 'priors_count':\n",
    "            b = list(np.percentile(df[c], [0, 50, 70, 80, 90, 100]))\n",
    "        bucketize_continuous_column(df, c, bins=b)\n",
    "\n",
    "    df = binarize_categorical_columns(\n",
    "        df,\n",
    "        categorical_columns=categorical_features + continuous_to_categorical_features)\n",
    "\n",
    "    to_fill = [\n",
    "      u'decile_score_0', u'decile_score_1', u'decile_score_2',\n",
    "      u'decile_score_3', u'decile_score_4', u'decile_score_5'\n",
    "    ]\n",
    "    for i in range(len(to_fill) - 1):\n",
    "        df[to_fill[i]] = df[to_fill[i:]].max(axis=1)\n",
    "    to_fill = [\n",
    "      u'priors_count_0.0', u'priors_count_1.0', u'priors_count_2.0',\n",
    "      u'priors_count_3.0', u'priors_count_4.0'\n",
    "    ]\n",
    "    for i in range(len(to_fill) - 1):\n",
    "        df[to_fill[i]] = df[to_fill[i:]].max(axis=1)\n",
    "\n",
    "    features = [\n",
    "      u'days_b_screening_arrest', u'c_charge_degree_F', u'c_charge_degree_M',\n",
    "      u'race_African-American', u'race_Asian', u'race_Caucasian',\n",
    "      u'race_Hispanic', u'race_Native American', u'race_Other',\n",
    "      u'score_text_High', u'score_text_Low', u'score_text_Medium',\n",
    "      u'sex_Female', u'sex_Male', u'age_0', u'age_1', u'age_2', u'age_3',\n",
    "      u'age_4', u'age_5', u'decile_score_0', u'decile_score_1',\n",
    "      u'decile_score_2', u'decile_score_3', u'decile_score_4',\n",
    "      u'decile_score_5', u'priors_count_0.0', u'priors_count_1.0',\n",
    "      u'priors_count_2.0', u'priors_count_3.0', u'priors_count_4.0'\n",
    "    ]\n",
    "    df = df[features + [LABEL_COLUMN]]\n",
    "    return df, features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now load the data and make a random train/test split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df, FEATURE_NAMES = get_data()\n",
    "\n",
    "tf.set_random_seed(1234)\n",
    "\n",
    "df.sample(frac=1, random_state=12345)\n",
    "N = len(df)\n",
    "train_df = df[:int(N * 0.7)]\n",
    "test_df = df[int(N * 0.7):]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model.\n",
    "\n",
    "We use a 1-hidden layer Neural Network with ReLU activations and 10 hidden units. We show that even with a small neural network, we will already see some oscillation and non-convergence that arises due to non-convexity.\n",
    "\n",
    "In the following code, we initialize the placeholders and model. In build_train_op, we set up the constrained optimization problem. We create a rate context for the entire dataset, and compute the overall true positive rate as the positive prediction rate on the positively labeled subset. We then construct a constraint for each of the protected groups based on the difference between the true positive rates of the protected group and that of the overall dataset. We then construct a minimization problem using RateMinimizationProblem and use the ProxyLagrangianOptimizerV1 as the solver. build_train_op initializes a training operation which will later be used to actually train the model. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _construct_model(input_tensor, hidden_units=10):\n",
    "    hidden = tf.layers.dense(\n",
    "        inputs=input_tensor,\n",
    "        units=hidden_units,\n",
    "        activation=tf.nn.relu)\n",
    "    output = tf.layers.dense(\n",
    "        inputs=hidden,\n",
    "        units=1,\n",
    "        activation=None)\n",
    "    return output\n",
    "\n",
    "class Model(object):\n",
    "    def __init__(self,\n",
    "                 feature_names,\n",
    "                 hidden_units=10,\n",
    "                 tpr_max_diff=0):\n",
    "        tf.random.set_random_seed(123)\n",
    "        self.feature_names = feature_names\n",
    "        self.tpr_max_diff = tpr_max_diff\n",
    "        num_features = len(self.feature_names)\n",
    "        self.features_placeholder = tf.placeholder(\n",
    "            tf.float32, shape=(None, num_features), name='features_placeholder')\n",
    "        self.labels_placeholder = tf.placeholder(\n",
    "            tf.float32, shape=(None, 1), name='labels_placeholder')\n",
    "        self.protected_placeholders = [tf.placeholder(tf.float32, shape=(None, 1), name=attribute+\"_placeholder\") for attribute in PROTECTED_COLUMNS]\n",
    "        self.predictions_tensor = _construct_model(\n",
    "            self.features_placeholder, hidden_units=hidden_units)\n",
    "\n",
    "    def build_train_op(self,\n",
    "                       learning_rate,\n",
    "                       unconstrained=False):\n",
    "        ctx = tfco.rate_context(self.predictions_tensor, self.labels_placeholder)\n",
    "        positive_slice = ctx.subset(self.labels_placeholder > 0) \n",
    "        overall_tpr = tfco.positive_prediction_rate(positive_slice)\n",
    "        constraints = []\n",
    "        if not unconstrained:\n",
    "            for placeholder in self.protected_placeholders:\n",
    "                slice_tpr = tfco.positive_prediction_rate(ctx.subset((placeholder > 0) & (self.labels_placeholder > 0)))\n",
    "                constraints.append(slice_tpr <= overall_tpr + self.tpr_max_diff)\n",
    "        mp = tfco.RateMinimizationProblem(tfco.error_rate(ctx), constraints)\n",
    "        opt = tfco.ProxyLagrangianOptimizerV1(tf.train.AdamOptimizer(learning_rate))\n",
    "        self.train_op = opt.minimize(mp)\n",
    "        return self.train_op\n",
    "  \n",
    "    def feed_dict_helper(self, dataframe):\n",
    "        feed_dict = {self.features_placeholder:\n",
    "                  dataframe[self.feature_names],\n",
    "              self.labels_placeholder:\n",
    "                  dataframe[[LABEL_COLUMN]],}\n",
    "        for i, protected_attribute in enumerate(PROTECTED_COLUMNS):\n",
    "            feed_dict[self.protected_placeholders[i]] = dataframe[[protected_attribute]]\n",
    "        return feed_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training.\n",
    "\n",
    "Below is the function which performs the training of our constrained optimization problem. Each call to the function does one epoch through the dataset and then yields the training and testing predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def training_generator(model,\n",
    "                       train_df,\n",
    "                       test_df,\n",
    "                       minibatch_size,\n",
    "                       num_iterations_per_loop=1,\n",
    "                       num_loops=1):\n",
    "    random.seed(31337)\n",
    "    num_rows = train_df.shape[0]\n",
    "    minibatch_size = min(minibatch_size, num_rows)\n",
    "    permutation = list(range(train_df.shape[0]))\n",
    "    random.shuffle(permutation)\n",
    "\n",
    "    session = tf.Session()\n",
    "    session.run((tf.global_variables_initializer(),\n",
    "               tf.local_variables_initializer()))\n",
    "\n",
    "    minibatch_start_index = 0\n",
    "    for n in xrange(num_loops):\n",
    "        for _ in xrange(num_iterations_per_loop):\n",
    "            minibatch_indices = []\n",
    "            while len(minibatch_indices) < minibatch_size:\n",
    "                minibatch_end_index = (\n",
    "                minibatch_start_index + minibatch_size - len(minibatch_indices))\n",
    "                if minibatch_end_index >= num_rows:\n",
    "                    minibatch_indices += range(minibatch_start_index, num_rows)\n",
    "                    minibatch_start_index = 0\n",
    "                else:\n",
    "                    minibatch_indices += range(minibatch_start_index, minibatch_end_index)\n",
    "                    minibatch_start_index = minibatch_end_index\n",
    "            session.run(\n",
    "                  model.train_op,\n",
    "                  feed_dict=model.feed_dict_helper(\n",
    "                      train_df.iloc[[permutation[ii] for ii in minibatch_indices]]))\n",
    "            \n",
    "        train_predictions = session.run(\n",
    "            model.predictions_tensor,\n",
    "            feed_dict=model.feed_dict_helper(train_df))\n",
    "        test_predictions = session.run(\n",
    "            model.predictions_tensor,\n",
    "            feed_dict=model.feed_dict_helper(test_df))\n",
    "\n",
    "        yield (train_predictions, test_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing accuracy and fairness metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def error_rate(predictions, labels):\n",
    "    signed_labels = (\n",
    "      (labels > 0).astype(np.float32) - (labels <= 0).astype(np.float32))\n",
    "    numerator = (np.multiply(signed_labels, predictions) <= 0).sum()\n",
    "    denominator = predictions.shape[0]\n",
    "    return float(numerator) / float(denominator)\n",
    "\n",
    "\n",
    "def positive_prediction_rate(predictions, subset):\n",
    "    numerator = np.multiply((predictions > 0).astype(np.float32),\n",
    "                          (subset > 0).astype(np.float32)).sum()\n",
    "    denominator = (subset > 0).sum()\n",
    "    return float(numerator) / float(denominator)\n",
    "\n",
    "def tpr(df):\n",
    "    \"\"\"Measure the true positive rate.\"\"\"\n",
    "    fp = sum((df['predictions'] >= 0.0) & (df[LABEL_COLUMN] > 0.5))\n",
    "    ln = sum(df[LABEL_COLUMN] > 0.5)\n",
    "    return float(fp) / float(ln)\n",
    "\n",
    "def _get_error_rate_and_constraints(df, tpr_max_diff):\n",
    "    \"\"\"Computes the error and fairness violations.\"\"\"\n",
    "    error_rate_local = error_rate(df[['predictions']], df[[LABEL_COLUMN]])\n",
    "    overall_tpr = tpr(df)\n",
    "    return error_rate_local, overall_tpr, [tpr(df[df[protected_attribute] > 0.5]) - (overall_tpr + tpr_max_diff) for protected_attribute in PROTECTED_COLUMNS]\n",
    "\n",
    "def _get_exp_error_rate_constraints(cand_dist, error_rates_vector,\n",
    "                                    overall_tpr_vector, constraints_matrix):\n",
    "    \"\"\"Computes the expected error and fairness violations on a randomized solution.\"\"\"\n",
    "    expected_error_rate = np.dot(cand_dist, error_rates_vector)\n",
    "    expected_overall_tpr = np.dot(cand_dist, overall_tpr_vector)\n",
    "    expected_constraints = np.matmul(cand_dist, constraints_matrix)\n",
    "    return expected_error_rate, expected_overall_tpr, expected_constraints\n",
    "\n",
    "\n",
    "def get_iterate_metrics(cand_dist, best_cand_index, error_rate_vector,\n",
    "                        overall_tpr_vector, constraints_matrix):\n",
    "    metrics = {}\n",
    "    exp_error_rate, exp_overall_tpr, exp_constraints = _get_exp_error_rate_constraints(\n",
    "      cand_dist, error_rate_vector, overall_tpr_vector, constraints_matrix)\n",
    "    metrics['m_stochastic_error_rate'] = exp_error_rate\n",
    "    metrics['m_stochastic_overall_tpr'] = exp_overall_tpr\n",
    "    metrics['m_stochastic_max_constraint_violation'] = max(exp_constraints)\n",
    "    for i, constraint in enumerate(exp_constraints):\n",
    "        metrics['m_stochastic_constraint_violation_%d' % i] = constraint\n",
    "    metrics['best_error_rate'] = error_rate_vector[best_cand_index]\n",
    "    metrics['last_error_rate'] = error_rate_vector[-1]\n",
    "    metrics['t_stochastic_error_rate'] = sum(error_rate_vector) / len(\n",
    "      error_rate_vector)\n",
    "    metrics['best_overall_tpr'] = overall_tpr_vector[best_cand_index]\n",
    "    metrics['last_overall_tpr'] = overall_tpr_vector[-1]\n",
    "    metrics['t_stochastic_overall_tpr'] = sum(overall_tpr_vector) / len(\n",
    "      overall_tpr_vector)\n",
    "    avg_constraints = []\n",
    "    best_constraints = []\n",
    "    last_constraints = []\n",
    "    for constraint_iterates in np.transpose(constraints_matrix):\n",
    "        avg_constraint = sum(constraint_iterates) / len(constraint_iterates)\n",
    "        avg_constraints.append(avg_constraint)\n",
    "        best_constraints.append(constraint_iterates[best_cand_index])\n",
    "        last_constraints.append(constraint_iterates[-1])\n",
    "    metrics['best_max_constraint_violation'] = max(best_constraints)\n",
    "    for i, constraint in enumerate(best_constraints):\n",
    "        metrics['best_constraint_violation_%d' % i] = constraint\n",
    "        metrics['last_max_constraint_violation'] = max(last_constraints)\n",
    "    for i, constraint in enumerate(last_constraints):\n",
    "        metrics['last_constraint_violation_%d' % i] = constraint\n",
    "        metrics['t_stochastic_max_constraint_violation'] = max(avg_constraints)\n",
    "    for i, constraint in enumerate(avg_constraints):\n",
    "        metrics['t_stochastic_constraint_violation_%d' % i] = constraint\n",
    "    metrics['all_errors'] = error_rate_vector\n",
    "    metrics['all_violations'] = np.max(constraints_matrix, axis=1)\n",
    "\n",
    "    return metrics\n",
    "\n",
    "def training_helper(model,\n",
    "                    train_df,\n",
    "                    test_df,\n",
    "                    minibatch_size,\n",
    "                    num_iterations_per_loop=1,\n",
    "                    num_loops=1):\n",
    "    train_objective_vector = []\n",
    "    train_constraints_loss_matrix = []\n",
    "    train_error_rate_vector = []\n",
    "    train_overall_tpr_vector = []\n",
    "    train_constraints_matrix = []\n",
    "    test_error_rate_vector = []\n",
    "    test_overall_tpr_vector = []\n",
    "    test_constraints_matrix = []\n",
    "    for train, test in training_generator(\n",
    "      model, train_df, test_df, minibatch_size, num_iterations_per_loop,\n",
    "      num_loops):\n",
    "        train_df['predictions'] = train\n",
    "        test_df['predictions'] = test\n",
    "\n",
    "        train_error_rate, train_overall_tpr, train_constraints = _get_error_rate_and_constraints(\n",
    "          train_df, model.tpr_max_diff)\n",
    "        train_error_rate_vector.append(train_error_rate)\n",
    "        train_overall_tpr_vector.append(train_overall_tpr)\n",
    "        train_constraints_matrix.append(train_constraints)\n",
    "\n",
    "        test_error_rate, test_overall_tpr, test_constraints = _get_error_rate_and_constraints(\n",
    "            test_df, model.tpr_max_diff)\n",
    "        test_error_rate_vector.append(test_error_rate)\n",
    "        test_overall_tpr_vector.append(test_overall_tpr)\n",
    "        test_constraints_matrix.append(test_constraints)\n",
    "\n",
    "    cand_dist = tfco.find_best_candidate_distribution(\n",
    "      train_error_rate_vector, train_constraints_matrix, epsilon=0.001)\n",
    "    best_cand_index = tfco.find_best_candidate_index(\n",
    "      train_error_rate_vector, train_constraints_matrix)\n",
    "    train_metrics = get_iterate_metrics(\n",
    "      cand_dist, best_cand_index, train_error_rate_vector,\n",
    "      train_overall_tpr_vector, train_constraints_matrix)\n",
    "    test_metrics = get_iterate_metrics(\n",
    "      cand_dist, best_cand_index, test_error_rate_vector,\n",
    "      test_overall_tpr_vector, test_constraints_matrix)\n",
    "\n",
    "    return (train_metrics, test_metrics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baseline without constraints.\n",
    "\n",
    "We now declare the model, build the training op, and then perform the training. We use a neural network with 10 hidden units as the underlying classifier, and train using the ADAM optimizer with learning rate 0.01, with minibatch size of 100 over 500 epochs. We first train without fairness constraints to show the baseline performance. We see that without training fair fairness, we obtain a high fairness violation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(FEATURE_NAMES, hidden_units=10)\n",
    "\n",
    "model.build_train_op(0.01, unconstrained=True)\n",
    "\n",
    "results = training_helper(\n",
    "      model,\n",
    "      train_df,\n",
    "      test_df,\n",
    "      100,\n",
    "      num_iterations_per_loop=44,\n",
    "      num_loops=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Error 0.29421296296296295\n",
      "Train Violation 0.0967080478842346\n"
     ]
    }
   ],
   "source": [
    "print(\"Train Error\", results[0][\"last_error_rate\"])\n",
    "print(\"Train Violation\", results[0][\"last_max_constraint_violation\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting it together: training with fairness constraints.\n",
    "\n",
    "We now train with fairness constraints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(FEATURE_NAMES, hidden_units=10)\n",
    "\n",
    "model.build_train_op(0.01, unconstrained=False)\n",
    "\n",
    "results = training_helper(\n",
    "      model,\n",
    "      train_df,\n",
    "      test_df,\n",
    "      100,\n",
    "      num_iterations_per_loop=44,\n",
    "      num_loops=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The iterates oscillate.\n",
    "\n",
    "We now plot the errors and violations of our iterate at the end of each epoch. We see that they don't converge and there is oscillating behavior. Thus suggests that the Lagrangian either has no stationary point to converge to or it is very difficult for our gradient-based methods to find one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(\"Error Rate vs Epoch\")\n",
    "plt.plot(range(100, len(results[0][\"all_errors\"])), results[0][\"all_errors\"][100:], color=\"green\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.show()\n",
    "plt.title(\"Violation vs Epoch\")\n",
    "plt.plot(range(100, len(results[0][\"all_violations\"])), results[0][\"all_violations\"][100:], color=\"blue\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using stochastic solution.\n",
    "\n",
    "This motivates the use of stochastic classifiers, which was proposed in [[CoJiSr19]](https://arxiv.org/abs/1804.06500). It was shown that the average iterate has guarantees. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results for Average Iterate.\n",
      "Train Error 0.3005370370370371\n",
      "Train Violation 0.0021946623392345966\n"
     ]
    }
   ],
   "source": [
    "print(\"Results for Average Iterate.\")\n",
    "print(\"Train Error\", results[0][\"t_stochastic_error_rate\"])\n",
    "print(\"Train Violation\", results[0][\"t_stochastic_max_constraint_violation\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shrinking the stochastic solution.\n",
    "\n",
    "The average of all the iterates may be computationally intensive (i.e. requires storing and processing the iterates at each epoch, and the number of iterates may become arbitrarily large). Moreover, the average iterate can have consituents that are suboptimal (especially the early iterates). [[CoJiSr19]](https://arxiv.org/abs/1804.06500) proposed a method to shrink down the uniform mixture of all iterates to one that is a mixture of at most m+1 solutions where m is the number of constraints with guarantees that the new solution will be at least as good as the original solution. This can be done using the find_best_candidate_distribution function. We see an improvement in terms of both fairness and accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results after Shrinking\n",
      "Train Error 0.29370749834992005\n",
      "Train Violation 5.854691731421724e-18\n"
     ]
    }
   ],
   "source": [
    "print(\"Results after Shrinking\")\n",
    "print(\"Train Error\", results[0][\"m_stochastic_error_rate\"])\n",
    "print(\"Train Violation\", results[0][\"m_stochastic_max_constraint_violation\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}