synthetic_experiment2_without_A_as_feature.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fair Dummies: Synthetic Example\n",
    "\n",
    "This notebook implements a the fair dummies framework for learning predictive models that approximately satisfy the equalized odds notion of fairness.\n",
    "\n",
    "Paper: \"Achieving Equalized Odds by Resampling Sensitive Attributes,\" Y. Romano, S. Bates, and E. J. Candès, 2020\n",
    "\n",
    "### Proposed approach\n",
    "\n",
    "__Core idea__: fit a regression function, minimizing\n",
    "\n",
    "$$ \\text{loss = prediction error + distance to equalized odds}$$\n",
    "\n",
    "\n",
    "__Input__: $  \\{(X_i,A_i,Y_i)\\}_{i=1}^n \\sim P_{XAY}$ training data\n",
    "    \n",
    "\n",
    "__Step 1__: sample dummy protected attributes\n",
    "$$\n",
    "\\tilde{A}_i \\sim P_{A|Y}(A \\mid Y=y_{i}) \\quad \\forall \\ i=1,2,\\dots,n \\nonumber\n",
    "$$\n",
    "\n",
    "$A \\in \\{0,1\\}$? generate $\\tilde{A}$ using a biased coin-flip, with\n",
    "$$\n",
    "P\\{A=1|Y=y\\} = \\frac{P\\{y \\mid A=1\\}P\\{A=1\\}}{P\\{y \\mid A=1\\}P\\{A=1\\} + P\\{y \\mid A=0\\}P\\{A=0\\}}\n",
    "$$\n",
    "    \n",
    "__Step 2__: fit a regression function on $\\{(X_i, A_i, Y_i)\\}_{i=1}^n$\n",
    "\n",
    "$$\n",
    "        \\hat{f}(\\cdot) \\,= \\, \\underset{f \\in \\mathcal{F}}{\\mathrm{arg min}} \\, \\frac{1-\\lambda}{n} \\sum_{i=1}^n (Y_i - f(X_i))^2  + \\lambda \\mathcal{D}\\left( [\\hat{\\mathbf{Y}}, \\mathbf{A}, \\mathbf{Y}] , [\\hat{\\mathbf{Y}}, \\tilde{\\mathbf{A}}, \\mathbf{Y}] \\right) \\nonumber\n",
    "$$\n",
    "\n",
    "where\n",
    "    \n",
    "$$\n",
    "\\hat{\\mathbf{Y}} = \\left[f(X_{1}), f(X_{2}), \\dots, f(X_{n})\\right]^T \\ ; \\ \\mathbf{A} = \\left[A_{1}, A_{2}, \\dots, A_{n}\\right]^T \\ ; \\ \\tilde{\\mathbf{A}} = \\left[\\tilde{A}_{1}, \\tilde{A}_{2}, \\dots, \\tilde{A}_{n}\\right]^T \\ ; \\ \\mathbf{Y} = \\left[Y_{1}, Y_{2}, \\dots, Y_{n}\\right]^T\n",
    "$$\n",
    "\n",
    "and $\\mathcal{D}\\left( \\mathbf{Z}_1, \\mathbf{Z}_2 \\right)$ tests whether $P_{Z_1} = \\ P_{Z_2}$ given $\\mathbf{Z}_1, \\mathbf{Z}_2$,  here it implemented as a classifier two-sample test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "import matplotlib\n",
    "matplotlib.use('Agg')\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "np.warnings.filterwarnings('ignore')\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import pandas as pd\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "\n",
    "sys.path.append(os.path.abspath(os.path.join(os.getcwd() + '/others/third_party/cqr')))\n",
    "base_path = os.getcwd() + '/data/'\n",
    "    \n",
    "from fair_dummies import fair_dummies_learning\n",
    "from fair_dummies import utility_functions\n",
    "\n",
    "seed = 123\n",
    "\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "\n",
    "# maximal number of testpoints to plot\n",
    "max_show = 100\n",
    "\n",
    "# save figures?\n",
    "save_figures = False\n",
    "\n",
    "# display results\n",
    "if save_figures:\n",
    "    SMALL_SIZE = 26\n",
    "else:\n",
    "    SMALL_SIZE = 18\n",
    "\n",
    "MEDIUM_SIZE = SMALL_SIZE\n",
    "BIGGER_SIZE = SMALL_SIZE\n",
    "\n",
    "plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n",
    "plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
    "plt.rc('text', usetex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_func(x,\n",
    "              y,\n",
    "              y_u=None,\n",
    "              y_l=None,\n",
    "              pred=None,\n",
    "              point_color=\"b.\",\n",
    "              shade_color=\"\",\n",
    "              method_name=\"\",\n",
    "              title=\"\",\n",
    "              filename=None,\n",
    "              save_figures=False,\n",
    "              show_legend=True):\n",
    "    \n",
    "    \"\"\" Scatter plot of (x,y) points along with the constructed prediction interval \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x : numpy array, corresponding to the feature of each of the n samples\n",
    "    y : numpy array, target response variable (length n)\n",
    "    pred : numpy array, the estimated prediction. It may be the conditional mean,\n",
    "           or low and high conditional quantiles.\n",
    "    shade_color : string, desired color of the prediciton interval\n",
    "    method_name : string, name of the method\n",
    "    title : string, the title of the figure\n",
    "    filename : sting, name of the file to save the figure\n",
    "    save_figures : boolean, save the figure (True) or not (False)\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    inds = np.random.permutation(x.shape[0])[:max_show]\n",
    "    x_ = x[inds]\n",
    "    y_ = y[inds]\n",
    "    if y_u is not None:\n",
    "        y_u_ = y_u[inds]\n",
    "    if y_l is not None:\n",
    "        y_l_ = y_l[inds]\n",
    "    if pred is not None:\n",
    "        pred_ = pred[inds]\n",
    "\n",
    "    fig = plt.figure()\n",
    "    inds = np.argsort(np.squeeze(x_))\n",
    "    \n",
    "    if (y_u is not None) and (y_l is not None):\n",
    "        plt.fill_between(x_[inds].squeeze(),\n",
    "                         y_u_[inds],\n",
    "                         y_l_[inds],\n",
    "                         alpha=.2,\n",
    "                         color=shade_color,\n",
    "                         edgecolor=\"\",\n",
    "                         label = u'Prediction interval')\n",
    "    \n",
    "    if pred is not None:\n",
    "        if pred_.ndim == 2:\n",
    "            plt.plot(x_[inds,:], pred_[inds,0], 'k', lw=2, alpha=0.2,\n",
    "                     label=u'Predicted low and high quantiles')\n",
    "            plt.plot(x_[inds,:], pred_[inds,1], 'k', lw=2, alpha=0.2)\n",
    "        else:\n",
    "            plt.plot(x_[inds,:], pred_[inds], point_color, lw=2, alpha=0.8, markersize=15,\n",
    "                     fillstyle='none')\n",
    "    min_val = -8\n",
    "    max_val = 8 \n",
    "    \n",
    "    ident = [min_val, max_val]\n",
    "    plt.xlim(ident[0], ident[1])\n",
    "    plt.ylim(ident[0], ident[1])\n",
    "    \n",
    "    plt.plot(ident,ident, ls=\"--\", c=\".3\")\n",
    "    \n",
    "    plt.xlabel(r'$Y$')\n",
    "    plt.ylabel(r'$\\hat{Y}$')\n",
    "    \n",
    "    ax = plt.gca()\n",
    "    ax.set_aspect('equal', 'box')\n",
    "    \n",
    "    plt.title(title)\n",
    "\n",
    "\n",
    "    if save_figures and (filename is not None):\n",
    "        plt.savefig(filename, bbox_inches='tight', dpi=300)\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "def plot_groups_pointwise(x_axis_0,x_axis_1,A,Y,Yhat,\n",
    "                          y_u=None,y_l=None,point_color=\"b.\",shade=\"\",\n",
    "                          filename_0=None,filename_1=None,save_figures=False):\n",
    "   \n",
    "    inds = A==0\n",
    "    \n",
    "    y_u0 = None\n",
    "    y_l0 = None\n",
    "    if (y_u is not None) and (y_l is not None):\n",
    "        y_u0=y_u[inds]\n",
    "        y_l0=y_l[inds]\n",
    "        \n",
    "    plot_func(x_axis_0.reshape(x_axis_0.shape[0],1),\n",
    "              Y[inds], y_u=y_u0, y_l=y_l0, pred=Yhat[inds],\n",
    "              point_color=point_color,shade_color=shade, method_name=\"\", title=r'$A=0$',\n",
    "              filename=filename_0, save_figures=save_figures,show_legend=True)\n",
    "\n",
    "    inds = A==1\n",
    "    \n",
    "    y_u1 = None\n",
    "    y_l1 = None\n",
    "    if (y_u is not None) and (y_l is not None):\n",
    "        y_u1=y_u[inds]\n",
    "        y_l1=y_l[inds]\n",
    "        \n",
    "    plot_func(x_axis_1.reshape(x_axis_1.shape[0],1),\n",
    "              Y[inds], y_u=y_u1, y_l=y_l1, pred=Yhat[inds],\n",
    "              point_color=point_color,shade_color=shade, method_name=\"\", title=r'$A=1$',\n",
    "              filename=filename_1, save_figures=save_figures,show_legend=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(500, 2)\n",
      "(500,)\n"
     ]
    }
   ],
   "source": [
    "def init_seed(seed = 0):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "\n",
    "def synthetic_example(include_A=False, n = 6000):\n",
    "        \n",
    "    p0 = 0.9\n",
    "    p1 = 1 - p0\n",
    "\n",
    "    A = np.random.binomial(1,p1,n).T\n",
    "    X = np.random.randn(n,2)\n",
    "\n",
    "    beta0 = [2,1]\n",
    "    beta1 = [1,2]\n",
    "\n",
    "    Y = np.random.randn(n)\n",
    "    Y[A==0] = Y[A==0] + np.dot(X[A==0],beta0)\n",
    "    Y[A==1] = Y[A==1] + np.dot(X[A==1],beta1)\n",
    "\n",
    "    x_axis_0 = Y[A==0]\n",
    "    x_axis_1 = Y[A==1]\n",
    "    \n",
    "    if include_A:\n",
    "        X = np.concatenate((X,A[:,np.newaxis]),axis=1)\n",
    "    \n",
    "    return X, A, Y, x_axis_0, x_axis_1, beta0, beta1\n",
    "\n",
    "include_A = False\n",
    "\n",
    "init_seed(seed)\n",
    "X, A, Y, x_axis_0, x_axis_1, beta0, beta1 = synthetic_example(include_A=include_A, n = 500)\n",
    "X_cal, A_cal, Y_cal, x_axis_0, x_axis_1, beta0, beta1 = synthetic_example(include_A=include_A, n = 2000)\n",
    "X_test, A_test, Y_test, x_axis_0_test, x_axis_1_test, beta0, beta1 = synthetic_example(include_A=include_A, n = 2000)\n",
    "\n",
    "# compute input dimensions\n",
    "n = X.shape[0]\n",
    "in_shape = X.shape[1]\n",
    "    \n",
    "print(X.shape)\n",
    "print(Y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimate $P_{A|Y}$ using kernel density estimator, then compute $P\\{A=1|Y=y\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD+CAYAAADcWrmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAWZklEQVR4nO3d6XJc1bnG8WclQEgqcGQZQyqpGKdTGSqppIitG0hh7sDnXIJ8B+QSKLgDfAnBX/PJrlQIkASQBFgIeZBb82hLao3W2O/5sHbHbbmlnnvtvdf/V9UF3a299dLY++m9RmdmAgDE6XuhCwAAhEMIAEDECAEAiBghAAARIwQAIGIvhC6gWa+99ppdunQpdBkAkCnDw8OPzezCydczFwKXLl3S0NBQ6DIAIFOcc9O1Xqc5CAAiRggAQMQIAQCIGCEAABEjBAAgYoQAAESMEACAiBECABCxzE0WA/KsXJamp6XFRenVV6Xf/U76Hl/V0EWEABBIuSytr/vH1JR/bXdX2t/3/z4/Lz16JP3pT1JfX7AykXOEANBjZtLSkvTNN9LW1tk/+/ixdOuW9Mc/Sr/5TW/qQ1wIAaCHNjakL7/03/6bceeO9MMfShcvdqcuxIsQAHrg4EAqFqWxMd8M1Iovv5ReeUU6d66ztSFuhADQRUdHvtlnZsb/ezvKZWl4WHr7bcm5ztQHMO4A6BIz6fPP/R1AuwFQsb7u+xOATmkoBJxzg865a8nj3QaP6UuO+6jGe1edcx855y475wrOuXedc4PNFg+k2f370sJCd84LdErdEEguzmtmdtPMbkq66Zz7sM4xlyVdlbQmqVDjR/qS14eTx3kzu9Fs8UBara5Ko6PdOffKirS52Z1zIz6N9AlcN7MrlSdmVnTOXT3rADMbkTSShMFpP3PltPeALFtclL74wjcHdcvUlB82CrTrzDsB51yfpFoX8lK9IABic3wsjY9Ln33mRwN109xcd0MG8ah3J1CQVKrx+mnNPA1LQqQvOf9lM/ugnfMBvWbm2/zX1vxM36Wl7l/8K3Z2/O89f743vw/5VS8E+uUv+CeV5C/grRqRfNOSJDnn1pxzt8zsnVo/nPRLDErSRWbLIKCtLWlvz7f5z801P+mrk6anCQG0L8g8gcrFv+r5iHNuwDlXOPle8v4NSTckaWBggJtg9JyZ9PXX0sRE6Eqemp2V3nqLBebQnkb++PTXeK0by1kV5UcUAalycCB9+mm6AkDydS0uhq4CWVcvBIZU+4Lfr6RJp1nJvICAN9FA48x8R29aJ2hVVh8FWnVmCJhZSVIxGSVUrc/Mbrfxe9+r8VpBUjvnBDpufNyv5JlWi4u+jwJoVSPNQe8r6ZSV/jsR7HbV80Iy+/e0O4ZnJG3+z4w4cs5dk/TXWv0BQCgLC37BtzQz8+sSAa2q2zFsZjeS5R8qQzoLZna96kcK8m35/Uou7s65gqRrkt6RdNk5976kh5VZwZVzJsf3Ja9VnxMIqlSS/v3v0FU0ZnJS+tWvWFQOrXGWsRknAwMDNjQ0FLoM5Nwnn6S3H6CWP/9Zeu210FUgzZxzw2Y2cPJ1BpcBJ6ysZCsApPSNXEJ2EAJAlXLZzwfImrk5aXs7dBXIIkIAqPLggd8CMmvMpHv3QleBLCIEgMT2dvpHA52lE7uXIT6EACD/TXpoyK8EmlVHR34pCaAZhAAgvxjbo0ehq2hfkZk2aBIhgOjt7UlffRW6is5YW8tmnwbCIQQQvfHxfLWlT0+HrgBZQgggaisr0sOHoavorJkZdh1D4wgBRGt3V/rXv/J3wXzyJN2L3iFdCAFEqVz2awMdHoaupDsmJ0NXgKwgBBCl8XHfiZpXc3P5DTh0FiGA6Ozt5X927fGxXwobqIcQQHTu3s32pLBGMUoIjSAEEJW9vfyNBjrN8jKLyqE+QgBRuXfPdwrHIpbAQ+sIAURjfz++i+LUVBxNX2gdIYBoTEzEd0E8OJDm50NXgTQjBBCFcjnexdWmpkJXgDQjBBCFxUXfKRyjlZV4/9tRHyGAKMQ8XNLMTx4DaiEEkHsHB/5OIGaTk/lbIwmdQQgg92Zm4hoWWkupxKJyqI0QQO7F3BRU7f790BUgjQgB5Nr2dr4XimvGwoJfPhuoRggg1xge+axYh8nidIQAcqtcZl39k4pF+kfwLEIAubWwwPj4k/b3pdnZ0FUgTQgB5NbMTOgK0mliInQFSBNCALnE3IDTra3RWY6nCAHk0uwsbd9n4W4AFYQAcolRMGebnaW/BB4hgNxZX/czZHG6ctlvswkQAsgdhoU2ZmKC7SdBCCBnjo8ZFdQoM2lsLHQVCI0QQK7Mz0uHh6GryI7ZWZaSiB0hgFyhQ7g5ZowUih0hgNzY2pIePQpdRfZMTkpHR6GrQCiEAHLjwYPQFWTTwQGfXcwIAeTCwQGjgtpx96705EnoKhACIYBcmJpihnA7jo6k0dHQVSAEQgCZR+dmZ0xPswVljAgBZN78vLSzE7qKfPj8c7/cNOJBCCDTmPDUWbu70qef+j4WxIEQQKZNT0ubm6GryJe1Nenjj5l0FwtCAJllJo2Ph64in0olaWTEf8bIN0IAmTU/zwJo3TQz45vaCIJ8IwSQSWbSvXuhq8i/8XHps8/oLM4zQgCZNDvLFom9srjoO4uPj0NXgm54oZEfcs4NSqr8lSuY2QcNHNMn6f8kvWNm/9uJcwKSH8EyPBy6irisrfnJZG+9FboSdFrdEKhcrM3sZvK84Jz70Myun3HMZUkF+Yt8oRPnBCq+/ZYFz0J48EDq65MuXQpdCTqpkTuB62Z2pfLEzIrOuatnHWBmI5JGkjDoyDkByQ8HnZ4OXUW8Rkak8+elV14JXQk65cw+gaRJp9aFvNTqRbsb50Q8mBgW1vGx9MkndBTnSb2O4YKkWlt212zmaVA3zokIbG5Kc3Ohq8DOjjQ0FLoKdEq9EOjX087baiVJfS3+zqbP6ZwbdM4NOeeGHrFrSLRY8z49Fhb8qCFkXyaGiJrZDTMbMLOBCxcuhC4HAezv++WikR6jo0wky4NGQqC/xmut3gV085zIsZkZ9gtIm40NaWUldBVoV70QGFLti3O/pJEWf2c3zomcm50NXQFqYdZ29p0ZAmZWklRMRvRU6zOz2638wm6cE/m2uyutroauArUsL7OKa9Y10hz0vqTBypNk7P/tqucF59xHNS7qUu1mn7rnBKpxF5Bu3A1kW90QMLMbSsbwO+euSbp6YmZvQdJVVV3wk2B4V9JfJF12zr2fzBJu9JzAf83MhK4AZ5meZme3LHOWse79gYEBG2KQcjR2d6W//S10FainUJCuXKn/cwjHOTdsZgMnX8/EEFHEa2kpdAVoxPQ0W1JmFSGAVCMEsuH4mGa7rCIEkFrHx4RAlkxOhq4ArSAEkForK2xkkiWlkrS+HroKNIsQQGpxF5A9LO2RPYQAUosQyB6W98geQgCptLMjbW+HrgLNOjggvLOGEEAqcSHJLnZ+yxZCAKm0vBy6ArRqfp6dx7KEEEDqlMuEQJaZMWcgSwgBpM7qqnR0FLoKtINRQtlBCCB1FhZCV4B2lUosMZ0VhABSxYwQyAuahLKBEECqbG0xNDQvZmbYgzgLCAGkCncB+bGzw45wWUAIIFXm50NXgE56+DB0BaiHEEBq7O1Ja2uhq0Anzc76jYGQXoQAUmNxMXQF6DQz6cGD0FXgLIQAUoOmoHx6+FA6PAxdBU5DCCAVDg+ZJZxXx8esJ5RmhABSYWGBJYjzrFhkuGhaEQJIBb4p5tvGBp3+aUUIILgnT2gKigHDRdOJEEBwLC8Qh9lZv+kM0oUQQFBmNAXFolxmddE0IgQQ1MaGfyAODx/SQZw2hACCoikoLtvb0spK6CpQjRBAMGbS3FzoKtBrzCBOF0IAwZRKfqVJxGVx0S8ZjnQgBBAMdwHxuns3dAWoIAQQBJuRx216ms2D0oIQQBBraywxHDMz6bvvQlcBiRBAIDQFYXqaPqE0IATQc2YsGw1vcjJ0BSAE0HOMCkLF9DSTx0IjBNBzbCaPit1d6fHj0FXEjRBAzy0tha4AacIosbAIAfTU/j7ryuNZc3N+9zGEQQigp9g3ACcdHNBEGBIhgJ6iKQi1sMR0OIQAesaMEEBtS0tMHgyFEEDPlEq+TwCohbuBMAgB9Ax3ATjL5CRzBkIgBNAzhADOsrsrPXoUuor4EALoiYMDaXU1dBVIu4cPQ1cQH0IAPbG8zK0+6pufl/b2QlcRF0IAPcE4cDTCzK8nhN4hBNB15TL9AWjc1BR3jb1ECKDr1tZ8nwDQiM1NlhbppRca+SHn3KCkyv+Wgpl90M4xzrmrkq5Lek9SSdI1SSUzu9FE7cgImoLQrMlJ6fz50FXEoe6dQOVibmY3zeympJvOuQ/bPKZPUkHScPI4TwDk1+Ji6AqQNTMz3D32SiN3AtfN7ErliZkVk2/ybR1T/T7ya2fH394DzTg+lopF6be/DV1J/p15J+Cc65N0ucZbpdOCoJVjkF80BaFV9+9LR0ehq8i/es1BBfk2+5PWkvdaPsY5d9U5dy3557uNFIvsoSkIrdrflyYmQleRf/Wag/r1tHO3Wkm+Xb/VY0Yk30wkSc65NefcLTN7p9YJkz6GQUm6ePFinZKRFkdHLAOA9ty7JxUK0ksvha4kv4IMETWzYiUAkucjkgacczXvLszshpkNmNnAhQsXelYn2rOy4ucIAK06OJC++y50FfnWSAj013jttLuAdo4pSqLPIEdoCkInPHwoPXkSuor8qhcCQ6p98e5X0qTT7DHOuYJzbr3xEpFFZoQAOqNclsbGQleRX2eGgJmVJBWTET/V+szsdhvHvFfj0IKkmudE9mxt8e0NnTM5KW1shK4inxppDnpfSaesJDnnLqvqYp18s//oxEX/1GOSvoBnRg85565J+mt1PwGyjQ3l0Wmjo6EryKe6k8XM7IZzbjAZ498nvwTE9aofKci35fcrubjXO6byfvK0L3mt+pzIOEIAnba46AcbvP566ErypaG1g85a0iFp4jnXzDGNvI/sKpcZGoruuHNHevttybnQleQHq4ii4x4/ZqYnumN9XZqdDV1FvhAC6DhGBaGbxsbYb6CTCAF0lBnrBaG7trfZfayTCAF01NaW/0sKdNPYmF9pFO0jBNBR3AWgF3Z3/UxitI8QQEfRH4BeuXuXAQidQAigY/b3/cggoBf29/2m9GgPIYCO4S4AvfbgASOF2kUIoGPm50NXgNhsb/Plo12EADri6IilIhAGu4+1hxBARywuMmQPYSwvs8JoOwgBdMTMTOgKELO7d0NXkF2EANq2v0+7LMKanZV2dkJXkU2EANo2Pc0IDYRlRt9AqwgBtMWMmZtIh8lJJo+1ghBAW5aXWSsI6XB4yOSxVhACaMuDB6ErAJ5i8ljzCAG0bHNTWloKXQXwFJPHmkcIoGX37oWuAHgefVTNIQTQEjb2QFotLTFctBmEAFry7be0vSK9isXQFWQHIYCmra2x2TfSbXKSZUwaRQigKWbSN9+ErgI42/6+NDcXuopsIATQlKUlNo5BNjBctDGEABpmJo2Ohq4CaMz6OsubN4IQQMNmZ1myF9ly5w53A/UQAmhIucxdALJnY4OlJOohBNCQqSlpdzd0FUDzRkf9ukKojRBAXWbS/fuhqwBas7/v57WgNkIAdS0sSFtboasAWjcx4ee34HmEAM5kJo2Ph64CaN+XXzKBrBZCAGdaWPBD7YCs29yUxsZCV5E+hABOdXzsh9gBeXHvHnMHTiIEcKr799k1DPnzn//w57oaIYCatrel774LXQXQeQcH0j//Ke3tha4kHQgBPMdM+uILP0EMyKOdHR8EBwehKwmPEMBz7tyRVldDVwF018aG9I9/cEdACOAZ4+NMDEM8Njakjz+WnjwJXUk4hAD+a3ycmZWIz+am9Pe/S6VS6ErCIAQgiQBA3HZ3fRAsLISupPcIARAAgPy8mM8+838XYhoUQQhErLJJDAEAPDU+Lt265SeVxbAXwQuhC0AYq6t+FBBbRQLP29z0Q0hffVX65S+lixell14KXVV3EAIR2dvzewQXiwwBBRqxuSl99ZX09dfShQvSG2/4f/7P/0gv5OTqmZP/jDiUy35J5/V135G1v+8v7Pv70o9+JP3gB9LLL0vf/76/jT089O/v7PihcDEPgwPaYSatrPhHxY9/LP30p9KlSz4UsooQSKnjY99Us7Hhh66VSj4AYuqwAtJse9vPqbl/X/rJT6Rf/1p6/XXJudCVNYcQSJG9Pf9NY2nJD1VjSzwgG5aW/KOvz4fBz38ufS8jw24IgYAq3/aXl/0j1skqQF6USn7drdFRHwa/+IX04ouhqzobIRDA6qq/hVxcZKcjII+ePJG++cYPN/3DH3y/QVrvDBoKAefcoKTKDp0FM/ug3WNaOWeWHR35Jp6JCUbmALE4OJCGh/2Xvt//XvrZz9IXBnVDoHKxNrObyfOCc+5DM7ve6jGtnDNLzPzonVLpacfu8rIPAgDx2drym9m89JKfc/Dmm9K5c+noRG7kTuC6mV2pPDGzonPuapvHtHLO4Mz8iIDNTd9pe3z8dJjmyQfNPABOOjjwrQETE36I6Ztv+pFFIQPhzBBwzvVJulzjrZJz7qqZ3W72GElDzZ6z18z8/6ytrWe/zW9scHEH0Bnb237j+7Exf4fw+us+EN54w8/76ZV6dwIFSbXGrKwl77VyzFoL52ybmW+OqUyuqv7WXuv5aePx03D7BiBfDg+l+Xn/kPxyFW+8IfX3+39/+WUfFN24/tQLgX497bytVpLU1+IxTZ8z6UMYlKSLFy+eXfEpnPNDtV58UXrllZZOAQC5k7J+6trM7IaZDZjZwIULF0KXAwC50UgI9Nd47bS7gEaPaeWcAIAOqxcCQ6p9ce6XNNLiMa2cEwDQBWeGgJmVJBWTET/V+k4bxVPvmFbOCQDojkaag95X0ikrSc65y5JuVz0vOOc+OnFRP/OYBt4HAPRA3cliZnbDOTeYjPHvk1/ioXpmb0HSVfnmnFIjxzRwTgBADzS0dpCZ3TjjvduSzjVzTCPvAwC6LxNDRAEA3UEIAEDEnJmFrqEpzrlHkqZD15Ezr0l6HLqICPG5hxHr5/6mmT032zZzIYDOc84NmdlA6Dpiw+ceBp/7s2gOAoCIEQIAEDFCAJLEcN0w+NzD4HOvQp8AAESMOwEAiBghAAARa2jZCACdk+yUV9ldr2BmH4SsJwbJOmXXJb0nv8bZNUkllq/hTgDoqUoAmNlNM7sp6aZz7sPQdUWgT36xy+HkcZ4A8LgTwDP4xtR1183sSuWJmRWTzxxdVv254ynuBHAS35i6JNlz43KNt0oEAULhTgDP4RtT1xSU7LlxwlryHrqoav+SkqTL9MV4hADQO/162iFcraTa+26jc0Yk3/wmSc65NefcLTN7J2xZ4RECeA7fmJA3lYt/1fMR59yAc65w8r3YEAI4iW9M3dVf4zXuAsIoym+NG3WfFx3DeIaZFau/GZnZiKQB5xxt1u0bUu0Lfr+S8EXnOecKzrn10HWkFXcCOZU06fylwR+/XueWmG9MHWBmJedc0TnXZ2bVHcR9yV7d6J73arxWkBT9504I5FRyUWnqD3jybX/YzM51pypIel/SoKQPJMk5d1lciLoqmYvxzKgs59w1SX+NvT9AYhVRVElC4NrJjuDkVvoKf2E6I5k1XFQyJ4OO995IPncpaZLjc/cIATzDOTdYPTks+cb0jpldD1gWgC4hBPAcvjEB8SAEACBiDBEFgIgRAgAQMUIAACJGCABAxAgBAIgYIQAAESMEACBi/w8rWFEhhB854AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.neighbors import KernelDensity\n",
    "\n",
    "def compute_density(Z,A,show_graphs=False,Z_test=[]):\n",
    "\n",
    "    bandwidth = np.sqrt(np.median(np.abs(Z)))\n",
    "\n",
    "    kde_0 = KernelDensity(kernel='linear', bandwidth=bandwidth).fit(Z[A==0][:, np.newaxis])\n",
    "    kde_1 = KernelDensity(kernel='linear', bandwidth=bandwidth).fit(Z[A==1][:, np.newaxis])\n",
    "    \n",
    "    if show_graphs:\n",
    "        plt.clf()\n",
    "        plt.hist(Z[A==0], fc='#AAAAFF', density=True)\n",
    "        plt.show()\n",
    "\n",
    "        X_plot = np.linspace(min(Z[A==0])-1, max(Z[A==0])+1, 1000)[:, np.newaxis]\n",
    "        log_dens = kde_0.score_samples(X_plot)\n",
    "\n",
    "        plt.clf()\n",
    "        plt.fill(X_plot[:, 0], np.exp(log_dens), fc='#AAAAFF')\n",
    "        plt.show()\n",
    "\n",
    "    log_dens_0 = np.exp(np.squeeze(kde_0.score_samples(Z[:, np.newaxis])))\n",
    "    log_dens_1 = np.exp(np.squeeze(kde_1.score_samples(Z[:, np.newaxis])))\n",
    "    p_0 = np.sum(A==0) / A.shape[0]\n",
    "    p_1 = 1 - p_0\n",
    "\n",
    "    # p(A=1|y) = p(y|A=1)p(A=1) / (p(y|A=1)p(A=1) + p(y|A=0)p(A=0))\n",
    "    p_success = (log_dens_1*p_1) / (log_dens_1*p_1 + log_dens_0*p_0)\n",
    "\n",
    "    p_success_test = []\n",
    "    if len(Z_test) > 0:\n",
    "        log_dens_0_test = np.exp(np.squeeze(kde_0.score_samples(Y_test[:, np.newaxis])))\n",
    "        log_dens_1_test = np.exp(np.squeeze(kde_1.score_samples(Y_test[:, np.newaxis])))\n",
    "        p_success_test = (log_dens_1_test*p_1) / (log_dens_1_test*p_1 + log_dens_0_test*p_0)\n",
    "    \n",
    "    return p_success, p_success_test\n",
    "\n",
    "p_success, p_success_test = compute_density(Y,A,True,Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementation of a fairness-unaware baseline algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step size\n",
    "lr = 0.01\n",
    "\n",
    "# inner epochs to fit adversary\n",
    "dis_steps = 1\n",
    "\n",
    "# inner epochs to fit loss\n",
    "loss_steps = 1\n",
    "\n",
    "batch_size = 6000\n",
    "\n",
    "# utility loss\n",
    "cost_pred = torch.nn.MSELoss()\n",
    "in_shape = X.shape[1]\n",
    "out_shape = 1\n",
    "\n",
    "model_type = \"deep_model\"\n",
    "\n",
    "# equalized odds penalty\n",
    "mu = 0\n",
    "second_moment_scaling = 0\n",
    "\n",
    "# total number of epochs\n",
    "epochs = 500\n",
    "\n",
    "base_reg = fair_dummies_learning.EquiRegLearner(lr=lr,\n",
    "                                                pretrain_pred_epochs=0,\n",
    "                                                pretrain_dis_epochs=0,\n",
    "                                                epochs=epochs,\n",
    "                                                loss_steps=loss_steps,\n",
    "                                                dis_steps=dis_steps,\n",
    "                                                cost_pred=cost_pred,\n",
    "                                                in_shape=in_shape,\n",
    "                                                batch_size=batch_size,\n",
    "                                                model_type=model_type,\n",
    "                                                lambda_vec=mu,\n",
    "                                                second_moment_scaling=second_moment_scaling,\n",
    "                                                out_shape=out_shape)\n",
    "\n",
    "init_seed(seed)\n",
    "\n",
    "input_data_train = np.concatenate((A[:,np.newaxis],X),1)\n",
    "base_reg.fit(input_data_train, Y)\n",
    "\n",
    "input_data_cal = np.concatenate((A_cal[:,np.newaxis],X_cal),1)\n",
    "Yhat_out_cal = base_reg.predict(input_data_cal)\n",
    "\n",
    "input_data_test = np.concatenate((A_test[:,np.newaxis],X_test),1)\n",
    "Yhat_out_test = Yhat_test = base_reg.predict(input_data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baseline (All): Test Error = 1.0977825652758708\n",
      "Baseline (A=0): Test Error = 1.020181728514243\n",
      "Baseline (A=1): Test Error = 1.659159533443617\n"
     ]
    }
   ],
   "source": [
    "# bhat, res, rank, s = np.linalg.lstsq(X, Y)\n",
    "\n",
    "# Yhat_out_cal = np.dot(X_cal,bhat)\n",
    "# Yhat_out_test = np.dot(X_test,bhat)\n",
    "\n",
    "print(\"Baseline (All): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test - Y_test)**2))))\n",
    "print(\"Baseline (A=0): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test[A_test==0] - Y_test[A_test==0])**2))))\n",
    "print(\"Baseline (A=1): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test[A_test==1] - Y_test[A_test==1])**2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init Loss = 4.7233157\n",
      "Final Loss = 0.95865446\n",
      "Fair dummies test (regression score), p-value: 0.000999000999000999\n"
     ]
    },
    {
     "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": [
    "plot_groups_pointwise(x_axis_0_test,\n",
    "                      x_axis_1_test,\n",
    "                      A_test,\n",
    "                      Y_test,\n",
    "                      Yhat_out_test,\n",
    "                      y_u=None,\n",
    "                      y_l=None,\n",
    "                      point_color='r.',\n",
    "                      shade=None,\n",
    "                      filename_0=\"supp_synth_no_use_A_baseline_0.png\",\n",
    "                      filename_1=\"supp_synth_no_use_A_baseline_1.png\",\n",
    "                      save_figures=save_figures)\n",
    "\n",
    "p_val_base = utility_functions.fair_dummies_test_regression(Yhat_out_cal,\n",
    "                                            A_cal,\n",
    "                                            Y_cal,\n",
    "                                            Yhat_out_test,\n",
    "                                            A_test,\n",
    "                                            Y_test,\n",
    "                                            num_reps = 1,\n",
    "                                            num_p_val_rep=1000,\n",
    "                                            reg_func_name=\"Net\",\n",
    "                                            lr = 0.01,\n",
    "                                            return_vec=True)\n",
    "\n",
    "\n",
    "plt.clf()\n",
    "x, bins, p=plt.hist(x=p_val_base, bins=30, color='salmon', alpha=0.7, range=(0, 1), density=True, ec='red', align='left', label=u'Baseline')\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.xlabel('Value')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Fair Dummies Test')\n",
    "for item in p:\n",
    "    item.set_height(item.get_height()/sum(x))\n",
    "plt.ylim(0, 1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step size\n",
    "lr = 0.01\n",
    "\n",
    "# inner epochs to fit adversary\n",
    "dis_steps = 40\n",
    "\n",
    "# inner epochs to fit loss\n",
    "loss_steps = 40\n",
    "\n",
    "batch_size = 6000\n",
    "\n",
    "# utility loss\n",
    "cost_pred = torch.nn.MSELoss()\n",
    "in_shape = X.shape[1]\n",
    "out_shape = 1\n",
    "\n",
    "model_type = \"deep_model\"\n",
    "\n",
    "# equalized odds penalty\n",
    "mu = 0.99\n",
    "second_moment_scaling = 0\n",
    "\n",
    "# total number of epochs\n",
    "epochs = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "fair_reg = fair_dummies_learning.EquiRegLearner(lr=lr,\n",
    "                                                pretrain_pred_epochs=0,\n",
    "                                                pretrain_dis_epochs=0,\n",
    "                                                epochs=epochs,\n",
    "                                                loss_steps=loss_steps,\n",
    "                                                dis_steps=dis_steps,\n",
    "                                                cost_pred=cost_pred,\n",
    "                                                in_shape=in_shape,\n",
    "                                                batch_size=batch_size,\n",
    "                                                model_type=model_type,\n",
    "                                                lambda_vec=mu,\n",
    "                                                second_moment_scaling=second_moment_scaling,\n",
    "                                                out_shape=out_shape)\n",
    "\n",
    "init_seed(seed)\n",
    "\n",
    "input_data_train = np.concatenate((A[:,np.newaxis],X),1)\n",
    "fair_reg.fit(input_data_train, Y)\n",
    "\n",
    "input_data_cal = np.concatenate((A_cal[:,np.newaxis],X_cal),1)\n",
    "Yhat_out_cal = fair_reg.predict(input_data_cal)\n",
    "\n",
    "input_data_test = np.concatenate((A_test[:,np.newaxis],X_test),1)\n",
    "Yhat_out_test = Yhat_test = fair_reg.predict(input_data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fair Dummies (All): Test Error = 1.2973786262064038\n",
      "Fair Dummies (A=0): Test Error = 1.3032914397172939\n",
      "Fair Dummies (A=1): Test Error = 1.2403179459379687\n"
     ]
    }
   ],
   "source": [
    "print(\"Fair Dummies (All): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test - Y_test)**2))))\n",
    "print(\"Fair Dummies (A=0): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test[A_test==0] - Y_test[A_test==0])**2))))\n",
    "print(\"Fair Dummies (A=1): Test Error = \" + str(np.sqrt(np.mean((Yhat_out_test[A_test==1] - Y_test[A_test==1])**2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init Loss = 4.146206\n",
      "Final Loss = 1.115266\n",
      "Fair dummies test (regression score), p-value: 0.6293706293706294\n"
     ]
    },
    {
     "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": [
    "plot_groups_pointwise(x_axis_0_test,\n",
    "                      x_axis_1_test,\n",
    "                      A_test,\n",
    "                      Y_test,\n",
    "                      Yhat_out_test,\n",
    "                      y_u=None,\n",
    "                      y_l=None,\n",
    "                      point_color='b.',\n",
    "                      shade=None,\n",
    "                      filename_0=\"supp_synth_no_use_A_equi_0.png\",\n",
    "                      filename_1=\"supp_synth_no_use_A_equi_1.png\",\n",
    "                      save_figures=save_figures)\n",
    "\n",
    "\n",
    "p_val_equi = utility_functions.fair_dummies_test_regression(Yhat_out_cal,\n",
    "                                                            A_cal,\n",
    "                                                            Y_cal,\n",
    "                                                            Yhat_out_test,\n",
    "                                                            A_test,\n",
    "                                                            Y_test,\n",
    "                                                            num_reps = 1,\n",
    "                                                            num_p_val_rep=1000,\n",
    "                                                            reg_func_name=\"Net\",\n",
    "                                                            lr = 0.01,\n",
    "                                                            return_vec=True)\n",
    "\n",
    "\n",
    "plt.clf()\n",
    "x_equi, bins_equi, p_equi=plt.hist(x=p_val_equi, bins=30, color='royalblue', alpha=0.7, range=(0, 1), density=True, ec='blue', align='left', label=u'Equitable model')\n",
    "x_base, bins_base, p_base=plt.hist(x=p_val_base, bins=30, color='salmon', alpha=0.7, range=(0, 1), density=True, ec='red', align='left', label=u'Baseline model')\n",
    "\n",
    "plt.grid(axis='y', alpha=0.75)\n",
    "plt.xlabel('p-value')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Fair Dummies Test')\n",
    "for item in p_equi:\n",
    "    item.set_height(item.get_height()/sum(x_equi))\n",
    "for item in p_base:\n",
    "    item.set_height(item.get_height()/sum(x_base))\n",
    "\n",
    "plt.ylim(0, 1)\n",
    "plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left') \n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}