Sensitivity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sensitivity\n",
    "\n",
    "Material courtesy of Joseph Near, University of Vermont"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we mentioned when we dicussed the Laplace mechanism, the amount of noise necessary to ensure differential privacy for a given query depends on the *sensitivity* of the query. Roughly speaking, the sensitivity of a function reflects the amount the function's output will change when its input changes. Recall that the Laplace mechanism defines a mechanism $F(x)$ as follows:\n",
    "\n",
    "\\begin{align}\n",
    "F(x) = f(x) + \\textsf{Lap}(\\frac{s}{\\epsilon})\n",
    "\\end{align}\n",
    "\n",
    "where $f(x)$ is a deterministic function (the query), $\\epsilon$ is the privacy parameter, and $s$ is the sensitivity of $f$.\n",
    "\n",
    "For a function $f : \\mathcal{D} \\rightarrow \\mathbb{R}$ mapping datasets ($\\mathcal{D}$) to real numbers, the *global sensitivity* of $f$ is defined as follows:\n",
    "\n",
    "\\begin{align}\n",
    "GS(f) = \\max_{x, y: d(x,x') <= 1} |f(x) - f(x')|\n",
    "\\end{align}\n",
    "\n",
    "Here, $d(x, x')$ represents the *distance* between two datasets $x$ and $x'$, and we say that two datasets are *neighbors* if their distance is 1 or less. How this distance is defined has a huge effect on the definition of privacy we obtain, and we'll discuss the distance metric on datasets in detail later on.\n",
    "\n",
    "The definition of global sensitivity says that for *any two* neighboring datasets $x$ and $x'$, the difference between $f(x)$ and $f(x')$ is at most $GS(f)$. This measure of sensitivity is called \"global\" because it is independent of the actual dataset being queried (it holds for *any* choice of neighboring $x$ and $x'$). \n",
    "\n",
    "(*Recall*: Another measure of sensitivity, called *local sensitivity*, fixes one of the datasets to be the one being queried. For now, when we say \"sensitivity,\" we mean global sensitivity.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating Sensitivity\n",
    "\n",
    "How do we determine the sensitivity of a particular function of interest? For some simple functions on real numbers, the answer is obvious.\n",
    "\n",
    "- The global sensitivity of $f(x) = x$ is 1, since changing $x$ by 1 changes $f(x)$ by 1\n",
    "- The global sensitivity of $f(x) = x+x$ is 2, since changing $x$ by 1 changes $f(x)$ by 2\n",
    "- The global sensitivity of $f(x) = 5*x$ is 5, since changing $x$ by 1 changes $f(x)$ by 5\n",
    "- The global sensitivity of $f(x) = x*x$ is unbounded, since the change in $f(x)$ depends on the value of $x$\n",
    "\n",
    "For functions that map datasets to real numbers, we can perform a similar analysis. We will consider the functions which represent common aggregate database queries: counts, sums, and averages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')\n",
    "\n",
    "adult = pd.read_csv(\"adult_with_pii.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting Queries\n",
    "\n",
    "Counting queries (`COUNT` in SQL) count the number of rows in the dataset which satisfy a specific property. As a rule of thumb, **counting queries always have a sensitivity of 1**. This is because adding a row to the dataset can increase the output of the query by at most 1: either the new row has the desired property, and the count increases by 1, or it does not, and the count stays the same (the count may correspondingly decrease when a row is removed)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"How many people are in the dataset?\"** (sensitivity: 1 - counting rows with a property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32561"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"How many people have an educational status above 10?\"** (sensitivity: 1 - counting rows with a property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10516"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Education-Num'] > 10].shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"How many people have an educational status equal to or below 10?\"** (sensitivity: 1 - counting rows with a property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22045"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Education-Num'] <= 10].shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"How many people are named Joe Near?\"** (sensitivity: 1 - counting rows with a property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Name'] == 'Joe Near'].shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summation Queries\n",
    "\n",
    "Summation queries (`SUM` in SQL) sum up the *attribute values* of dataset rows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"What is the sum of the ages of people with an educational status above 10?\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "422876"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Education-Num'] > 10]['Age'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sensitivity for these queries is not as simple as it is for counting queries. Adding a new row to the dataset will increase the result of our example query by the *age of the new person*. That means the sensitivity of the query depends on the *contents* of the row we add.\n",
    "\n",
    "We'd like to come up with a concrete number to represent the sensitivity of the query. Unfortunately, no number really exists. We could claim, for example, that the sensitivity is 125 - but it may turn out that the row we add to the database corresponds to a person who is over 125 years old, which would violate our claim. For any number we come up with, it's possible for the added row to violate our claim.\n",
    "\n",
    "You might (rightly) be skeptical of this point. Say we claim the sensitivity is 1000 - it's very unlikely that we'll find a person who is 1000 years old to violate this claim. In this specific domain - ages - there's a very reasonable upper bound on how old someone can be. The oldest person ever lived to be [122 years old](https://en.wikipedia.org/wiki/List_of_the_verified_oldest_people), so an upper bound of 125 seems reasonable.\n",
    "\n",
    "But this is not a *proof* that nobody will ever live to be 126. And in other domains (e.g. income), it can be much harder to come up with a reasonable upper bound.\n",
    "\n",
    "As a rule of thumb, summation queries have **unbounded sensitivity** when no lower and upper bounds exist on the value of the attribute being summed. When lower and upper bounds do exist, the sensitivity of a summation query is equal to the **difference between them**. In the next section, we will see a technique called *clipping* for enforcing bounds when none exist, so that summation queries with unbounded sensitivity can be converted into queries with bounded sensitivity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Average Queries\n",
    "\n",
    "Average queries (`AVG` in SQL) calculate the mean of attribute values in a particular column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example: \"What is the average age of people with an educational status above 10?\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.21262837580829"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Education-Num'] > 10]['Age'].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The easiest way to answer an average query with differential privacy is by re-phrasing it as two queries: a summation query divided by a counting query. For the above example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.21262837580829"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult[adult['Education-Num'] > 10]['Age'].sum() / adult[adult['Education-Num'] > 10]['Age'].shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sensitivities of both queries can be calculated as described above. Noisy answers for each can be calculated (e.g. using the Laplace mechanism) and the noisy answers can be divided to obtain a differentially private mean. The total privacy cost of both queries can be calculated by sequential composition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clipping\n",
    "\n",
    "Queries with unbounded sensitivity cannot be directly answered with differential privacy using the Laplace mechanism. Fortunately, we can often transform such queries into equivalent queries with *bounded* sensitivity, via a process called *clipping*.\n",
    "\n",
    "The basic idea beind clipping is to *enforce* upper and lower bounds on attribute values. For example, ages above 125 can be \"clipped\" to exactly 125. After clipping has been performed, we are *guaranteed* that all ages will be 125 or below. As a result, the senstivity of a summation query on clipped data is equal to the difference between the upper and lower bounds used in clipping: $upper - lower$. For example, the following query has a sensitivity of 125:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1256257"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adult['Age'].clip(lower=0, upper=125).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The primary challenge in performing clipping is to determine the upper and lower bounds. For ages, this is simple - nobody can have an age less than 0, and probably nobody will be older than 125. In other domains, as mentioned earlier, it's much more difficult.\n",
    "\n",
    "Furthermore, there is a tradeoff between the amount of information lost in clipping and the amount of noise needed to ensure differential privacy. When the upper and lower clipping bounds are closer together, then the sensitivity is lower, and less noise is needed to ensure differential privacy. However, aggressive clipping often removes a lot of information from the data; this information loss tends to cause a *loss* of accuracy which outweighs the improvement in noise resulting from smaller sensitivity. \n",
    "\n",
    "As a rule of thumb, **try to set the clipping bounds to include 100% of the dataset**, or get as close as possible. This is harder in some domains (e.g. graph queries, which we will study later) than others.\n",
    "\n",
    "It's tempting to determine the clipping bounds by looking at the data. For example, we can look at the histogram of ages in our dataset to determine an appropriate upper bound:"
   ]
  },
  {
   "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"
    }
   ],
   "source": [
    "plt.hist(adult['Age']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's clear from this histogram that nobody in this particular dataset is over 90, so an upper bound of 90 would suffice.\n",
    "\n",
    "However, it's important to note that **this approach does not satisfy differential privacy**. If we pick our clipping bounds by looking at the data, then the bounds themselves might reveal something about the data.\n",
    "\n",
    "Typically, clipping bounds are decided either by using a property of the dataset that can be known without looking at the data (e.g. that the dataset contains ages, which are likely to lie between 0 and 125), or by performing differentially private queries to evaluate different choices for the clipping bounds.\n",
    "\n",
    "To use the second approach, we typically set the lower bound to 0 and slowly increase the upper bound until the query's output stops changing (meaning we haven't included any new data by increasing the bound). For example, let's try computing the sum of ages for clipping bounds from 0 to 100, using the Laplace mechanism for each one to ensure differential privacy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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"
    }
   ],
   "source": [
    "def laplace_mech(v, sensitivity, epsilon):\n",
    "    return v + np.random.laplace(loc=0, scale=sensitivity/epsilon)\n",
    "\n",
    "epsilon_i = .01\n",
    "plt.plot([laplace_mech(adult['Age'].clip(lower=0, upper=i).sum(), i, epsilon_i) for i in range(100)]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total privacy cost for building this plot is $\\epsilon = 1$ by sequential composition, since we do 100 queries each with $\\epsilon_i = 0.01$. It's clear that the results level off around a value of `upper = 80`, so this is a good choice for the clipping bound.\n",
    "\n",
    "We can use the same approach for data attributes from any numerical domain, but it helps to know something about the scale of the data in advance. For example, trying clipping values between 0 and 100 for yearly incomes would not work very well - we wouldn't even come close to finding a reasonable upper bound."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}