examples/fairret.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fairrets comparison\n",
    "\n",
    "This is demo code comparing Fairrets https://github.com/aida-ugent/fairret with OxonFair using equal opportunity, and on tabular data as done in their paper.\n",
    "\n",
    "Where possible we have followed good practices.\n",
    "\n",
    "Fairrets doesn't use a validation set, so we merged train and val for them.\n",
    "\n",
    "For tabular data, wide shallow networks tend to work best, so we've used these, and we use a batch size of 1000 for fairrets to try to make it more stable.\n",
    "\n",
    "However, performance and fairness remains noticeably worse than OxonFair on a network of the same architecture.\n",
    "\n",
    "Increasing the regularization weight to 5 or 10 increases fairness, but the classifier is strongly degraded. Their simple pipeline demo uses 1, but this doesn't seem to be helping with fairness.\n",
    "\n",
    "If you know how to make it work better, please submit a patch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load libraries\n",
    "\n",
    "import oxonfair\n",
    "from oxonfair import group_metrics as gm\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch import nn, optim\n",
    "import xgboost\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load adult dataset, using sex as the default groups and discard sex from the raw data\n",
    "train, val, test = oxonfair.dataset_loader.adult(discard_groups=True, seed=0,train_proportion=0.4,test_proportion=0.3)\n",
    "#Note that Eopp is difficult because we have few positive e.g. for women and so we use more data in val, test for stability of outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Normalise data\n",
    "std = train['data'].std()\n",
    "train['data'] = train['data'] / std\n",
    "val['data'] = val['data'] / std\n",
    "test['data'] = test['data'] / std\n",
    "# Merge train and val as fairret can't use val\n",
    "fairret_data = torch.tensor(np.vstack((train['data'],val['data']))).float()\n",
    "fairret_target = torch.tensor(np.hstack((train['target'],val['target']))).float()\n",
    "fairret_groups = torch.tensor(np.hstack((train['groups'],val['groups']))==' Male').float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define a basic nn with 2 hidden-layers. 1 of width 100, and the second width 50.\n",
    "network = nn.Sequential(nn.Linear(train['data'].shape[1],100),\n",
    "                        nn.SELU(),\n",
    "                        nn.Linear(100,50),\n",
    "                        nn.SELU(),\n",
    "                        nn.Linear(50,2))\n",
    "#fairret network\n",
    "network_1head = nn.Sequential(nn.Linear(train['data'].shape[1],100),\n",
    "                              nn.SELU(),\n",
    "                              nn.Linear(100,50),\n",
    "                              nn.SELU(),\n",
    "                              nn.Linear(50,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a custom loss that trains the two-heads as required.\n",
    "def loss(x, y, g):\n",
    "    output = network(x)\n",
    "    loss0 = F.binary_cross_entropy_with_logits(output[:,0], y)\n",
    "    loss1 = F.mse_loss(output[:,1], g)\n",
    "    return loss0+loss1\n",
    "\n",
    "from fairret.statistic import TruePositiveRate\n",
    "from fairret.loss import NormLoss\n",
    "\n",
    "statistic = TruePositiveRate()\n",
    "norm_fairret = NormLoss(statistic)\n",
    "\n",
    "#fairret loss\n",
    "def loss_1head(x,y,g,scalar=1):\n",
    "    output = network_1head(x)\n",
    "    y=y.reshape(-1,1)\n",
    "    g=g.reshape(-1,1)\n",
    "    loss0 = F.binary_cross_entropy_with_logits(output, y)\n",
    "    loss1 = norm_fairret(output,g,y)\n",
    "    return loss0+scalar*loss1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copy variables to tensors\n",
    "target = torch.tensor(train['target']).float()\n",
    "data = torch.tensor(np.asarray(train['data'])).float()\n",
    "groups = torch.tensor(train['groups']==' Male').float()\n",
    "\n",
    "optimizer = optim.Adam(network.parameters(), lr=1e-4)\n",
    "optimizer_1head = optim.Adam(network_1head.parameters(), lr=1e-4)\n",
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch is 0\n",
      "epoch is 10\n",
      "epoch is 20\n",
      "epoch is 30\n",
      "epoch is 40\n",
      "epoch is 50\n",
      "epoch is 60\n",
      "epoch is 70\n",
      "epoch is 80\n",
      "epoch is 90\n"
     ]
    }
   ],
   "source": [
    "# Train the network\n",
    "batch_size = 50\n",
    "\n",
    "for epoch in range(100):\n",
    "    #shuffle data\n",
    "    perm = random.permutation(target.shape[0])\n",
    "    target = target[perm]\n",
    "    data = data[perm]\n",
    "    groups = groups[perm]\n",
    "    if epoch%10==0:\n",
    "        print ('epoch is %d'%epoch)\n",
    "    for step in range(target.shape[0]//batch_size): # This discards the final incomplete batch\n",
    "        optimizer.zero_grad()\n",
    "        l = loss(data[step*batch_size:(1+step)*batch_size],\n",
    "                 target[step*batch_size:(1+step)*batch_size],\n",
    "                 groups[step*batch_size:(1+step)*batch_size])\n",
    "        l.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch is 0\n",
      "epoch is 10\n",
      "epoch is 20\n",
      "epoch is 30\n",
      "epoch is 40\n",
      "epoch is 50\n",
      "epoch is 60\n",
      "epoch is 70\n",
      "epoch is 80\n",
      "epoch is 90\n"
     ]
    }
   ],
   "source": [
    "# Train the network\n",
    "# Inherently any loss based fairness regulariser is unstable and needs large batches.\n",
    "# This is particularly true for Equal Opportunity when positive target labels and particular groups are sparse.\n",
    "# 1000 is copied from their code. It might not be large enough, but it is already causing a 6x slow down.\n",
    "batch_size = 1000\n",
    "\n",
    "for epoch in range(100):\n",
    "    #shuffle data\n",
    "    perm = random.permutation(fairret_target.shape[0])\n",
    "    target = fairret_target[perm]\n",
    "    data = fairret_data[perm]\n",
    "    groups = fairret_groups[perm]\n",
    "    if epoch%10==0:\n",
    "        print ('epoch is %d'%epoch)\n",
    "    for step in range(target.shape[0]//batch_size): # This discards the final incomplete batch\n",
    "        optimizer_1head.zero_grad()\n",
    "        l = loss_1head(fairret_data[step*batch_size:(1+step)*batch_size],\n",
    "                 fairret_target[step*batch_size:(1+step)*batch_size],\n",
    "                 fairret_groups[step*batch_size:(1+step)*batch_size],1)\n",
    "        l.backward()\n",
    "        optimizer_1head.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#convert test['data'] to tensor via numpy and then move the output back to numpy\n",
    "test_output=np.asarray(network(torch.tensor(np.asarray(test['data'])).float()).detach())\n",
    "test_output_1head=np.asarray(network_1head(torch.tensor(np.asarray(test['data'])).float()).detach())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's train a fair classifier using the two heads \n",
    "#convert val['data'] to tensor via numpy and then move the output back to numpy\n",
    "val_output = np.asarray(network(torch.tensor(np.asarray(val['data'])).float()).detach())\n",
    "train_output = np.asarray(network(torch.tensor(np.asarray(train['data'])).float()).detach())\n",
    "test_output = np.asarray(network(torch.tensor(np.asarray(test['data'])).float()).detach())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up a fairpredictor using the neural network over the validation data\n",
    "fpred = oxonfair.DeepFairPredictor(val['target'],\n",
    "                                   val_output,\n",
    "                                   groups=val['groups'])\n",
    "\n",
    "# Enforce EO to within 1%\n",
    "fpred.fit(gm.accuracy, gm.equal_opportunity, 0.01)\n",
    "# Varying the grid with can improve accuracy at the cost of a longer search time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_network = oxonfair.DeepDataDict(test['target'], test_output, test['groups'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8439227461953184, 0.04137239076421528)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute\n",
    "import pandas as pd\n",
    "fairret_score = ((oxonfair.performance.evaluate(test['target'],test_output_1head.reshape(-1))['Accuracy'],\n",
    "                  oxonfair.performance.evaluate_fairness(test['target'],test_output_1head.reshape(-1),test['groups'])['Equal Opportunity']))\n",
    "fairret_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To emphasize that you shouldn't use standard neural networks on tabular data, \n",
    "# we compare with xgboost\n",
    "# train a base classifier\n",
    "pred = xgboost.XGBClassifier().fit(X=train['data'],y=train['target'])\n",
    "# and a second classifier to infer group membership\n",
    "group_pred = xgboost.XGBClassifier().fit(X=train['data'],y=train['groups'] == ' Male')\n",
    "fpred2 = oxonfair.FairPredictor(pred,val, inferred_groups=group_pred)\n",
    "fpred2.fit(gm.accuracy, gm.equal_opportunity, 0.01)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1683c2cd0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "fpred2.plot_frontier(data=test, name_frontier='XGBoost Front')\n",
    "fpred.plot_frontier(data=test_network, new_plot=False,name_frontier='Neural Net Front')\n",
    "plt.scatter(y=fairret_score[0],x=fairret_score[1],label='Fairrets',marker='X')\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The frontier turning into this kind of noisy point cloud is expected on test data. \n",
    "\n",
    "For very small measures of fairness differences in sampling can lead to noticeable shifts in ordering creating these unstable orderings.\n",
    "\n",
    " For comparison here are the clean curves on validation data (where fairness was enforced)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fpred2.plot_frontier(name_frontier='XGBoost Front')\n",
    "fpred.plot_frontier(new_plot=False,name_frontier='Neural Net Front')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finally let's show how the 2-headed network can be merged into a single-headed network that makes fair predictions.\n",
    "# We copy the network and create a fair version\n",
    "import copy\n",
    "fair_network= copy.deepcopy(network)\n",
    "# We replace the final linear layer with a 1 dimensional head.\n",
    "fair_network[-1] = fpred.merge_heads_pytorch(network[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate the new fair network on test\n",
    "test_output_fair=np.asarray(fair_network(torch.tensor(np.asarray(test['data'])).float()).detach())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8499283423189791, 0.03749450062510884)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((oxonfair.performance.evaluate(test['target'],test_output_fair.reshape(-1))['Accuracy'],\n",
    "  oxonfair.performance.evaluate_fairness(test['target'],test_output_fair.reshape(-1),test['groups'])['Equal Opportunity']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8439227461953184, 0.04137239076421528)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The same score for fairrets was\n",
    "fairret_score"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3.8",
   "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}