benchmark

benchmark.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gif\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pylab as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.pipeline import Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_boston"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = load_boston(return_X_y=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Copyright (c) Microsoft Corporation and contributors.\n",
    "# Licensed under the MIT License.\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.utils import check_array\n",
    "from sklearn.utils.validation import check_is_fitted\n",
    "\n",
    "\n",
    "class CorrelationRemover(BaseEstimator, TransformerMixin):\n",
    "    r\"\"\"\n",
    "    A component that filters out sensitive correlations in a dataset.\n",
    "\n",
    "    CorrelationRemover applies a linear transformation to the non-sensitive feature columns in order\n",
    "    to remove their correlation with the sensitive feature columns while retaining as much information\n",
    "    as possible (as measured by the least-squares error).\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    sensitive_feature_ids : list of columns to filter out this can be a sequence of either int\n",
    "      ,in the case of numpy, or string, in the case of pandas.\n",
    "    alpha : parameter to control how much to filter, for alpha=1.0 we filter out\n",
    "      all information while for alpha=0.0 we don't apply any.\n",
    "    center : setting to tell if this preprocessing step should center the data for\n",
    "      numerical stability\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "\n",
    "    This method will change the original dataset by removing all correlation with sensitive values.\n",
    "    To describe that mathematically, let's assume in the original dataset :math:`X` we've got a set of\n",
    "    sensitive atttributes :math:`S` and a set of non-sensitive attributes :math:`Z`. Mathmatically this method\n",
    "    will be solving the following problem.\n",
    "\n",
    "    .. math::\n",
    "\n",
    "       \\min _{\\mathbf{z}_{1}, \\ldots, \\mathbf{z}_{n}} \\sum_{i=1}^{n}\\left\\|\\mathbf{z}_{i}-\\mathbf{x}_{i}\\right\\|^{2} \\\\\n",
    "       \\text{subject to} \\\\\n",
    "       \\frac{1}{n} \\sum_{i=1}^{n} \\mathbf{z}_{i}\\left(\\mathbf{s}_{i}-\\overline{\\mathbf{s}}\\right)^{T}=\\mathbf{0}\n",
    "\n",
    "\n",
    "    The solution to this problem is found by centering sensitive features, fitting a\n",
    "    linear regression model to the non-sensitive features and reporting the residual.\n",
    "\n",
    "    The columns in :math:`S` will be dropped but the hyper parameter :math:`\\alpha` does allow you to tweak\n",
    "    the amount of filtering that gets applied.\n",
    "\n",
    "    .. math::\n",
    "\n",
    "      X_{\\text{tfm}} = \\alpha X_{\\text{filtered}} + (1-\\alpha) X_{\\text{orig}}\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, *, sensitive_feature_ids=None, alpha=1.0, center=True):\n",
    "        self.columns = sensitive_feature_ids\n",
    "        self.alpha = alpha\n",
    "        self.center = center\n",
    "\n",
    "    def _split_X(self, X):\n",
    "        \"\"\"Split up X into a sensitive and non-sensitive group.\"\"\"\n",
    "        if isinstance(X, pd.DataFrame):\n",
    "            sens_df = X[self.columns]\n",
    "            non_sens_df = X[[c for c in X.columns if c not in self.columns]]\n",
    "            return sens_df.values, non_sens_df.values\n",
    "        non_sensitive = [i for i in range(X.shape[1]) if i not in self.columns]\n",
    "        return X[:, non_sensitive], X[:, self.columns]\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        \"\"\"Learn the projection required to make the dataset orthogonal to sensitive columns.\"\"\"\n",
    "        X = check_array(X, estimator=self,  force_all_finite=True)\n",
    "        if (not self.columns) or (len(self.columns) == 0):\n",
    "                raise ValueError(f\"No sensitive feature ids were passed to this object, got {self.columns}\")\n",
    "        X_use, X_sensitive = self._split_X(X)\n",
    "        self.sensitive_mean_ = X_sensitive.mean()\n",
    "        X_s_center = X_sensitive - self.sensitive_mean_\n",
    "        self.beta_, _, _, _ = np.linalg.lstsq(X_s_center, X_use, rcond=None)\n",
    "        self.X_shape_ = X.shape\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \"\"\"Transform X by applying the information filter.\"\"\"\n",
    "        X = check_array(X, estimator=self, dtype=None, force_all_finite=True)\n",
    "        check_is_fitted(self, [\"beta_\", \"X_shape_\", \"sensitive_mean_\"])\n",
    "        if self.X_shape_[1] != X.shape[1]:\n",
    "            raise ValueError(f\"The trained data has {self.X_shape_[1]} while this dataset has {X.shape[1]}.\")\n",
    "        X_use, X_sensitive = self._split_X(X)\n",
    "        X_s_center = X_sensitive - self.sensitive_mean_\n",
    "        X_filtered = X_use - X_s_center.dot(self.beta_)\n",
    "        X_use = np.atleast_2d(X_use)\n",
    "        X_filtered = np.atleast_2d(X_filtered)\n",
    "        return self.alpha * X_filtered + (1 - self.alpha) * X_use\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.utils import check_array\n",
    "from sklearn.utils.validation import check_is_fitted\n",
    "\n",
    "from sklego.common import as_list\n",
    "\n",
    "\n",
    "def scalar_projection(vec, unto):\n",
    "    return vec.dot(unto) / unto.dot(unto)\n",
    "\n",
    "\n",
    "def vector_projection(vec, unto):\n",
    "    return scalar_projection(vec, unto) * unto\n",
    "\n",
    "\n",
    "class InformationFilter(BaseEstimator, TransformerMixin):\n",
    "    \"\"\"\n",
    "    The `InformationFilter` uses a variant of the gram smidt process\n",
    "    to filter information out of the dataset. This can be useful if you\n",
    "    want to filter information out of a dataset because of fairness.\n",
    "    To explain how it works: given a training matrix :math:`X` that contains\n",
    "    columns :math:`x_1, ..., x_k`. If we assume columns :math:`x_1` and :math:`x_2`\n",
    "    to be the sensitive columns then the information-filter will\n",
    "    remove information by applying these transformations;\n",
    "    .. math::\n",
    "       \\\\begin{split}\n",
    "       v_1 & = x_1 \\\\\\\\\n",
    "       v_2 & = x_2 - \\\\frac{x_2 v_1}{v_1 v_1}\\\\\\\\\n",
    "       v_3 & = x_3 - \\\\frac{x_k v_1}{v_1 v_1} - \\\\frac{x_2 v_2}{v_2 v_2}\\\\\\\\\n",
    "       ... \\\\\\\\\n",
    "       v_k & = x_k - \\\\frac{x_k v_1}{v_1 v_1} - \\\\frac{x_2 v_2}{v_2 v_2}\n",
    "       \\\\end{split}\n",
    "    Concatenating our vectors (but removing the sensitive ones) gives us\n",
    "    a new training matrix :math:`X_{fair} =  [v_3, ..., v_k]`.\n",
    "    :param columns: the columns to filter out this can be a sequence of either int\n",
    "                    (in the case of numpy) or string (in the case of pandas).\n",
    "    :param alpha: parameter to control how much to filter, for alpha=1 we filter out\n",
    "                  all information while for alpha=0 we don't apply any.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, columns, alpha=1):\n",
    "        self.columns = columns\n",
    "        self.alpha = alpha\n",
    "\n",
    "    def _check_coltype(self, X):\n",
    "        for col in as_list(self.columns):\n",
    "            if isinstance(col, str):\n",
    "                if isinstance(X, np.ndarray):\n",
    "                    raise ValueError(\n",
    "                        f\"column {col} is a string but datatype receive is numpy.\"\n",
    "                    )\n",
    "                if isinstance(X, pd.DataFrame):\n",
    "                    if col not in X.columns:\n",
    "                        raise ValueError(f\"column {col} is not in {X.columns}\")\n",
    "            if isinstance(col, int):\n",
    "                if col not in range(np.atleast_2d(np.array(X)).shape[1]):\n",
    "                    raise ValueError(\n",
    "                        f\"column {col} is out of bounds for input shape {X.shape}\"\n",
    "                    )\n",
    "\n",
    "    def _col_idx(self, X, name):\n",
    "        if isinstance(name, str):\n",
    "            if isinstance(X, np.ndarray):\n",
    "                raise ValueError(\n",
    "                    \"You cannot have a column of type string on a numpy input matrix.\"\n",
    "                )\n",
    "            return {name: i for i, name in enumerate(X.columns)}[name]\n",
    "        return name\n",
    "\n",
    "    def _make_v_vectors(self, X, col_ids):\n",
    "        vs = np.zeros((X.shape[0], len(col_ids)))\n",
    "        for i, c in enumerate(col_ids):\n",
    "            vs[:, i] = X[:, col_ids[i]]\n",
    "            for j in range(0, i):\n",
    "                vs[:, i] = vs[:, i] - vector_projection(vs[:, i], vs[:, j])\n",
    "        return vs\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        \"\"\"Learn the projection required to make the dataset orthogonal to sensitive columns.\"\"\"\n",
    "        self._check_coltype(X)\n",
    "        self.col_ids_ = [\n",
    "            v if isinstance(v, int) else self._col_idx(X, v)\n",
    "            for v in as_list(self.columns)\n",
    "        ]\n",
    "        X = check_array(X, estimator=self)\n",
    "        X_fair = X.copy()\n",
    "        v_vectors = self._make_v_vectors(X, self.col_ids_)\n",
    "        # gram smidt process but only on sensitive attributes\n",
    "        for i, col in enumerate(X_fair.T):\n",
    "            for v in v_vectors.T:\n",
    "                X_fair[:, i] = X_fair[:, i] - vector_projection(X_fair[:, i], v)\n",
    "        # we want to learn matrix P: X P = X_fair\n",
    "        # this means we first need to create X_fair in order to learn P\n",
    "        self.projection_, resid, rank, s = np.linalg.lstsq(X, X_fair, rcond=None)\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        \"\"\"Transforms X by applying the information filter.\"\"\"\n",
    "        check_is_fitted(self, [\"projection_\", \"col_ids_\"])\n",
    "        self._check_coltype(X)\n",
    "        X = check_array(X, estimator=self)\n",
    "        # apply the projection and remove the column we won't need\n",
    "        X_fair = X @ self.projection_\n",
    "        X_removed = np.delete(X_fair, self.col_ids_, axis=1)\n",
    "        X_orig = np.delete(X, self.col_ids_, axis=1)\n",
    "        return self.alpha * np.atleast_2d(X_removed) + (1 - self.alpha) * np.atleast_2d(\n",
    "            X_orig\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "@gif.frame\n",
    "def frame(alpha, filter_method):\n",
    "    remover = filter_method\n",
    "    pipe = Pipeline([\n",
    "        ('filter', remover),\n",
    "        ('mod', LinearRegression())\n",
    "    ])\n",
    "    pipe.fit(X, y)\n",
    "    pred = pipe.predict(X)\n",
    "    plt.figure(figsize=(12, 4))\n",
    "\n",
    "    plt.subplot(131)\n",
    "    plt.scatter(pred, y)\n",
    "    plt.title(f'pred vs. actual alpha={alpha}')\n",
    "\n",
    "    plt.subplot(132)\n",
    "    c11_upper, c11_lower = pred[X[:, 11] > X[:, 11].mean()], pred[X[:, 11] <= X[:, 11].mean()]\n",
    "    plt.hist(c11_lower, bins=30, density=True, alpha=0.5, label='lower')\n",
    "    plt.hist(c11_upper, bins=30, density=True, alpha=0.5, label='upper')\n",
    "    plt.legend()\n",
    "    plt.title('predictions split on col B')\n",
    "\n",
    "    plt.subplot(133)\n",
    "    c12_upper, c12_lower = pred[X[:, 12] > X[:, 12].mean()], pred[X[:, 12] <= X[:, 12].mean()]\n",
    "    plt.hist(c12_lower, bins=30, density=True, alpha=0.5, label='lower')\n",
    "    plt.hist(c12_upper, bins=30, density=True, alpha=0.5, label='upper')\n",
    "    plt.legend()\n",
    "    plt.title('predictions split on col LSTAT')\n",
    "    data.append([filter_method.__class__.__name__, \n",
    "                 alpha, \n",
    "                 c11_upper.mean() - c11_lower.mean(), \n",
    "                 c12_upper.mean() - c12_lower.mean()]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "frames = [frame(alpha=np.round(i, 2), filter_method=InformationFilter(columns=[11, 12], alpha=np.round(i, 2))) \n",
    "          for i in np.linspace(-3.0, 2.0, 51)]\n",
    "gif.save(frames, \"boston_filter.gif\", duration=400)\n",
    "frames = [frame(alpha=np.round(i, 2), filter_method=CorrelationRemover(sensitive_feature_ids=[11, 12], alpha=np.round(i, 2))) \n",
    "          for i in np.linspace(-3.0, 2.0, 51)]\n",
    "gif.save(frames, \"boston_corr.gif\", duration=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from IPython.display import Image\n",
    "# Image(\"boston_filter.gif\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from IPython.display import Image\n",
    "# Image(\"boston_corr.gif\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotnine as p9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "run_df = pd.DataFrame(data, columns=['method', 'alpha', 'c11_diff', 'c12_diff'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (322863985)>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(p9.ggplot() + \n",
    "  p9.geom_line(data=run_df, mapping=p9.aes('alpha','c11_diff', color='method')) + \n",
    "  p9.geom_point(data=run_df, mapping=p9.aes('alpha','c12_diff', color='method')))"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}