solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Representing and comparing probabilities with kernels - practical\n",
    "\n",
    "Notebook prepared by [Heiko Strathmann](http://herrstrathmann.de/) with additional code by [Dougal Sutherland](http://www.gatsby.ucl.ac.uk/~dougals/) and Kacper Chwialkowski.\n",
    "Feel free to email any questions you have.\n",
    "\n",
    "In this notebook, we will cover implementation details and applications for three types of kernel hypothesis tests:\n",
    "    \n",
    "* Two-sampling testing using the Maximum Mean Discrepancy (MMD)\n",
    "* Independence testing using the Hilbert-Schmidt Independence Criterion (HSIC)\n",
    "* Goodness-of-fit testing using the Kernel Stein Discrepancy (KSD)\n",
    "\n",
    "On the fly, we will introduce basic concepts of statistical hypothesis testing.\n",
    "\n",
    "The notebook contains a number of `# IMPLEMENT` comments, where you are supposed to insert missing code yourself.\n",
    "We also prepared a solution notebook that contains the code we envisioned.\n",
    "\n",
    "Cells are meant to be executed in order (i.e. cells might depend on previous ones).\n",
    "\n",
    "## Dependencies\n",
    "The notebook was written using Python 3.6, but we made an effort to keep it backwards compatible to older versions down to 2.7 (hopefully).\n",
    "\n",
    "We encourage you to use a `conda` environment so you don't modify your system's Python setup (especially due to the problems that come with install TensorFlow and Shogun).\n",
    "\n",
    "The packages you need are:\n",
    "* A standard scipy setup covers most content: `numpy`, `scipy`, `matplotlib`, and of yource `jupyter`\n",
    "* `tensorflow` for gradient-based optimization of test power on the MNIST-GAN example. Note we recommend to install this using `conda install -c conda-forge tensorflow `\n",
    "* Optional: `scikit-learn` for a cross-validation splitting iterator (can implement yourself or use another lib)\n",
    "* Optional: `seaborn`, `pandas` for convenient visualization in some examples\n",
    "* Optional: `tqdm` for a fancy progress bar\n",
    "* Optional: Shogun if you want to run a faster MMD test in the MNIST-GAN example: `conda install -c conda-forge shogun` (do this first as the package currently uses openblas and not MKL, so some of the other packages need to be re-installed).\n",
    "\n",
    "This is an example how to set this environment up and run the notebook server\n",
    "```\n",
    "conda create --name ds3_kernels  python=3.6\n",
    "source activate ds3_kernels\n",
    "conda install -c conda-forge tensorflow \n",
    "conda install -c conda-forge shogun\n",
    "conda install jupyter matplotlib scikit-learn seaborn pandas tqdm\n",
    "jupyter notebook\n",
    "```\n",
    "\n",
    "See the Anaconda/TensorFlow/Shogun installation pages for more details.\n",
    "\n",
    "\n",
    "## Additional files\n",
    "All files can be found at https://github.com/karlnapf/ds3_kernel_testing.\n",
    "They include\n",
    "\n",
    "* This notebook and the solution notebook (we encourage you to not look at this before the practical has finished).\n",
    "* **Provided Python modules**: We provide a few external modules that need to be in the `PYTHONPATH` of your notebook server (just put the files in the same folder as this notebook and start the server from this folder).\n",
    "To see whether this worked, try ```import mmd```, and if it doesn't work, make sure that the file is present in one of the paths when you execute `import sys; print(sys.path)`.\n",
    "* **Provided data**: Put those into the same folder as this notebook\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "try:\n",
    "    from tqdm import tqdm_notebooks as tqdm\n",
    "except ImportError:\n",
    "    tqdm = lambda x: x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data (don't give it to students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mean shifted Gaussians\n",
    "# N = 1000\n",
    "# np.random.seed(0)\n",
    "# X = np.random.randn(N)\n",
    "# Y = np.random.randn(N) + 0.2\n",
    "# np.savez(\"simple.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gaussian vs laplace with same mean / variance\n",
    "# from scipy.stats import laplace, norm\n",
    "\n",
    "# def sample_gaussian_vs_laplace(n=220, mu=0.0, sigma2=1, b=np.sqrt(0.5)):\n",
    "#     # sample from both distributions\n",
    "#     X=norm.rvs(size=n)*np.sqrt(sigma2)+mu\n",
    "#     Y=laplace.rvs(size=n, loc=mu, scale=b)\n",
    "\n",
    "#     return X,Y\n",
    "\n",
    "# np.random.seed(2)\n",
    "# N=300\n",
    "# X, Y = sample_gaussian_vs_laplace(n=N)\n",
    "# np.savez(\"almost_simple.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def sample_blobs(n, ratio, rows=5, cols=5, sep=10, rs=None):\n",
    "#     # ratio is eigenvalue ratio\n",
    "#     correlation = (ratio - 1) / (ratio + 1)\n",
    "\n",
    "#     # generate within-blob variation\n",
    "#     mu = np.zeros(2)\n",
    "#     sigma = np.eye(2)\n",
    "#     X = np.random.multivariate_normal(mu, sigma, size=n)\n",
    "\n",
    "#     corr_sigma = np.array([[1, correlation], [correlation, 1]])\n",
    "#     Y = np.random.multivariate_normal(mu, corr_sigma, size=n)\n",
    "\n",
    "#     # assign to blobs\n",
    "#     X[:, 0] += np.random.randint(rows, size=n) * sep\n",
    "#     X[:, 1] += np.random.randint(cols, size=n) * sep\n",
    "#     Y[:, 0] += np.random.randint(rows, size=n) * sep\n",
    "#     Y[:, 1] += np.random.randint(cols, size=n) * sep\n",
    "\n",
    "#     return X, Y\n",
    "\n",
    "# np.random.seed(0)\n",
    "# N=500\n",
    "# ratio = 0.01\n",
    "# rows_cols = 10\n",
    "# X, Y = sample_blobs(n=N, rows=rows_cols, cols=rows_cols, ratio=ratio)\n",
    "# np.savez(\"blobs.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))\n",
    "# X, Y = sample_blobs(n=N, rows=rows_cols, cols=rows_cols, ratio=ratio)\n",
    "# np.savez(\"blobs2.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))\n",
    "# X, Y = sample_blobs(n=N, rows=1, cols=1, ratio=ratio)\n",
    "# np.savez(\"blobs_zoomed.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.random.seed(0)\n",
    "# N=400\n",
    "# X = np.random.randn(N)\n",
    "# Y = np.random.randn(N)\n",
    "# np.savez(\"hsic1.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def sample_hsic(n, angle, sigma=0.2, offset=1):\n",
    "#     n4 = int(n/4)\n",
    "#     N = np.random.randn(n4, 2)*sigma\n",
    "#     S = np.random.randn(n4, 2)*sigma\n",
    "#     E = np.random.randn(n4, 2)*sigma\n",
    "#     W = np.random.randn(n4, 2)*sigma\n",
    "\n",
    "#     N[:,1] += offset\n",
    "#     S[:,1] -= offset\n",
    "#     W[:,0] -= offset\n",
    "#     E[:,0] += offset\n",
    "\n",
    "#     R = np.array([[np.cos(angle), -np.sin(angle)],[np.sin(angle), np.cos(angle)]])\n",
    "#     A = R.dot(np.vstack((N,S,W,E)).T).T\n",
    "\n",
    "#     return A[:,0], A[:,1]\n",
    "\n",
    "# N=200\n",
    "# np.random.seed(0)\n",
    "# X,Y = sample_hsic(n=N, angle=np.pi/12)\n",
    "# np.savez(\"hsic2.npz\", X=X.astype(np.float32), Y=Y.astype(np.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-sample testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us begin with some simple data $X\\sim P_X, Y\\sim P_Y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.load(\"./data/simple.npz\")\n",
    "X = data[\"X\"]\n",
    "Y = data[\"Y\"]\n",
    "plt.hist(X, alpha=0.5)\n",
    "plt.hist(Y, alpha=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question: do X and Y come from the same distribution?\n",
    "Or in other words: can we reject the null hypothesis that $P_X=P_Y$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The simplest of all test statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by comparing the means of the samples.\n",
    "Clearly, if the distributions are the same, the mean would be zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean differencce: -0.25887364\n"
     ]
    }
   ],
   "source": [
    "def simple_statistic(X,Y, squared=False):\n",
    "    assert X.ndim == Y.ndim == 1\n",
    "\n",
    "    # IMPLEMENT: compute mean difference of X and Y\n",
    "    result = np.mean(X) - np.mean(Y)\n",
    "\n",
    "    if squared:\n",
    "        result *= result\n",
    "    return result\n",
    "\n",
    "my_statistic = simple_statistic(X,Y)\n",
    "print(\"Mean differencce:\", my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Significant?\n",
    "What would it be if distributions were the same? What if they were different?\n",
    "\n",
    "Let's assume that $P_X=P_Y$ and look at the distribution of the test statistic (null distribution).\n",
    "For that, we can merge the samples and shuffle them, after which they have the same \"joint\" distribution.\n",
    "We can then re-compute the statistic for multiple permutations to get a feeling for how the statistic is distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_sample_permutation_test(test_statistic, X, Y, num_permutations, prog_bar=True):\n",
    "    assert X.ndim == Y.ndim\n",
    "\n",
    "    statistics = np.zeros(num_permutations)\n",
    "\n",
    "    range_ = range(num_permutations)\n",
    "    if prog_bar:\n",
    "        range_ = tqdm(range_)\n",
    "    for i in range_:\n",
    "        # concatenate samples\n",
    "        if X.ndim == 1:\n",
    "            Z = np.hstack((X,Y))\n",
    "        elif X.ndim == 2:\n",
    "            Z = np.vstack((X,Y))\n",
    "\n",
    "        # IMPLEMENT: permute samples and compute test statistic\n",
    "        perm_inds = np.random.permutation(len(Z))\n",
    "        Z = Z[perm_inds]\n",
    "        X_ = Z[:len(X)]\n",
    "        Y_ = Z[len(X):]\n",
    "        my_test_statistic = test_statistic(X_, Y_)\n",
    "        statistics[i] = my_test_statistic\n",
    "    return statistics\n",
    "\n",
    "num_permutations = 200\n",
    "statistics = two_sample_permutation_test(simple_statistic, X, Y, num_permutations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have an idea about what to expect from the statistic in case where the distributions are equal.\n",
    "How likely is our particular value of that statistic?\n",
    "We can compare it against the say 95% quantiles of the null distribution.\n",
    "If our statistic lies outside those, we can reject the null with a confidence of 0.05."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_permutation_samples(null_samples, statistic=None):\n",
    "    plt.hist(null_samples)\n",
    "    plt.axvline(x=np.percentile(null_samples, 2.5), c='b')\n",
    "    legend = [\"95% quantiles\"]\n",
    "    if statistic is not None:\n",
    "        plt.axvline(x=statistic, c='r')\n",
    "        legend += [\"Actual test statistic\"]\n",
    "    plt.legend(legend)\n",
    "    plt.axvline(x=np.percentile(null_samples, 97.5), c='b')\n",
    "    plt.xlabel(\"Test statistic value\")\n",
    "    plt.ylabel(\"Counts\")\n",
    "\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, depending on the test statistic, there might be multiple ways to compute the null distribution.\n",
    "Not all of them work via sampling it directly, which also can be costly.\n",
    "For example, if we just use the mean difference as a test statistic, and then plug in two Gaussian distributed random variables, we know that the distribution of the statistic is also Gaussian (see the above plot). \n",
    "We might be even able to analytically work out the parameters of this distribution.\n",
    "\n",
    "In case you haven't realized, this is basically a [t-test](https://en.wikipedia.org/wiki/Student%27s_t-test) where we assume that we know that both distributions have unit variance and we can distinguish them via solely looking at their mean.\n",
    "As it will be useful for kernel based test statistics later, we will also look at the distribution of a squared test statistic, in order to make it strictly positive (and zero in expectation if both distributions are the same).\n",
    "Naturally, the average of squared Gaussian random variables has a chi-square distribution -- something that can be used for the kernel tests that we introduce later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# IMPLEMENT: use squared test statistic\n",
    "simple_statistic_squared = lambda X,Y: simple_statistic(X,Y,squared=True)\n",
    "\n",
    "# visualise test\n",
    "statistics = two_sample_permutation_test(simple_statistic_squared, X, Y, num_permutations)\n",
    "my_statistic = simple_statistic_squared(X,Y)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative distribution via explicit simulation\n",
    "\n",
    "As a caveat, please note that the test statistic itself has a distribution under the alternative hypothesis ($P_X \\neq P_Y$), and that our computed test statistic is only a single sample from this distribution.\n",
    "In practice, it is unfortunately not possible to look at the distribution of the test under the alternative, as this would require a way to generate more data.\n",
    "We can try this for a synthetic example where we have infinite data though."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "\n",
    "# we make a model where the null distribution is false\n",
    "shift = .3\n",
    "N = 200\n",
    "X = np.random.randn(N)\n",
    "Y = np.random.randn(N)+shift\n",
    "\n",
    "statistics_null = two_sample_permutation_test(simple_statistic_squared, X, Y, num_permutations)\n",
    "my_statistic = simple_statistic_squared(X,Y) # this is a single sample from the alternative\n",
    "\n",
    "statistics_alt = np.zeros(num_permutations)\n",
    "for i in tqdm(range(num_permutations)):\n",
    "    # IMPLEMENT: generate more data from the alternative\n",
    "    X = np.random.randn(N)\n",
    "    Y = np.random.randn(N)+shift\n",
    "\n",
    "    statistics_alt[i] = simple_statistic_squared(X,Y)\n",
    "\n",
    "plt.figure(figsize=(12,4))\n",
    "plot_permutation_samples(statistics_null, my_statistic)\n",
    "plt.hist(statistics_alt, alpha=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, even though most of the alternative distribution far larger than the null, we can be unlucky: there are datasets for which the test would not reject the null simply by chance -- we only have a single draw from the alternative.\n",
    "With this fixed seed, it turns out that we have been unlucky and would have not rejected the null hypothesis even it is not true.\n",
    "You could play with the sample size and observe how this impacts the position of the alternative distribution (and as such the test power).\n",
    "\n",
    "Let's try the test on another dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Means: -0.05499658 0.027213123\n",
      "Standard deviations: 1.046988 0.9609663\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.load(\"./data/almost_simple.npz\")\n",
    "X = data[\"X\"]\n",
    "Y = data[\"Y\"]\n",
    "plt.hist(X, alpha=0.5)\n",
    "plt.hist(Y, alpha=0.5)\n",
    "\n",
    "# IMPLEMENT: print mean and std deviation of data\n",
    "print(\"Means:\", np.mean(X), np.mean(Y))\n",
    "print(\"Standard deviations:\", np.std(X), np.std(Y))\n",
    "\n",
    "my_statistic = simple_statistic(X,Y)\n",
    "statistics = two_sample_permutation_test(simple_statistic, X, Y, num_permutations)\n",
    "\n",
    "plt.figure()\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now for the squared test statistic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# IMPLEMENT: visualize test for squared statistic\n",
    "simple_statistic_squared = lambda X,Y: simple_statistic(X,Y,squared=True)\n",
    "statistics = two_sample_permutation_test(simple_statistic_squared, X, Y, num_permutations)\n",
    "my_statistic = simple_statistic_squared(X,Y)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, both test statistics essentially have no chance in distinguishing this data.\n",
    "(althogh keep in mind we could have been unlucky as outlined above).\n",
    "For now, let's just assume we only have a single dataset to compute the test."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quadratic time MMD\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already seen the quadratic time MMD: it was the squared difference of the sample means above, if we had used a linear kernel (where the feature space embedding is the identity function).\n",
    "This test wasn't able to distinguish the above distributions, but let's try a different kernel.\n",
    "\n",
    "We will use the unbiased statistic here, defined as\n",
    "$$ \n",
    "\\frac{1}{n(n-1)}\\sum_{i=1}^n\\sum_{j\\neq i}^m k(x_i,x_j) + \\frac{1}{m(m-1)}\\sum_{i=1}^n\\sum_{j\\neq i}^mk(y_i,y_j) -2\\frac{1}{nm}\\sum_{i=1}^n \\sum_{j=1}^m k(x_i,y_j)\n",
    "$$\n",
    "See the slides for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kernels\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first need to implement a kernel function.\n",
    "Though we could use a framework to do this for us, it is quite instructive to do this ourselves (at least once).\n",
    "\n",
    "We will start with a Gaussian kernel\n",
    "$$\n",
    "k(x,y) = \\exp \\left( - \\frac{||x-y||_2^2}{\\sigma}\\right)\n",
    "$$\n",
    "with some bandwidth parameter $\\sigma$ (note there are many different parametrizations!).\n",
    "\n",
    "This kernel is translation invariant, and like many other kernels, it is defined in terms of pairwise (Euclidean) distances between the data.\n",
    "Let's implement it this way so we can easily try other kernels that are translation invariant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial.distance import squareform, pdist, cdist\n",
    "\n",
    "def sq_distances(X,Y=None):\n",
    "    \"\"\"\n",
    "    If Y=None, then this computes the distance between X and itself\n",
    "    \"\"\"\n",
    "    assert(X.ndim==2)\n",
    "\n",
    "    # IMPLEMENT: compute pairwise distance matrix. Don't use explicit loops, but the above scipy functions\n",
    "    # if X=Y, use more efficient pdist call which exploits symmetry\n",
    "    if Y is None:\n",
    "        sq_dists = squareform(pdist(X, 'sqeuclidean'))\n",
    "    else:\n",
    "        assert(Y.ndim==2)\n",
    "        assert(X.shape[1]==Y.shape[1])\n",
    "        sq_dists = cdist(X, Y, 'sqeuclidean')\n",
    "\n",
    "    return sq_dists\n",
    "\n",
    "def gauss_kernel(X, Y=None, sigma=1.0):\n",
    "    \"\"\"\n",
    "    Computes the standard Gaussian kernel k(x,y)=exp(- ||x-y||**2 / (2 * sigma**2))\n",
    "\n",
    "    X - 2d array, samples on left hand side\n",
    "    Y - 2d array, samples on right hand side, can be None in which case they are replaced by X\n",
    "\n",
    "    returns: kernel matrix\n",
    "    \"\"\"\n",
    "\n",
    "    # IMPLEMENT: compute squared distances and kernel matrix\n",
    "    sq_dists = sq_distances(X,Y)\n",
    "    K = np.exp(-sq_dists / (2 * sigma**2))\n",
    "    return K\n",
    "\n",
    "# IMPLEMENT\n",
    "def linear_kernel(X, Y):\n",
    "    return np.dot(X, Y.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the kernel at hand, we can implement the quadratic time MMD statistic as a function of the kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadratic_time_mmd(X,Y,kernel):\n",
    "    assert X.ndim == Y.ndim == 2\n",
    "    K_XX = kernel(X,X)\n",
    "    K_XY = kernel(X,Y)\n",
    "    K_YY = kernel(Y,Y)\n",
    "\n",
    "    n = len(K_XX)\n",
    "    m = len(K_YY)\n",
    "\n",
    "    # IMPLEMENT: unbiased MMD statistic (could also use biased, doesn't matter if we use permutation tests)\n",
    "    np.fill_diagonal(K_XX, 0)\n",
    "    np.fill_diagonal(K_YY, 0)\n",
    "    mmd = np.sum(K_XX) / (n*(n-1))  + np.sum(K_YY) / (m*(m-1))  - 2*np.sum(K_XY)/(n*m)\n",
    "    return mmd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=0.3)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X[:,np.newaxis],Y[:,np.newaxis], my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems much better: the Gaussian kernel allows us to very clearly distinguish the two distributions.\n",
    "\n",
    "Now let us try the MMD with a linear kernel and compare it to the above.\n",
    "In particular, compare (and think about) the relationship to the simple squared mean difference statistic we computed above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16.14073786916104, 16.14053790596624)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test equivalence linear kernel with unbiased statistic vs squared difference of means\n",
    "num_samples = 10000\n",
    "test1 = np.random.randn(num_samples) + 1\n",
    "test1 = test1[:,np.newaxis]\n",
    "test2 = np.random.randn(num_samples) + 5\n",
    "test2 = test2[:,np.newaxis]\n",
    "stat1 = simple_statistic(test1[:,0], test2[:,0], squared=True)\n",
    "stat2 = quadratic_time_mmd(test1, test2, linear_kernel)\n",
    "stat1, stat2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# IMPLEMENT: visualize test using linear kernel\n",
    "my_kernel = lambda X,Y : linear_kernel(X,Y)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X[:,np.newaxis],Y[:,np.newaxis], my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is almost the same result as we had for doing the simple squared statistic above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative methods to estimate the null distribution\n",
    "\n",
    "There are multiple other way to get our hands on the distribution of the MMD test statistic under the null hypothesis.\n",
    "\n",
    "We know that asymptotically, the distribution is an infinite sum of Chi-square variables -- intractable unfortunately.\n",
    "Techniques to approximate it include\n",
    "\n",
    "* moment matching using a Gamma distribution: fast, but doesn't result in a consistent test\n",
    "* a spectral approximation: use Eigenvalues of the kernel matrix to sample from the null distribution in closed form. Costly (cubic!) for large sample sets.\n",
    "* wild-bootstrap: a technique used for correlated samples that is similar to permuting\n",
    "* linear time statistics: for those, one can often show that the null distribution is Gaussian and its variance can be estimated in closed form.\n",
    "\n",
    "We do not cover those here since they require some more details.\n",
    "The permutation test, while potentially slower, is easy to understand and works for most applications (if implemented well).\n",
    "\n",
    "Some resources:\n",
    "* [a Shogun notebook](http://www.shogun-toolbox.org/notebook/latest/mmd_two_sample_testing.html), old but contains many null approximation methods\n",
    "* Linear time tests based on analytic function comparisons (see notes at end of section)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MMD witness function in the RKHS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One nice feature of the MMD is that we can see where the density functions are different via querying the (empirical) MMD witness function.\n",
    "This is just the difference of the empirical mean embeddings in the RKHS and thus computable (remember the MMD is the RKHS norm of this witness function).\n",
    "See the slides for details.\n",
    "\n",
    "$$f^*(\\cdot)=\\hat \\mu_X(\\cdot) - \\hat \\mu_Y(\\cdot) $$\n",
    "\n",
    "Let's define a grid and evaluate the witness function on it to see where X and Y differ most."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f731b0539d0>"
      ]
     },
     "execution_count": 42,
     "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": [
    "X = np.random.normal(size=100000, scale=1.0)\n",
    "Y = np.random.laplace(size=100000, scale=0.1)\n",
    "\n",
    "grid = np.linspace(np.min(X), np.max(X))\n",
    "\n",
    "my_kernel = lambda X,Y : gauss_kernel(X,Y, sigma=0.3)\n",
    "\n",
    "# IMPLEMENT: evaluate MMD witness function on grid\n",
    "phi_X = np.mean(my_kernel(X[:,np.newaxis], grid[:,np.newaxis]), axis=0)*1\n",
    "phi_Y = np.mean(my_kernel(Y[:,np.newaxis], grid[:,np.newaxis]), axis=0)\n",
    "witness = phi_X-phi_Y\n",
    "\n",
    "plt.plot(grid, witness, label=\"f\")\n",
    "# compute gaussian pdf based on grid domain\n",
    "pdf_x = np.exp(-grid**2/2)/np.sqrt(2*np.pi)\n",
    "# compute laplace pdf based on grid domain\n",
    "pdf_y = np.exp(-np.abs(grid))/2\n",
    "\n",
    "plt.plot(grid, pdf_x, label=\"Gaussian\")\n",
    "plt.plot(grid, pdf_y, label=\"Laplace\")\n",
    "plt.legend()\n",
    "\n",
    "# plt.hist(X, alpha=0.5, density=True)\n",
    "# plt.hist(Y, alpha=0.5, density=True);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.928633669346844 1.9751057331918775\n",
      "4.035992805478751 2.0458872734754885\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# IMPLEMENT (optional): try mix and matching kernels and data sources\n",
    "# e.g. try a periodic kernel on data that differs in frequency space\n",
    "from scipy.stats import laplace, norm, lognorm, levy, gamma\n",
    "\n",
    "mean = 4\n",
    "\n",
    "X2 = gamma.rvs(mean, loc=0., scale=1., size=1000)\n",
    "plt.hist(X2, bins=100, alpha=0.5);\n",
    "print(np.mean(X2), np.std(X2))\n",
    "\n",
    "Y2 = norm.rvs(loc=mean, scale=np.sqrt(mean), size=1000)\n",
    "plt.hist(Y2, bins=100, alpha=0.5);\n",
    "print(np.mean(Y2), np.std(Y2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_permutations = 500\n",
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=0.3)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X[:,np.newaxis],Y[:,np.newaxis], my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X2, Y2, num_permutations)\n",
    "my_statistic = my_mmd(X2,Y2)\n",
    "\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid = np.linspace(np.min(X2), np.max(X2))\n",
    "\n",
    "my_kernel = lambda X,Y : gauss_kernel(X,Y, sigma=0.5)\n",
    "\n",
    "# IMPLEMENT: evaluate MMD witness function on grid\n",
    "phi_X = np.mean(my_kernel(X2[:,np.newaxis], grid[:,np.newaxis]), axis=0)\n",
    "phi_Y = np.mean(my_kernel(Y2[:,np.newaxis], grid[:,np.newaxis]), axis=0)\n",
    "witness = phi_X-phi_Y\n",
    "\n",
    "plt.plot(grid, witness)\n",
    "\n",
    "plt.hist(X2, alpha=0.5, density=True)\n",
    "plt.hist(Y2, alpha=0.5, density=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the witness function is positive where X as a higher density than Y, and negative vice versa.\n",
    "It is zero where both densities match.\n",
    "Intuitively, the RKHS norm of this function can only be zero if the densities match everywhere, and it grows as the densities differ on more and more points in their support.\n",
    "Of course, this kind of visualization only works in few dimensions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes on efficient implementations\n",
    "Note that the above implemention of the MMD, and in particular the permutation test, is extremelty inefficient since the kernel matrix is re-computed in every iteration of the permutation test (and the data is copied around for concatenation as well).\n",
    "We could precompute it once, but then we still would be required to permute it multiple times.\n",
    "\n",
    "We have written a multi-threaded version in C++ that does not permute the matrix, but simply traverses it multiple times, which makes the algorithm L2 cache friendly and therefore hundreds of times faster.\n",
    "See:\n",
    "* http://shogun.ml for the toolbox\n",
    "* http://shogun.ml/examples/latest/examples/statistical_testing/quadratic_time_mmd.html for an API example\n",
    "* http://www.shogun-toolbox.org/notebook/latest/mmd_two_sample_testing.html for a complex demo in Python\n",
    "* https://arxiv.org/abs/1611.04488 for a paper with performance details\n",
    "\n",
    "We will use Shogun for a larger example below.\n",
    "You could time our handwritten implementation against it, or you can tune the Python implementation and try to beat it ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernel learning (aka which kernel parameter to choose?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen that the Gaussian kernel above increased the power of the test.\n",
    "But what happened if we chose a wrong kernel parameter?\n",
    "Let's pick a bad one and see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFuElEQVR4nO3deZzNdf//8eeZGbMxi7HM0jXM2GUXCSUxV8ZSiEIqVHSVJUlqrqxFI1fkssTFL8RliRakkF3LZG0sWWOEMiMxMwYzmHn//vB1LseMZWYOc3w87rfbuXXOZ3l/Xq8zg2ef1WaMMQIAALAot4IuAAAA4FYi7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEsj7AAAAEvzKOgCXEFWVpb++OMP+fn5yWazFXQ5AADgJhhjdPr0aYWFhcnN7dr7bwg7kv744w+Fh4cXdBkAACAPjhw5or/97W/XnE/YkeTn5yfp0pfl7+9fwNUUrDNnpLCwS+//+EMqXLhg6wFcHn9oCgRfOyQpNTVV4eHh9n/Hr4WwI9kPXfn7+9/1Ycfd/X/v/f35CwS4If7QFAi+dlzpRqegcIIyAACwNMIOAACwtAINO+vXr9djjz2msLAw2Ww2LVy40D7vwoULevPNN1WtWjUVLlxYYWFheu655/THH384jHHy5El17txZ/v7+CgwM1AsvvKC0tLTb3AkAAHBVBXrOzpkzZ1SjRg09//zzeuKJJxzmnT17Vlu3btWgQYNUo0YNnTp1Sq+++qoef/xxbd682b5c586ddezYMa1YsUIXLlxQt27d1KNHD82ZM+d2twMABS4zM1MXLlwo6DJuuYwMqXTp/72/8hweWEehQoXk7oQfrs0YY5xQT77ZbDZ9+eWXatOmzTWX2bRpk+6//3799ttvKlWqlHbv3q17771XmzZtUp06dSRJy5YtU4sWLXT06FGFXT5V/wZSU1MVEBCglJSUu/4E5TNnpCJFLr1PS+OkP+CGXOQPjTFGiYmJSk5OLpDt325ZWdKRI5feh4dL17nFCu5wgYGBCgkJyfEk5Jv99/uOuhorJSVFNptNgYGBkqS4uDgFBgbag44kRUVFyc3NTRs2bFDbtm1zHCcjI0MZGRn2z6mpqbe0bgC41S4HnZIlS8rX19fyN0jNzJTOnbv0PiKCPTtWZIzR2bNndfz4cUlSaGhonse6Y8JOenq63nzzTXXq1Mme3hITE1WyZEmH5Tw8PBQUFKTExMRrjhUbG6thw4bd0noB4HbJzMy0B51ixYoVdDm3RWbm/957exN2rMrHx0eSdPz4cZUsWTLPh7TuiB1/Fy5c0FNPPSVjjCZNmpTv8WJiYpSSkmJ/Hbm8LxQA7kCXz9Hx9fUt4EoA57v8e52fc9Fcfs/O5aDz22+/afXq1Q7H5EJCQuy7ty67ePGiTp48qZCQkGuO6eXlJS8vr1tWMwAUBKsfusLdyRm/1y69Z+dy0Nm/f79WrlyZbfds/fr1lZycrC1bttinrV69WllZWapXr97tLhcAALigAt2zk5aWpl9//dX+OSEhQfHx8QoKClJoaKjat2+vrVu3asmSJcrMzLSfhxMUFCRPT09VrlxZ0dHR6t69uyZPnqwLFy6oV69e6tix401fiQUAAKytQPfsbN68WbVq1VKtWrUkSf369VOtWrU0ePBg/f7771q8eLGOHj2qmjVrKjQ01P768ccf7WPMnj1blSpVUtOmTdWiRQs9+OCDmjJlSkG1BACA0x06dEg2m03x8fGSpLVr18pms901txrIrwINO40bN5YxJttrxowZioiIyHGeMUaNGze2jxEUFKQ5c+bo9OnTSklJ0bRp01Tk8j0vAAAu6/Tp0+rbt69Kly4tHx8fNWjQQJs2bXJYpmvXrrLZbA6v6Oho+/zz5zPUpcuz8vf3V4UKFbRy5UqH9f/1r3+pd+/et6UfZ+natWu2e86Fh4fr2LFjqlq1asEUdYdz+ROUAQDW9OKLL2rnzp2aNWuWwsLC9N///ldRUVHatWuX7rnnHvty0dHRmj59uv3zlReYfPnlFG3dukVxcXFaunSpnn76aSUlJclmsykhIUFTp051uOv+ncrd3f26F97g+lz6BGUAQN4Yc+nmzrf7dbP35D937pw+//xzjRo1So0aNVK5cuU0dOhQlStXLtstRry8vBQSEmJ/FS1a1D4vIWG3WrV6XFWqVFHPnj31559/6sSJE5Kkl19+We+///5N3Rk/MzNT/fr1U2BgoIoVK6YBAwaoS5cuDntYIiIiNHbsWIf1atasqaFDh9o/jxkzxv5Mx/DwcL3yyisOz2ucMWOGAgMDtXz5clWuXFlFihRRdHS0jh07JkkaOnSoPvnkEy1atMi+J2vt2rXZDmPl5Pvvv9dDDz0kHx8fhYeHq0+fPjpz5ox9/kcffaTy5cvL29tbwcHBat++/Q2/F6tgzw6AXIl46+uCLiHXDo1sWdAl3HZnz/7vKRa3080+MePixYvKzMyUt7e3w3QfHx99//33DtPWrl2rkiVLqmjRomrSpImGDx+uwMBLV+dWqFBD69bN0rlz57R8+XKFhoaqePHimj17try9va95J/2rjR49WjNmzNC0adNUuXJljR49Wl9++aWaNGlyc43/Hzc3N40bN06RkZE6ePCgXnnlFQ0YMEAfffSRfZmzZ8/qgw8+0KxZs+Tm5qZnnnlG/fv31+zZs9W/f3/t3r1bqamp9r1ZQUFB2R6CfbUDBw4oOjpaw4cP17Rp0/Tnn3+qV69e6tWrl6ZPn67NmzerT58+mjVrlho0aKCTJ0/qu+++y1VvdzLCDgDgtvPz81P9+vX17rvvqnLlygoODtbcuXMVFxencuXK2ZeLjo7WE088ocjISB04cED//Oc/1bx5c33/fZwkdz3++PNKTt6ue++9V8WLF9f8+fN16tQpDR48WGvXrtXAgQM1b948lS1bVtOmTXM4PHalsWPHKiYmxv5Q6smTJ2v58uW57qtv37729xERERo+fLj+8Y9/OISdCxcuaPLkySpbtqwkqVevXnrnnXckSUWKFJGPj48yMjJyddgqNjZWnTt3tm+/fPnyGjdunB5++GFNmjRJhw8fVuHChdWqVSv5+fmpdOnS9ouD7gaEHQCwIF/fS3tZCmK7N2vWrFl6/vnndc8998jd3V21a9dWp06dHO6d1rFjR/v7atWqqXr16ipbtqzWrl2roKCm8vAopPHjJzo8LqJbt27q06ePfv75Zy1cuFDbtm3TqFGj1KdPH33++efZ6khJSdGxY8cc7s/m4eGhOnXqKLfPyl65cqViY2O1Z88epaam6uLFi0pPT9fZs2ftdwL29fW1Bx3p0jOfrr5Bbm5t27ZN27dv1+zZs+3TjDHKyspSQkKC/v73v6t06dIqU6aMoqOjFR0drbZt2941d90m7AAF5E48HIQ7h81WYA9gv2lly5bVunXrdObMGaWmpio0NFQdOnRQmTJlrrlOmTJlVLx4cR048KuCgppmm79mzRr98ssv+n//7//pjTfeUIsWLVS4cGE99dRTmjBhQr7qdXNzyxZ+rnyEwaFDh9SqVSu9/PLLGjFihIKCgvT999/rhRde0Pnz5+3BolChQg5j2Gy2XIeqq6Wlpemll15Snz59ss0rVaqUPD09tXXrVq1du1bffvutBg8erKFDh2rTpk32h2tbGScoAwAKVOHChRUaGqpTp05p+fLlat269TWXPXr0qP76668cn4Cdnp6unj176j//+Y/c3d2VmZlpDyMXLlxQ5pVPD71CQECAQkNDtWHDBvu0ixcvOuxhkqQSJUrYTySWpNTUVCUkJNg/b9myRVlZWRo9erQeeOABVahQ4Ybn2uTE09PzmrVeS+3atbVr1y6VK1cu28vT01PSpb1VUVFRGjVqlLZv365Dhw5p9erVua7vTkTYAQAUiOXLl2vZsmVKSEjQihUr9Mgjj6hSpUrq1q2bpEt7K9544w399NNPOnTokFatWqXWrVurXLlyevTRZtnGe/fdd9WiRQv7uSgNGzbUF198oe3bt2vChAlq2LDhNWt59dVXNXLkSC1cuFB79uzRK6+8ku2GfU2aNNGsWbP03XffaceOHerSpYvDU7jLlSunCxcuaPz48Tp48KBmzZqlyZMn5/p7iYiI0Pbt27V3716dOHHiph6A+eabb+rHH39Ur169FB8fr/3792vRokXq1auXJGnJkiUaN26c4uPj9dtvv2nmzJnKyspSxYoVc13fnYjDWACAApGSkqKYmBgdPXpUQUFBateunUaMGGE/zOPu7q7t27frk08+UXJyssLCwvToo4/q3XffzfYw5507d2r+/PkOl2a3b99ea9eu1UMPPaSKFStqzpw516zl9ddf17Fjx9SlSxe5ubnp+eefV9u2bZWSkmJfJiYmRgkJCWrVqpUCAgL07rvvOuzZqVGjhsaMGaP3339fMTExatSokWJjY/Xcc8/l6nvp3r271q5dqzp16igtLU1r1qxRRETEddepXr261q1bp7ffflsPPfSQjDEqW7asOnToIEkKDAzUF198oaFDhyo9PV3ly5fX3LlzVaVKlVzVdqeymfweKLSA1NRUBQQEKCUl5abux2BlZ87873LVm72EFHnDOTu3zy299NwF/tCkp6crISFBkZGR2S7ltqrMTOnnny+9r1VLDicoO0vXrl2VnJyshQsXOn9w3LTr/X7f7L/fHMYCAACWRtgBAACWxjk7AADkYMaMGQVdApyEPTsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSCDsAAOTAZrNxQ0Hl/3sYOnSoatas6bR68oKwAwAoUHFxcXJ3d1fLlrm/0/Xjj0fo3/8e6/yibkLjxo3Vt29fp47ZtWtXtWnTpkDGuFYoOXbsmJo3b35TY+QUjPr3769Vq1bluh5nIuwAAArUxx9/rN69e2v9+vV5eko4bq2QkJBszyLLjSJFiqhYsWJOrCj3CDsAgAKTlpamTz/9VC+//LJatmyZ4438vvrqK9WtW1fe3t4qXry42rZtK0l66aXGOnbsN73++muy2Wyy2WySct5DMXbsWIeHaW7atEl///vfVbx4cQUEBOjhhx/W1q1bb7rurl27at26dfr3v/9t3/ahQ4ckXXooafPmzVWkSBEFBwfr2Wef1YkTJ+zrfvbZZ6pWrZp8fHxUrFgxRUVF6cyZMxo6dKg++eQTLVq0yD7m2rVrc9x+XsZ48803VaFCBfn6+qpMmTIaNGiQ/YnqM2bM0LBhw7Rt2zb7epd/FlfurTl//rx69eql0NBQeXt7q3Tp0oqNjZUk+/fbtm1b2Ww2++ecfh7Tpk1TlSpV5OXlpdDQUPvT2W8V7qAMAFZkjHT27O3frq+v9H+h42bMnz9flSpVUsWKFfXMM8+ob9++iomJsQeXr7/+Wm3bttXbb7+tmTNn6vz58/rmm28kSaNGfaGnn66hV17poZde6p6rMk+fPq0uXbpo/PjxMsZo9OjRatGihfbv3y8/P78brv/vf/9b+/btU9WqVfXOO+9IkkqUKKHk5GQ1adJEL774oj788EOdO3dOb775pp566imtXr1ax44dU6dOnTRq1Ci1bdtWp0+f1nfffSdjjPr376/du3crNTVV06dPlyQFBQVl23Zex/Dz89OMGTMUFhamHTt2qHv37vLz89OAAQPUoUMH7dy5U8uWLdPKlSslSQEBAdm2PW7cOC1evFjz589XqVKldOTIER05ckTSpQBZsmRJTZ8+XdHR0XK/xtNZJ02apH79+mnkyJFq3ry5UlJS9MMPP9zwO88Pwg4AWNHZs/97GvvtlMsnv3/88cd65plnJEnR0dFKSUnRunXr1LhxY0nSiBEj1LFjRw0bNsy+To0aNZSZKQUEBMnd3V1+fn4KCQnJVZlNmjRx+DxlyhQFBgZq3bp1atWq1Q3XDwgIkKenp3x9fR22PWHCBNWqVUvvvfeefdq0adMUHh6uffv2KS0tTRcvXtQTTzyh0qVLS5KqVatmX9bHx0cZGRnX7efYsWN5GmPgwIH29xEREerfv7/mzZunAQMGyMfHR0WKFJGHh8d1t3348GGVL19eDz74oGw2m3370qWwJ0mBgYHXHWP48OF6/fXX9eqrr9qn1a1b95rLOwOHsQAABWLv3r3auHGjOnXqJEny8PBQhw4d9PHHH9uXiY+PV9OmTZ2+7aSkJHXv3l3ly5dXQECA/P39lZaWpsOHD+dr3G3btmnNmjUqUqSI/VWpUiVJ0oEDB1SjRg01bdpU1apV05NPPqmpU6fq1KlTudpGXsf49NNP1bBhQ4WEhKhIkSIaOHBgrvvt2rWr4uPjVbFiRfXp00fffvttrtY/fvy4/vjjj1vyM70e9uwAgBX5+l7ay1IQ271JH3/8sS5evKiwsDD7NGOMvLy8NGHCBAUEBMjHxyfXJbi5uckY4zDt8rkpl3Xp0kV//fWX/v3vf6t06dLy8vJS/fr1df78+Vxv70ppaWl67LHH9P7772ebFxoaKnd3d61YsUI//vijvv32W40fP15vv/22NmzYoMjIyJvaRl7GiIuLU+fOnTVs2DA1a9ZMAQEBmjdvnkaPHp2r/mrXrq2EhAQtXbpUK1eu1FNPPaWoqCh99tlnN7V+Xn6ezsCeHQCwIpvt0uGk2/26yfN1Ll68qJkzZ2r06NGKj4+3v7Zt26awsDDNnTtXklS9evXrXrZcqJCnMjMzHaaVKFFCiYmJDoEnPj7eYZkffvhBffr0UYsWLewnyl55EvHN8PTMvu3atWvrl19+UUREhMqVK+fwKvx/h/dsNpsaNmyoYcOG6eeff5anp6e+/PLLa46Zk9yO8eOPP6p06dJ6++23VadOHZUvX16//fbbDfvJib+/vzp06KCpU6fq008/1eeff66TJ09KkgoVKnTdMfz8/BQREXHbL0Un7AAAbrslS5bo1KlTeuGFF1S1alWHV7t27eyHsoYMGaK5c+dqyJAh2r17t3bs2OGw1yQ0NELffbdev//+uz2sNG7cWH/++adGjRqlAwcOaOLEiVq6dKnD9suXL69Zs2Zp9+7d2rBhgzp37pzrvQ4RERHasGGDDh06pBMnTigrK0s9e/bUyZMn1alTJ23atEkHDhzQ8uXL1a1bN2VmZmrDhg167733tHnzZh0+fFhffPGF/vzzT1WuXNk+5vbt27V3716dOHEi2x4pSXkao3z58jp8+LDmzZunAwcOaNy4cfZwdGU/CQkJio+P14kTJ5SRkZFt22PGjNHcuXO1Z88e7du3TwsWLFBISIgCAwPtY6xatUqJiYnXPLQ2dOhQjR49WuPGjdP+/fu1detWjR8/PlfffW4RdgAAt93HH3+sqKioHK/4adeunTZv3qzt27ercePGWrBggRYvXqyaNWuqSZMm2rhxo33Zl156R7/9dkhly5a1nyBbuXJlffTRR5o4caJq1KihjRs3qn///tm2f+rUKdWuXVvPPvus+vTpo5IlS+aqh/79+8vd3V333nuvSpQoocOHDyssLEw//PCDMjMz9eijj6patWrq27evAgMD5ebmJn9/f61fv14tWrRQhQoVNHDgQI0ePdp+077u3burYsWKqlOnjkqUKJHjVUp5GePxxx/Xa6+9pl69eqlmzZr68ccfNWjQoGzfe3R0tB555BGVKFHCvnftSn5+fho1apTq1KmjunXr6tChQ/rmm2/k5nYpTowePVorVqxQeHi4atWqleP31qVLF40dO1YfffSRqlSpolatWmn//v25+u5zy2auPrB5F0pNTVVAQIBSUlLk7+9f0OUUqDNn/ncBRy4vqkAuRbz1dUGXcNc4NDL3d+a9aS7whyY9PV0JCQmKjIyUt7f3bd9+QcjMlH7++dL7WrWka1zlDAu43u/3zf77zZ4dAABgaYQdAABgaYQdAABgaYQdAABgaYQdALAIrjeBFTnj95qwAwB3uEKFCkmSzhbEgz+BW+zy7/Xl3/O84HERAHCHc3d3V2BgoI4fPy5J8vX1tT813KquvElvejqXnluRMUZnz57V8ePHFRgYeM2nqN8Mwg4AWMDlp0xfDjxWl5UlXX66w6FDkhvHKSzrRk9RvxmEHQCwAJvNptDQUJUsWTLHRwxYzdmzUsv/u1fk1q25ev4o7iCFChXK1x6dywg7AGAh7u7uTvnHwdVlZkqXn2Pp5SXdJTeORh6x4w8AAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFhagYad9evX67HHHlNYWJhsNpsWLlzoMN8Yo8GDBys0NFQ+Pj6KiorS/v37HZY5efKkOnfuLH9/fwUGBuqFF15QWlrabewCAAC4sgINO2fOnFGNGjU0ceLEHOePGjVK48aN0+TJk7VhwwYVLlxYzZo1U3p6un2Zzp0765dfftGKFSu0ZMkSrV+/Xj169LhdLQAAABdXoM/Gat68uZo3b57jPGOMxo4dq4EDB6p169aSpJkzZyo4OFgLFy5Ux44dtXv3bi1btkybNm1SnTp1JEnjx49XixYt9MEHHygsLOy29QIAAFyTy56zk5CQoMTEREVFRdmnBQQEqF69eoqLi5MkxcXFKTAw0B50JCkqKkpubm7asGHDNcfOyMhQamqqwwsAAFiTy4adxMRESVJwcLDD9ODgYPu8xMRElSxZ0mG+h4eHgoKC7MvkJDY2VgEBAfZXeHi4k6sHAACuwmXDzq0UExOjlJQU++vIkSMFXRIAALhFXDbshISESJKSkpIcpiclJdnnhYSE6Pjx4w7zL168qJMnT9qXyYmXl5f8/f0dXgAAwJpcNuxERkYqJCREq1atsk9LTU3Vhg0bVL9+fUlS/fr1lZycrC1bttiXWb16tbKyslSvXr3bXjMAAHA9BXo1Vlpamn799Vf754SEBMXHxysoKEilSpVS3759NXz4cJUvX16RkZEaNGiQwsLC1KZNG0lS5cqVFR0dre7du2vy5Mm6cOGCevXqpY4dO3IlFgAAkFTAYWfz5s165JFH7J/79esnSerSpYtmzJihAQMG6MyZM+rRo4eSk5P14IMPatmyZfL29ravM3v2bPXq1UtNmzaVm5ub2rVrp3Hjxt32XgAAgGuyGWNMQRdR0FJTUxUQEKCUlJS7/vydM2ekIkUuvU9LkwoXLth6rCzira8LuoS7xqGRLW/d4PyhKRB87ZBu/t9vlz1nBwAAwBkIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNIIOwAAwNI8CroAALjVIt76+paN7XM+Xbv/733lQct0ztPbKeMeGtnSKeMAYM8OAACwOMIOAACwNMIOAACwNMIOAACwNMIOAACwNMIOAACwNMIOAACwNJcOO5mZmRo0aJAiIyPl4+OjsmXL6t1335Uxxr6MMUaDBw9WaGiofHx8FBUVpf379xdg1QAAwJW4dNh5//33NWnSJE2YMEG7d+/W+++/r1GjRmn8+PH2ZUaNGqVx48Zp8uTJ2rBhgwoXLqxmzZopPT29ACsHAACuwqXvoPzjjz+qdevWatny0p1EIyIiNHfuXG3cuFHSpb06Y8eO1cCBA9W6dWtJ0syZMxUcHKyFCxeqY8eOBVY7AABwDS69Z6dBgwZatWqV9u3bJ0natm2bvv/+ezVv3lySlJCQoMTEREVFRdnXCQgIUL169RQXF3fNcTMyMpSamurwAgAA1uTSe3beeustpaamqlKlSnJ3d1dmZqZGjBihzp07S5ISExMlScHBwQ7rBQcH2+flJDY2VsOGDbt1hQMAAJfh0nt25s+fr9mzZ2vOnDnaunWrPvnkE33wwQf65JNP8jVuTEyMUlJS7K8jR444qWIAAOBqXHrPzhtvvKG33nrLfu5NtWrV9Ntvvyk2NlZdunRRSEiIJCkpKUmhoaH29ZKSklSzZs1rjuvl5SUvL69bWjsAAHANLr1n5+zZs3JzcyzR3d1dWVlZkqTIyEiFhIRo1apV9vmpqanasGGD6tevf1trBQAArsml9+w89thjGjFihEqVKqUqVaro559/1pgxY/T8889Lkmw2m/r27avhw4erfPnyioyM1KBBgxQWFqY2bdoUbPEAAMAluHTYGT9+vAYNGqRXXnlFx48fV1hYmF566SUNHjzYvsyAAQN05swZ9ejRQ8nJyXrwwQe1bNkyeXt7F2DlAADAVbh02PHz89PYsWM1duzYay5js9n0zjvv6J133rl9hQEAgDuGS5+zAwAAkF+EHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGmEHQAAYGkeBV0A4AwRb31d0CUAAFwUe3YAAIClEXYAAIClEXYAAIClEXYAAICl5SnsbN26VTt27LB/XrRokdq0aaN//vOfOn/+vNOKAwAAyK88hZ2XXnpJ+/btkyQdPHhQHTt2lK+vrxYsWKABAwY4tUAAAID8yFPY2bdvn2rWrClJWrBggRo1aqQ5c+ZoxowZ+vzzz51ZHwAAQL7kKewYY5SVlSVJWrlypVq0aCFJCg8P14kTJ5xXHQAAQD7lKezUqVNHw4cP16xZs7Ru3Tq1bNlSkpSQkKDg4GCnFggAAJAfeQo7H374obZu3apevXrp7bffVrly5SRJn332mRo0aODUAgEAAPIjT4+LqFGjhsPVWJf961//kocHT6AAAACuI097dsqUKaO//vor2/T09HRVqFAh30UBAAA4S57CzqFDh5SZmZltekZGho4ePZrvogAAAJwlV8ecFi9ebH+/fPlyBQQE2D9nZmZq1apVioyMdF51AAAA+ZSrsNOmTRtJks1mU5cuXRzmFSpUSBERERo9erTTigMAAMivXIWdy/fWiYyM1KZNm1S8ePFbUhQAAICz5OnSqYSEBGfXAQAAcEvk+TrxVatWadWqVTp+/Lh9j89l06ZNy3dhAAAAzpCnsDNs2DC98847qlOnjkJDQ2Wz2ZxdFwAAgFPkKexMnjxZM2bM0LPPPuvsegAAAJwqT/fZOX/+PI+FAAAAd4Q8hZ0XX3xRc+bMcXYtAAAATpenw1jp6emaMmWKVq5cqerVq6tQoUIO88eMGeOU4gAAAPIrT2Fn+/btqlmzpiRp586dDvM4WRkAALiSPIWdNWvWOLsOAACAWyJP5+wAAADcKfK0Z+eRRx657uGq1atX57mgq/3+++968803tXTpUp09e1blypXT9OnTVadOHUmSMUZDhgzR1KlTlZycrIYNG2rSpEkqX76802oAAAB3rjyFncvn61x24cIFxcfHa+fOndkeEJofp06dUsOGDfXII49o6dKlKlGihPbv36+iRYvalxk1apTGjRunTz75RJGRkRo0aJCaNWumXbt2ydvb22m1AACAO1Oews6HH36Y4/ShQ4cqLS0tXwVd6f3331d4eLimT59unxYZGWl/b4zR2LFjNXDgQLVu3VqSNHPmTAUHB2vhwoXq2LFjjuNmZGQoIyPD/jk1NdVpNQMAANfi1HN2nnnmGac+F2vx4sWqU6eOnnzySZUsWVK1atXS1KlT7fMTEhKUmJioqKgo+7SAgADVq1dPcXFx1xw3NjZWAQEB9ld4eLjTagYAAK7FqWEnLi7OqYeODh48aD//Zvny5Xr55ZfVp08fffLJJ5KkxMRESVJwcLDDesHBwfZ5OYmJiVFKSor9deTIEafVDAAAXEueDmM98cQTDp+NMTp27Jg2b96sQYMGOaUwScrKylKdOnX03nvvSZJq1aqlnTt3avLkyfk6N8jLy0teXl7OKhMAALiwPO3ZufIQUEBAgIKCgtS4cWN98803GjJkiNOKCw0N1b333uswrXLlyjp8+LAkKSQkRJKUlJTksExSUpJ9HgAAuLvlac/OlScM30oNGzbU3r17Habt27dPpUuXlnTpZOWQkBCtWrXKfoVYamqqNmzYoJdffvm21AgAAFxbnsLOZVu2bNHu3bslSVWqVFGtWrWcUtRlr732mho0aKD33ntPTz31lDZu3KgpU6ZoypQpki49mqJv374aPny4ypcvb7/0PCwsTG3atHFqLQAA4M6Up7Bz/PhxdezYUWvXrlVgYKAkKTk5WY888ojmzZunEiVKOKW4unXr6ssvv1RMTIzeeecdRUZGauzYsercubN9mQEDBujMmTPq0aOHkpOT9eCDD2rZsmXcYwcAAEjK4zk7vXv31unTp/XLL7/o5MmTOnnypHbu3KnU1FT16dPHqQW2atVKO3bsUHp6unbv3q3u3bs7zLfZbHrnnXeUmJio9PR0rVy5UhUqVHBqDQAA4M6Vpz07y5Yt08qVK1W5cmX7tHvvvVcTJ07Uo48+6rTiAAAA8itPe3aysrJUqFChbNMLFSqkrKysfBcFAADgLHkKO02aNNGrr76qP/74wz7t999/12uvvaamTZs6rTgAAID8ylPYmTBhglJTUxUREaGyZcuqbNmyioyMVGpqqsaPH+/sGgEAAPIsT+fshIeHa+vWrVq5cqX27Nkj6dLN/q58RhUAAIAryNWendWrV+vee+9VamqqbDab/v73v6t3797q3bu36tatqypVqui77767VbUCAADkWq7CztixY9W9e3f5+/tnmxcQEKCXXnpJY8aMcVpxAAAA+ZWrsLNt2zZFR0dfc/6jjz6qLVu25LsoAAAAZ8lV2ElKSsrxkvPLPDw89Oeff+a7KAAAAGfJVdi55557tHPnzmvO3759u0JDQ/NdFAAAgLPkKuy0aNFCgwYNUnp6erZ5586d05AhQ9SqVSunFQcAAJBfubr0fODAgfriiy9UoUIF9erVSxUrVpQk7dmzRxMnTlRmZqbefvvtW1IoAABAXuQq7AQHB+vHH3/Uyy+/rJiYGBljJF16GGezZs00ceJEBQcH35JCAQAA8iLXNxUsXbq0vvnmG506dUq//vqrjDEqX768ihYteivqAwAAyJc83UFZkooWLaq6des6sxYAAACny9OzsQAAAO4UhB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBpd1TYGTlypGw2m/r27Wuflp6erp49e6pYsWIqUqSI2rVrp6SkpIIrEgAAuJQ7Juxs2rRJ//nPf1S9enWH6a+99pq++uorLViwQOvWrdMff/yhJ554ooCqBAAAruaOCDtpaWnq3Lmzpk6dqqJFi9qnp6Sk6OOPP9aYMWPUpEkT3XfffZo+fbp+/PFH/fTTT9ccLyMjQ6mpqQ4vAABgTXdE2OnZs6datmypqKgoh+lbtmzRhQsXHKZXqlRJpUqVUlxc3DXHi42NVUBAgP0VHh5+y2oHAAAFy+XDzrx587R161bFxsZmm5eYmChPT08FBgY6TA8ODlZiYuI1x4yJiVFKSor9deTIEWeXDQAAXIRHQRdwPUeOHNGrr76qFStWyNvb22njenl5ycvLy2njAQAA1+XSYWfLli06fvy4ateubZ+WmZmp9evXa8KECVq+fLnOnz+v5ORkh707SUlJCgkJKYCKAcA5It76uqBLyLVDI1sWdAlAjlw67DRt2lQ7duxwmNatWzdVqlRJb775psLDw1WoUCGtWrVK7dq1kyTt3btXhw8fVv369QuiZAAA4GJcOuz4+fmpatWqDtMKFy6sYsWK2ae/8MIL6tevn4KCguTv76/evXurfv36euCBBwqiZAAA4GJcOuzcjA8//FBubm5q166dMjIy1KxZM3300UcFXRYAAHARd1zYWbt2rcNnb29vTZw4URMnTiyYggAAgEtz+UvPAQAA8oOwAwAALI2wAwAALI2wAwAALO2OO0EZt0/lQcvk5plZ0GUAAJAv7NkBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACWRtgBAACW5lHQBQAArCHira9v27ayzrtLipYkVR60TG6emXka59DIlk6sCq6KPTsAAMDSXDrsxMbGqm7duvLz81PJkiXVpk0b7d2712GZ9PR09ezZU8WKFVORIkXUrl07JSUlFVDFAADA1bh02Fm3bp169uypn376SStWrNCFCxf06KOP6syZM/ZlXnvtNX311VdasGCB1q1bpz/++ENPPPFEAVYNAABciUufs7Ns2TKHzzNmzFDJkiW1ZcsWNWrUSCkpKfr44481Z84cNWnSRJI0ffp0Va5cWT/99JMeeOCBgigbAAC4EJfes3O1lJQUSVJQUJAkacuWLbpw4YKioqLsy1SqVEmlSpVSXFzcNcfJyMhQamqqwwsAAFjTHRN2srKy1LdvXzVs2FBVq1aVJCUmJsrT01OBgYEOywYHBysxMfGaY8XGxiogIMD+Cg8Pv5WlAwCAAnTHhJ2ePXtq586dmjdvXr7HiomJUUpKiv115MgRJ1QIAABckUufs3NZr169tGTJEq1fv15/+9vf7NNDQkJ0/vx5JScnO+zdSUpKUkhIyDXH8/LykpeX160sGQAAuAiX3rNjjFGvXr305ZdfavXq1YqMjHSYf99996lQoUJatWqVfdrevXt1+PBh1a9f/3aXCwAAXJBL79np2bOn5syZo0WLFsnPz89+Hk5AQIB8fHwUEBCgF154Qf369VNQUJD8/f3Vu3dv1a9fnyuxAACAJBcPO5MmTZIkNW7c2GH69OnT1bVrV0nShx9+KDc3N7Vr104ZGRlq1qyZPvroo9tcKQAAcFUuHXaMMTdcxtvbWxMnTtTEiRNvQ0UAAOBO49Ln7AAAAOQXYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFiaR0EXYHURb31d0CXkStZ5d0nRBV0GAABOw54dAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaR4FXQAAAAUl4q2vC7qEu8KhkS0LdPvs2QEAAJZmmbAzceJERUREyNvbW/Xq1dPGjRsLuiQAAOACLBF2Pv30U/Xr109DhgzR1q1bVaNGDTVr1kzHjx8v6NIAAEABs0TYGTNmjLp3765u3brp3nvv1eTJk+Xr66tp06YVdGkAAKCA3fEnKJ8/f15btmxRTEyMfZqbm5uioqIUFxeX4zoZGRnKyMiwf05JSZEkpaamOr2+rIyzTh/zVso67ybp0veQlXFGMlkFWxDg4jLPp+vy3xyZGWeVxZ+Z24K/q+4st+Lf1yvHNcZcd7k7PuycOHFCmZmZCg4OdpgeHBysPXv25LhObGyshg0blm16eHj4LanxTvX7RwVdAXBnCLj85qPnCrKMuxZ/V7m+gLG3dvzTp08rICDgmvPv+LCTFzExMerXr5/9c1ZWlk6ePKlixYrJZrPla+zU1FSFh4fryJEj8vf3z2+pd5y7uf+7uXeJ/u/m/u/m3qW7u/+C7t0Yo9OnTyssLOy6y93xYad48eJyd3dXUlKSw/SkpCSFhITkuI6Xl5e8vLwcpgUGBjq1Ln9//7vul/5Kd3P/d3PvEv3fzf3fzb1Ld3f/Bdn79fboXHbHn6Ds6emp++67T6tWrbJPy8rK0qpVq1S/fv0CrAwAALiCO37PjiT169dPXbp0UZ06dXT//fdr7NixOnPmjLp161bQpQEAgAJmibDToUMH/fnnnxo8eLASExNVs2ZNLVu2LNtJy7eDl5eXhgwZku0w2d3ibu7/bu5dov+7uf+7uXfp7u7/TundZm50vRYAAMAd7I4/ZwcAAOB6CDsAAMDSCDsAAMDSCDsAAMDSCDtXOXnypDp37ix/f38FBgbqhRdeUFpa2nXXSU9PV8+ePVWsWDEVKVJE7dq1y3aTw8OHD6tly5by9fVVyZIl9cYbb+jixYsOy6xdu1a1a9eWl5eXypUrpxkzZmTb1u+//65nnnlGxYoVk4+Pj6pVq6bNmzfnu2/J9Xu/bOTIkbLZbOrbt29eW82RK/cfGxurunXrys/PTyVLllSbNm20d+/efPU7ceJERUREyNvbW/Xq1dPGjRuvu/yCBQtUqVIleXt7q1q1avrmm28c5htjNHjwYIWGhsrHx0dRUVHav3+/wzI38x1v375dDz30kLy9vRUeHq5Ro0blq8+cuGLva9euVevWrRUaGqrChQurZs2amj17tvOavoIr9n+lX3/9VX5+fk6/2avkur0bY/TBBx+oQoUK8vLy0j333KMRI0Y4p+kruGr/y5cv1wMPPCA/Pz+VKFFC7dq106FDh5zS8+VCcYXo6GhTo0YN89NPP5nvvvvOlCtXznTq1Om66/zjH/8w4eHhZtWqVWbz5s3mgQceMA0aNLDPv3jxoqlataqJiooyP//8s/nmm29M8eLFTUxMjH2ZgwcPGl9fX9OvXz+za9cuM378eOPu7m6WLVtmX+bkyZOmdOnSpmvXrmbDhg3m4MGDZvny5ebXX3+1fO+Xbdy40URERJjq1aubV1991Sl9X+bK/Tdr1sxMnz7d7Ny508THx5sWLVqYUqVKmbS0tDz1Om/ePOPp6WmmTZtmfvnlF9O9e3cTGBhokpKSclz+hx9+MO7u7mbUqFFm165dZuDAgaZQoUJmx44d9mVGjhxpAgICzMKFC822bdvM448/biIjI825c+fsy9zoO05JSTHBwcGmc+fOZufOnWbu3LnGx8fH/Oc//8lTn3dS7yNGjDADBw40P/zwg/n111/N2LFjjZubm/nqq6+c1rsr93/Z+fPnTZ06dUzz5s1NQEDAXdN77969TcWKFc2iRYvMwYMHzebNm8233357V/R/8OBB4+XlZWJiYsyvv/5qtmzZYho1amRq1arltN4JO1fYtWuXkWQ2bdpkn7Z06VJjs9nM77//nuM6ycnJplChQmbBggX2abt37zaSTFxcnDHGmG+++ca4ubmZxMRE+zKTJk0y/v7+JiMjwxhjzIABA0yVKlUcxu7QoYNp1qyZ/fObb75pHnzwwfw3mgNX790YY06fPm3Kly9vVqxYYR5++GGnhp07of8rHT9+3Egy69aty32zxpj777/f9OzZ0/45MzPThIWFmdjY2ByXf+qpp0zLli0dptWrV8+89NJLxhhjsrKyTEhIiPnXv/5ln5+cnGy8vLzM3LlzjTE39x1/9NFHpmjRovbvxphLv/cVK1bMU585cdXec9KiRQvTrVu33Dd5Ha7e/4ABA8wzzzxjpk+f7vSw46q979q1y3h4eJg9e/Y4p9FrcNX+FyxYYDw8PExmZqZ9mcWLFxubzWbOnz+fz64v4TDWFeLi4hQYGKg6derYp0VFRcnNzU0bNmzIcZ0tW7bowoULioqKsk+rVKmSSpUqpbi4OPu41apVc7jJYbNmzZSamqpffvnFvsyVY1xe5vIYkrR48WLVqVNHTz75pEqWLKlatWpp6tSp+W9crt+7JPXs2VMtW7bMtqwz3An9XyklJUWSFBQUlMtOpfPnz2vLli0O23Rzc1NUVNQ1t3mjGhMSEpSYmOiwTEBAgOrVq+fwXdzoO46Li1OjRo3k6enpsJ29e/fq1KlTue71aq7ce05SUlLy9DO+Flfvf/Xq1VqwYIEmTpyY/2av4sq9f/XVVypTpoyWLFmiyMhIRURE6MUXX9TJkyed07xcu//77rtPbm5umj59ujIzM5WSkqJZs2YpKipKhQoVckr/hJ0rJCYmqmTJkg7TPDw8FBQUpMTExGuu4+npme3YcnBwsH2dxMTEbHdzvvz5Rsukpqbq3LlzkqSDBw9q0qRJKl++vJYvX66XX35Zffr00SeffJK3hq/qw5V7nzdvnrZu3arY2Ni8NXgDrt7/lbKystS3b181bNhQVatWvfkm/8+JEyeUmZmZ4zav1+v1lr/83xstc6Pv+Ga+r/xw5d6vNn/+fG3atMmpj71x5f7/+usvde3aVTNmzLglD5R05d4PHjyo3377TQsWLNDMmTM1Y8YMbdmyRe3bt89jt9m5cv+RkZH69ttv9c9//lNeXl4KDAzU0aNHNX/+/Dx2m91dEXbeeust2Wy267727NlT0GXeUFZWlmrXrq333ntPtWrVUo8ePdS9e3dNnjz5mutYofcjR47o1Vdf1ezZs+Xt7Z2rda3Q/9V69uypnTt3at68eQVdCm6RNWvWqFu3bpo6daqqVKlS0OXcFt27d9fTTz+tRo0aFXQpt11WVpYyMjI0c+ZMPfTQQ2rcuLE+/vhjrVmzJt8XItwJEhMT1b17d3Xp0kWbNm3SunXr5Onpqfbt28s46SEPlng21o28/vrr6tq163WXKVOmjEJCQnT8+HGH6RcvXtTJkycVEhKS43ohISE6f/68kpOTHf4PPykpyb5OSEhItjPeL1+xc+UyV1/Fk5SUJH9/f/n4+EiSQkNDde+99zosU7lyZX3++efX7MsKvW/ZskXHjx9X7dq17fMzMzO1fv16TZgwQRkZGXJ3d7ds/1fq1auXlixZovXr1+tvf/vbdfu6luLFi8vd3T3HbV6v1+stf/m/SUlJCg0NdVimZs2a9mVu9B1faztXbiM/XLn3y9atW6fHHntMH374oZ577rncN3kdrtz/6tWrtXjxYn3wwQeSLl3lk5WVJQ8PD02ZMkXPP/98Hru+xJV7Dw0NlYeHhypUqGBfpnLlypIuXc1ZsWLF3LabjSv3P3HiRAUEBDhcefnf//5X4eHh2rBhgx544IE8dHwVp5z5YxGXT6TavHmzfdry5ctv6iTVzz77zD5tz549OZ6keuUZ7//5z3+Mv7+/SU9PN8ZcOimvatWqDmN36tTJ4STVTp06ZTtBuW/fvqZ+/fp57Ph/XLn31NRUs2PHDodXnTp1zDPPPONwVYBV+zfm0omAPXv2NGFhYWbfvn357vf+++83vXr1sn/OzMw099xzz3VPVGzVqpXDtPr162c7UfGDDz6wz09JScnxRMXrfceXT1C+8qTEmJgYp5+g7Iq9G2PMmjVrTOHChc2ECRPy3+g1uGr/u3btcvgzPnz4cOPn52d27NhhTp48aenely9fbiQ5XFkbHx9vJJm9e/fms+v/cdX++/XrZ+6//36H7fzxxx9Gkvnhhx/y0fH/EHauEh0dbWrVqmU2bNhgvv/+e1O+fHmHS+SOHj1qKlasaDZs2GCf9o9//MOUKlXKrF692mzevNnUr1/fIYBcvvz40UcfNfHx8WbZsmWmRIkSOV5+/MYbb5jdu3ebiRMnZrv8eOPGjcbDw8OMGDHC7N+/38yePdv4+vqa//73v5bv/WrOvhrL1ft/+eWXTUBAgFm7dq05duyY/XX27Nk89Tpv3jzj5eVlZsyYYXbt2mV69OhhAgMD7VeNPfvss+att96yL//DDz8YDw8P88EHH5jdu3ebIUOG5HgJamBgoFm0aJHZvn27ad26dY6XoF7vO05OTjbBwcHm2WefNTt37jTz5s0zvr6+Tr/03BV7X716tfH19TUxMTEOP+O//vrLab27cv9XuxVXY7lq75mZmaZ27dqmUaNGZuvWrWbz5s2mXr165u9///td0f+qVauMzWYzw4YNM/v27TNbtmwxzZo1M6VLl87z33FXI+xc5a+//jKdOnUyRYoUMf7+/qZbt27m9OnT9vkJCQlGklmzZo192rlz58wrr7xiihYtanx9fU3btm3NsWPHHMY9dOiQad68ufHx8THFixc3r7/+urlw4YLDMmvWrDE1a9Y0np6epkyZMmb69OnZ6vvqq69M1apVjZeXl6lUqZKZMmXKXdP7lW5F2HHl/iXl+LrR93Q948ePN6VKlTKenp7m/vvvNz/99JN93sMPP2y6dOnisPz8+fNNhQoVjKenp6lSpYr5+uuvHeZnZWWZQYMGmeDgYOPl5WWaNm2a7f9Kb/QdG2PMtm3bzIMPPmi8vLzMPffcY0aOHJnnHq/FFXvv0qVLjj/jhx9++K7o/2q3IuwY47q9//777+aJJ54wRYoUMcHBwaZr165OD7rGuG7/c+fONbVq1TKFCxc2JUqUMI8//rjZvXu30/q2GeOks38AAABc0F1xNRYAALh7EXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAWMaMGTMcHsqaFxERERo7dqxT6smLQ4cOyWazKT4+vsBqAKyGsANYnM1mu+5r6NCh+Rp74cKF+a4vL2PkFEo6dOigffv23dT61wpGmzZtUo8ePXJdDwDX5VHQBQC4tY4dO2Z//+mnn2rw4MHau3evfVqRIkUKoqxbwsfHRz4+Pvkao0SJEk6qBoCrYM8OYHEhISH2V0BAgGw2m8O0efPmqXLlyvL29lalSpX00Ucf2dc9f/68evXqpdDQUHl7e6t06dKKjY2VdGnPiiS1bdtWNpvN/vlqeRnjwIEDat26tYKDg1WkSBHVrVtXK1eutI/ZuHFj/fbbb3rttdfse6ik7Htrtm3bpkceeUR+fn7y9/fXfffdp82bN2vt2rXq1q2bUlJSsu3hunqPUXJysl566SUFBwfL29tbVatW1ZIlS3Ls9emnn1aHDh0cpl24cEHFixfXzJkzJUnLli3Tgw8+qMDAQBUrVkytWrXSgQMHcv7h5dCTJC1cuNDe82WLFi1S7dq15e3trTJlymjYsGG6ePHiNccF7ibs2QHuYrNnz9bgwYM1YcIE1apVSz///LO6d++uwoULq0uXLho3bpwWL16s+fPnq1SpUjpy5IiOHDki6dLhnpIlS2r69OmKjo6Wu7t7jtvIyxhpaWlq0aKFRowYIS8vL82cOVOPPfaY9u7dq1KlSumLL75QjRo11KNHD3Xv3v2a/XXu3Fm1atXSpEmT5O7urvj4eBUqVEgNGjTQ2LFjHfZy5bSHKysrS82bN9fp06f13//+V2XLltWuXbuu2Wvnzp315JNPKi0tzT7e8uXLdfbsWbVt21aSdObMGfXr10/Vq1dXWlqaBg8erLZt2yo+Pl5ubnn7/8/vvvtOzz33nMaNG6eHHnpIBw4csB+KGzJkSJ7GBCzFac9PB+Dypk+fbgICAuyfy5Yta+bMmeOwzLvvvmvq169vjDGmd+/epkmTJiYrKyvH8SSZL7/88rrbdMYYxhhTpUoVM378ePvn0qVLmw8//NBhmav78/PzMzNmzMhxvKuXzWnc5cuXGzc3N7N3794b1meMMRcuXDDFixc3M2fOtE/r1KmT6dChwzXX+fPPP40ks2PHDmOMMQkJCUaS+fnnn69Z55dffmmu/Ou7adOm5r333nNYZtasWSY0NPSm6gasjsNYwF3qzJkzOnDggF544QUVKVLE/ho+fLj9sErXrl0VHx+vihUrqk+fPvr2229zvZ28jJGWlqb+/furcuXKCgwMVJEiRbR7924dPnw4V9vu16+fXnzxRUVFRWnkyJHXPVyUk/j4eP3tb39ThQoVbmp5Dw8PPfXUU5o9e7akS9/xokWL1LlzZ/sy+/fvV6dOnVSmTBn5+/vbD93ltrcrbdu2Te+8847Dz7F79+46duyYzp49m+dxAavgMBZwl0pLS5MkTZ06VfXq1XOYd/kwTe3atZWQkKClS5dq5cqVeuqppxQVFaXPPvvspreTlzH69++vFStW6IMPPlC5cuXk4+Oj9u3b6/z587nqcejQoXr66af19ddfa+nSpRoyZIjmzZtnP6R0I3k52blz5856+OGHdfz4ca1YsUI+Pj6Kjo62z3/sscdUunRpTZ06VWFhYcrKylLVqlWv2Zubm5uMMQ7TLly44PA5LS1Nw4YN0xNPPJFtfW9v71z3AFgNYQe4SwUHByssLEwHDx502PNwNX9/f3Xo0EEdOnRQ+/btFR0drZMnTyooKEiFChVSZmbmDbeV2zF++OEHde3a1R5K0tLSdOjQIYdlPD09b2rbFSpUUIUKFfTaa6+pU6dOmj59utq2bXtT61evXl1Hjx7Vvn37bnrvToMGDRQeHq5PP/1US5cu1ZNPPqlChQpJkv766y/t3btXU6dO1UMPPSRJ+v777687XokSJXT69GmdOXNGhQsXlqRs9+CpXbu29u7dq3Llyt1UjcDdhrAD3MWGDRumPn36KCAgQNHR0crIyNDmzZt16tQp9evXT2PGjFFoaKhq1aolNzc3LViwQCEhIfargyIiIrRq1So1bNhQXl5eKlq0aLZt5GWM8uXL64svvtBjjz0mm82mQYMGKSsry2HciIgIrV+/Xh07dpSXl5eKFy/uMP/cuXN644031L59e0VGRuro0aPatGmT2rVrZ18/LS1Nq1atUo0aNeTr6ytfX1+HMR5++GE1atRI7dq105gxY1SuXDnt2bNHNpvNYW/N1Z5++mlNnjxZ+/bt05o1a+zTixYtqmLFimnKlCkKDQ3V4cOH9dZbb133Z1SvXj35+vrqn//8p/r06aMNGzZoxowZDssMHjxYrVq1UqlSpdS+fXu5ublp27Zt2rlzp4YPH37d8YG7QkGfNATg9snpZNfZs2ebmjVrGk9PT1O0aFHTqFEj88UXXxhjjJkyZYqpWbOmKVy4sPH39zdNmzY1W7duta+7ePFiU65cOePh4WFKly6d4zbzMkZCQoJ55JFHjI+PjwkPDzcTJkwwDz/8sHn11Vft68XFxZnq1asbLy8v+8m6V/aXkZFhOnbsaMLDw42np6cJCwszvXr1MufOnbOP8Y9//MMUK1bMSDJDhgwxxmQ/8fmvv/4y3bp1M8WKFTPe3t6matWqZsmSJdf9nnft2mUkmdKlS2c7MXvFihWmcuXKxsvLy1SvXt2sXbvW4STtq09QNubSCcnlypUzPj4+plWrVmbKlCnm6r++ly1bZho0aGB8fHyMv7+/uf/++82UKVOuWydwt7AZc9XBYAAAAAvhaiwAAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBphB0AAGBp/x+/Gx/57JJlcQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=0.001)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X[:,np.newaxis],Y[:,np.newaxis], my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is quite different, the performance of kernel tests indeed crucially depends on the chosen parameters.\n",
    "How to chose those in practice?\n",
    "\n",
    "For simple datasets, there is a heuristic rule to chose the parameter of a Gaussian kernel: using the median of the pairwise distances of the data.\n",
    "See https://arxiv.org/abs/1707.07269 for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6585612327494343\n"
     ]
    }
   ],
   "source": [
    "def gaussian_kernel_median_heuristic(Z):\n",
    "    # IMPLEMENT: compute the median of the pairwise distances in Z\n",
    "    # (not taking zero distance between identical samples (diagonal) into account)\n",
    "    sq_dists = sq_distances(Z)\n",
    "    np.fill_diagonal(sq_dists, np.nan)\n",
    "    sq_dists = np.ravel(sq_dists)\n",
    "    sq_dists = sq_dists[~np.isnan(sq_dists)]\n",
    "    median_dist = np.median(np.sqrt(sq_dists))\n",
    "\n",
    "    return np.sqrt(median_dist/2.0) # our kernel uses a bandwidth of 2*(sigma**2)\n",
    "\n",
    "sigma_median = gaussian_kernel_median_heuristic(np.vstack((X[:,np.newaxis],Y[:,np.newaxis])))\n",
    "print(sigma_median)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we could probably get away with sub-sampling the data to compute pair-wise distances to speed up computing the heuristic, as it stabilizes quickly.\n",
    "In addition, we should probably re-use the pairwise distances when computing the kernel matrix; again, see Shogun.\n",
    "\n",
    "Let's try the heuristic for the statistical test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=sigma_median)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X[:,np.newaxis],Y[:,np.newaxis], my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This worked great!\n",
    "But it doesn't always.\n",
    "\n",
    "Let's try the median heuristic on the following dataset, referred to as Gaussian blobs, see https://papers.nips.cc/paper/4727-optimal-kernel-choice-for-large-scale-two-sample-tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.load(\"./data/blobs_zoomed.npz\")\n",
    "X = data[\"X\"]\n",
    "Y = data[\"Y\"]\n",
    "plt.plot(X[:,0], X[:,1], 'b.', alpha=0.5)\n",
    "plt.plot(Y[:,0], Y[:,1], 'r.', alpha=0.5)\n",
    "plt.title(\"One blob\")\n",
    "\n",
    "plt.figure()\n",
    "data = np.load(\"./data/blobs.npz\")\n",
    "X = data[\"X\"]\n",
    "Y = data[\"Y\"]\n",
    "plt.plot(X[:,0], X[:,1], 'b.', alpha=0.5)\n",
    "plt.plot(Y[:,0], Y[:,1], 'r.', alpha=0.5);\n",
    "plt.title(\"All blobs\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly, the two distributions are very different.\n",
    "On the grid, the scale at which they differ, however, is somewhat invisible from the median heuristic, which looks at global scaling of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "median bw/sigma: 51.60189981691304 / 5.079463545341823\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sigma_median = gaussian_kernel_median_heuristic(np.vstack((X,Y)))\n",
    "print(\"median bw/sigma:\", 2*(sigma_median**2), \"/\", sigma_median)\n",
    "\n",
    "# IMPLEMENT: visualize test using median heuristic\n",
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=sigma_median)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X,Y, my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Somehow, the median distance does not really represent the scale on which the two distribution are differing here (they clearly do!).\n",
    "We have figure out how to fix that though."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using cross-validation to select a single kernel parameter\n",
    "\n",
    "As a modern ML scientist, your first reflex might be to just try a bunch of different kernel parameters, and compute a cross-validation estimate of the test power.\n",
    "This involves computing the test for the \"training partitions\" of every fold, and average the number of rejections.\n",
    "Let's start with that.\n",
    "Note that we have to use a different \"training\" dataset to learn the kernel -- otherwise the test would over-fit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's start with few values\n",
    "log_sigmas = np.array([-5, 0., 10])\n",
    "\n",
    "num_folds = 5\n",
    "data = np.load(\"./data/blobs2.npz\")\n",
    "X_learn = data[\"X\"]\n",
    "Y_learn = data[\"Y\"]\n",
    "\n",
    "from sklearn.model_selection import KFold\n",
    "\n",
    "test_powers = np.zeros(len(log_sigmas))\n",
    "np.random.seed(0)\n",
    "\n",
    "for i, log_sigma in tqdm(list(enumerate(log_sigmas))):\n",
    "    # IMPLEMENT: define kernel and mmd\n",
    "    my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=10**log_sigma)\n",
    "    my_mmd = lambda X,Y : quadratic_time_mmd(X,Y, my_kernel)\n",
    "    kf = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "    rejects = []\n",
    "    for train, _ in  kf.split(X_learn):\n",
    "        # IMPLEMENT: split data into train and test folds\n",
    "        X_learn_train = X_learn[train]\n",
    "        Y_learn_train = Y_learn[train]\n",
    "\n",
    "        # IMPLEMENT: compute test statistic and null distribution, use prog_bar=False\n",
    "        statistics = two_sample_permutation_test(my_mmd, X_learn_train, Y_learn_train, num_permutations, prog_bar=False)\n",
    "        my_statistic = my_mmd(X_learn_train, Y_learn_train)\n",
    "\n",
    "        # IMPLEMENT: compute p-value as the quantile of the test statistic in the null distribution\n",
    "        p_value = np.mean(my_statistic <= np.sort(statistics))\n",
    "        rejects += [p_value<0.05]\n",
    "\n",
    "    test_powers[i] = np.mean(rejects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(log_sigmas, test_powers)\n",
    "plt.xlabel(\"Log sigma\")\n",
    "plt.ylabel(\"Test power estimate\")\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems to give us an idea of which kernel parameter is better.\n",
    "Unfortunately, this approach is quite costly and noisy.\n",
    "In reality, we would also want to use more folds, repeat the x-validation, and try out more kernel parameters (play with it and you will see).\n",
    "\n",
    "We could try one of the faster approximations for the null distribution mentioned above, for example the moment matching Gamma approach.\n",
    "This would speed up the procedure, however, the Gamma approximation has its limits in how accurate it is, especially for extreme values of the kernel.\n",
    "\n",
    "Instead, we will do something better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimal kernel via maximising the ratio of mmd and its variance, see https://arxiv.org/abs/1611.04488"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen that estimating the test power using cross-validation is a bit messy; it is also not differentiable.\n",
    "\n",
    "Luckily, there is a closed form criterion that acts as a surrogate for the test power: the MMD divided by its variance.\n",
    "You have seen in the slides that maximising this directly maximises the power of the statistical test -- without ever computing the test.\n",
    "\n",
    "Long story short, you can\n",
    "\n",
    "1. Pick a training set (not the one you use for performing the test, to avoid overfitting)\n",
    "2. Choose the kernel that maximises the value of the MMD, divided by its standard variance\n",
    "3. Enjoy a test that has higher power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As implementing the variance of the MMD estimator is slightly more complicated, we have provided a TensorFlow implementation for you (so we can later automagically differentiate it).\n",
    "Feel free to examine the imported code in `mmd.py`.\n",
    "\n",
    "(Note that the provided implementation uses a biased MMD statistic, and as such produces slightly different numbers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'tensorflow'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32mc:\\Git\\ds3_kernel_testing\\solutions.ipynb Cell 69\u001b[0m line \u001b[0;36m2\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Git/ds3_kernel_testing/solutions.ipynb#Y130sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# provided implementation\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Git/ds3_kernel_testing/solutions.ipynb#Y130sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mtf\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Git/ds3_kernel_testing/solutions.ipynb#Y130sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmmd\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Git/ds3_kernel_testing/solutions.ipynb#Y130sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mSession() \u001b[39mas\u001b[39;00m sess:\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'tensorflow'"
     ]
    }
   ],
   "source": [
    "# provided implementation\n",
    "import tensorflow as tf\n",
    "import mmd\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess.run(init)\n",
    "    print(\"MMD and ratio:\", sess.run(mmd.rbf_mmd2_and_ratio(X,Y, sigma=sigma_median)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen above, the most naive way to select a kernel to to come up with a number of baseline kernels, then simply compute the ratio of MMD and standard deviation for all of them, and finally to pick the kernel with the largest ratio.\n",
    "Remember it is important to do this on a separate \"training\" dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best sigma: 0.21544346900318834\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.load(\"./data/blobs2.npz\")\n",
    "X_learn = data[\"X\"]\n",
    "Y_learn = data[\"Y\"]\n",
    "\n",
    "# sigma = 10**log_sigma\n",
    "log_sigmas = np.linspace(-2, 2,10)\n",
    "\n",
    "ratios = np.empty(len(log_sigmas))\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess.run(init)\n",
    "\n",
    "    # IMPLEMENT: compute ratio for every sigma\n",
    "    for i, log_sigma in tqdm(list(enumerate(log_sigmas))):\n",
    "        current_ratio = sess.run(mmd.rbf_mmd2_and_ratio(X_learn,Y_learn, sigma=10**log_sigma))[1]\n",
    "        ratios[i] = current_ratio\n",
    "\n",
    "plt.plot(log_sigmas, ratios)\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"Log sigma\")\n",
    "plt.ylabel(\"Ratio of MMD and variance (proportional to test power)\")\n",
    "\n",
    "print(\"best sigma:\", 10**log_sigmas[np.argmax(ratios)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was much faster, even for more parameters to try.\n",
    "\n",
    "The curve looks very much like those obtained when cross-validating kernel-parameters for kernel machines (like a support vector machine): you make the model/test more and more complex (bandwidth smaller), until it hits a sweet spot (peak), and after which it starts overfitting (ratio decreasing).\n",
    "Let's try out how it worked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sigma_opt = 0.215\n",
    "\n",
    "# IMPLEMENT: visualise test for best sigma\n",
    "my_kernel = lambda X,Y : gauss_kernel(X,Y,sigma=sigma_opt)\n",
    "my_mmd = lambda X,Y : quadratic_time_mmd(X,Y, my_kernel)\n",
    "\n",
    "statistics = two_sample_permutation_test(my_mmd, X, Y, num_permutations)\n",
    "my_statistic = my_mmd(X,Y)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Victory!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient descent\n",
    "Now, what if we have more than one kernel parameter?\n",
    "Trying out all the different combinations is not the best idea.\n",
    "Instead, we can take a deep learning artisan's mindset and do gradient descent.\n",
    "That is, we maximize the ratio of MMD to standard deviation as a function of the kernel parameters (differentiable!), we could even do this in mini-batches.\n",
    "\n",
    "The implementation of the ratio is quite tricky (you might have checked the imported code).\n",
    "Differentiating it would be a nightmare, but luckily in 2018 we have tools at hand that allow us to do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GANs\n",
    "\n",
    "Moving to the context of training GANs (Generative adversarial networks).\n",
    "Assume someone came to you with a new GAN, which generates some realistic looking images, supposedly indistinguishable from the images used to train the GAN.\n",
    "\n",
    "Let's assume that person said (https://arxiv.org/abs/1606.03498)\n",
    "> On MTurk, annotators were able to distinguish\n",
    "samples in 52.4% of cases (2000 votes total), where 50% would be obtained by random\n",
    "guessing. Similarly, researchers in our institution were not able to find any artifacts that would allow\n",
    "them to distinguish samples.\n",
    "\n",
    "Let's see what the kernel MMD thinks about this.\n",
    "We will use a slightly different kernel than before: an ARD kernel.\n",
    "This one that scales each of the $D$ input dimensions by a parameter, and then uses a standard Gaussian kernel (unit bandwidth) on top of that.\n",
    "$$ k(x,y) = \\exp\\left(-\\sum_d^D (x_d/\\sigma_d - y_d/\\sigma_d)^2\\right) $$\n",
    "Again, we have implemented this for you in `mmd.py`, feel free to see how.\n",
    "\n",
    "We begin with visualizing the data, and splitting it into train and test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image dimensions: 28x28=784\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.load(\"./data/samples-to-compare.npz\")[\"target\"]\n",
    "# before fitting the model, we binarized the images\n",
    "X[X<0.5]=0\n",
    "X[X>=0.5]=1\n",
    "\n",
    "Y = np.load(\"./data/samples-to-compare.npz\")[\"model\"]\n",
    "\n",
    "plt.figure(figsize=(12,3))\n",
    "plt.suptitle(\"Train samples\")\n",
    "\n",
    "for i in np.arange(0,16):\n",
    "    plt.subplot(2,8,i+1)\n",
    "    plt.imshow(X[i],cmap='gray')\n",
    "    plt.axis('off')\n",
    "plt.figure(figsize=(12,3))\n",
    "plt.suptitle(\"GAN samples\")\n",
    "for i in np.arange(0,16):\n",
    "    plt.subplot(2,8,i+1)\n",
    "    plt.imshow(Y[i],cmap='gray')\n",
    "    plt.axis('off')\n",
    "\n",
    "# split off a training set, reshape to vectors\n",
    "N = len(X)\n",
    "assert len(X) == len(Y)\n",
    "size = X.shape[1]\n",
    "size2 = size**2\n",
    "assert size2 == X.shape[2]**2\n",
    "half = int(N/2)\n",
    "X_learn = X[half:].reshape(half,size2)\n",
    "Y_learn = Y[half:].reshape(half,size2)\n",
    "X = X[:half].reshape(half,size2)\n",
    "Y = Y[:half].reshape(half,size2)\n",
    "\n",
    "print(\"Image dimensions: %dx%d=%d\" % (size, size, size2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have some code to compute the ratio we want to optimize, and make TensorFlow's Adam optimizer do the rest for us, i.e optimizing the bandwidth variables, $28^2$ of them.\n",
    "\n",
    "Note: this is a very simplistic implementation that might suffer from all sorts of problems.\n",
    "In practice, we would pay more careful attention to the optimization scheme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start, ratio: 0.1268358\n",
      "step, ratio: 0.1310806\n",
      "step, ratio: 0.14533705\n",
      "step, ratio: 0.17821728\n",
      "step, ratio: 0.24888371\n",
      "step, ratio: 0.39294672\n",
      "step, ratio: 0.6644053\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-32-0699506fef2d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mstep\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m         \u001b[0;31m# IMPLEMENT: run optimizer and update best found sigmas so far\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m         \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mminimize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"step,\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"ratio:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mratio\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m         \u001b[0mbest_sigmas\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msigmas\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    898\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    899\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 900\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    901\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    902\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1133\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mhandle\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1134\u001b[0m       results = self._do_run(handle, final_targets, final_fetches,\n\u001b[0;32m-> 1135\u001b[0;31m                              feed_dict_tensor, options, run_metadata)\n\u001b[0m\u001b[1;32m   1136\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1137\u001b[0m       \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_run\u001b[0;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1314\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1315\u001b[0m       return self._do_call(_run_fn, feeds, fetches, targets, options,\n\u001b[0;32m-> 1316\u001b[0;31m                            run_metadata)\n\u001b[0m\u001b[1;32m   1317\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1318\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_prun_fn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeeds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetches\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m   1320\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1321\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1322\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1323\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1324\u001b[0m       \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_text\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run_fn\u001b[0;34m(feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[1;32m   1305\u001b[0m       \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extend_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1306\u001b[0m       return self._call_tf_sessionrun(\n\u001b[0;32m-> 1307\u001b[0;31m           options, feed_dict, fetch_list, target_list, run_metadata)\n\u001b[0m\u001b[1;32m   1308\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1309\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_prun_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/software/anaconda3/envs/ds3_kernels/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_call_tf_sessionrun\u001b[0;34m(self, options, feed_dict, fetch_list, target_list, run_metadata)\u001b[0m\n\u001b[1;32m   1407\u001b[0m       return tf_session.TF_SessionRun_wrapper(\n\u001b[1;32m   1408\u001b[0m           \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1409\u001b[0;31m           run_metadata)\n\u001b[0m\u001b[1;32m   1410\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1411\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_exception_on_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "sigmas = tf.Variable(np.ones(X_learn.shape[1]), dtype=np.float32, name=\"sigmas\")\n",
    "\n",
    "# provided function. note we are using the \"training\" dataset here.\n",
    "ratio = mmd.ard_mmd2_and_ratio(X_learn,Y_learn, bws=sigmas)[1]\n",
    "\n",
    "# IMPLEMENT: set up adam optimizer tensorflow op to maximise the ratio\n",
    "learning_rate = 0.5\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "minimize = optimizer.minimize(-ratio)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "\n",
    "    print(\"start,\", \"ratio:\", sess.run(ratio))\n",
    "\n",
    "    for step in range(20):\n",
    "        # IMPLEMENT: run optimizer and update best found sigmas so far\n",
    "        sess.run(minimize)\n",
    "        print(\"step,\", \"ratio:\", sess.run(ratio))\n",
    "        best_sigmas = sess.run(sigmas)\n",
    "    print(\"done, ratio:\", sess.run(ratio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we now have learnt one bandwidth per pixel, we can visualise the scaled data to see what the resulting test focusses on.\n",
    "Note that we do this on the actual test data, while we learned the weights on the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENT: scale images according to sigmas\n",
    "X_scaled = (X/best_sigmas)\n",
    "Y_scaled = (Y/best_sigmas)\n",
    "\n",
    "plt.suptitle(\"Train samples\")\n",
    "plt.figure(figsize=(12,3))\n",
    "for i in np.arange(0,16):\n",
    "    plt.subplot(2,8,i+1)\n",
    "    plt.imshow(X_scaled[i].reshape(size, size),cmap='gray')\n",
    "    plt.axis('off')\n",
    "plt.figure(figsize=(12,3))\n",
    "plt.suptitle(\"GAN samples\")\n",
    "for i in np.arange(0,16):\n",
    "    plt.subplot(2,8,i+1)\n",
    "    plt.imshow(Y_scaled[i].reshape(size, size),cmap='gray')\n",
    "    plt.axis('off')\n",
    "plt.figure()\n",
    "plt.title(\"ARD weights\")\n",
    "plt.imshow(best_sigmas.reshape(size,size), 'magma')\n",
    "plt.colorbar()\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, there seem to be pixel level artifacts that the test focuses on.\n",
    "As it turns out, focusing on those allows the test to fully distinguish training samples from GAN samples.\n",
    "\n",
    "Since our above implementation for the MMD permutation test is very inefficient, we don't use it here to perform the full test -- it would take too long.\n",
    "You can use the below Shogun snippet to perform the test much more quickly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shogun as sg\n",
    "sg.get_global_parallel().set_num_threads(4)\n",
    "\n",
    "sigma = 1\n",
    "kernel_width = 2 * sigma**2\n",
    "mmd = sg.QuadraticTimeMMD()\n",
    "mmd.set_p(sg.RealFeatures(X_scaled.T.astype(np.float64))) # shogun uses column major format\n",
    "mmd.set_q(sg.RealFeatures(Y_scaled.T.astype(np.float64)))\n",
    "mmd.set_kernel(sg.GaussianKernel(10, kernel_width))\n",
    "\n",
    "mmd.set_num_null_samples(num_permutations)\n",
    "statistics = mmd.sample_null()\n",
    "my_statistic = mmd.compute_statistic()\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# IMPLEMENT (optional): how does this compare to all weights being one.\n",
    "sigma = 1\n",
    "kernel_width = 2 * sigma**2\n",
    "mmd = sg.QuadraticTimeMMD()\n",
    "mmd.set_p(sg.RealFeatures(X.T.astype(np.float64)))\n",
    "mmd.set_q(sg.RealFeatures(Y.T.astype(np.float64)))\n",
    "mmd.set_kernel(sg.GaussianKernel(10, kernel_width))\n",
    "\n",
    "mmd.set_num_null_samples(num_permutations)\n",
    "statistics = mmd.sample_null()\n",
    "my_statistic = mmd.compute_statistic()\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that the unscaled features already allow the test to distinguish the distribution quite well.\n",
    "The scaled version above, however, is a much more powerful test."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notes\n",
    "\n",
    "Have much more data? Try the linear time versions of the tests\n",
    "* https://arxiv.org/abs/1605.06796\n",
    "* https://arxiv.org/abs/1506.04725\n",
    "\n",
    "\n",
    "Need faster implementations (of the quadratic time MMD tests)\n",
    "* use Shogun!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independence testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's move on to independence testing.\n",
    "Here, the data we observe is in pairs $(x_i,y_i)\\sim P_{XY}$..\n",
    "The null hypothesis is that the two sets of samples come from independent distributions: $P_{XY} = P_X\\cdot P_Y$.\n",
    "\n",
    "We will use the HSIC, which you can think of as the MMD between the joint distribution $P_{XY}$ and the product of the marginal distributions $P_X P_Y$. \n",
    "Clearly, if those are different, then the samples cannot be independent.\n",
    "\n",
    "See the slides for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quadratic time test statistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's kick of with implementing the quadratic time version of the HSIC statistic.\n",
    "\n",
    "$$ \\frac{1}{n^2}\\text{Trace}(KL) $$\n",
    "\n",
    "where $K$ and $L$ are centered kernel matrices of the samples from the two distribution respectively.\n",
    "(Note that one can center a kernel matrix via multiplying it with a centering matrix $H=I-\\frac{1}{n}\\mathbf{1}\\mathbf{1}^\\top$.)\n",
    "\n",
    "As our kernel will quite expensive to be computed, we here write a version that accepts precomputed kernel matrices rather than a kernel function, and we will permute this kernel matrix for the permutation test.\n",
    "We implement the test statistic as a function of kernel matrices, and with an option to permute the matrices before computing the statistic (for approximating the null distribution).\n",
    "\n",
    "Note that the permutation for dependence testing is different from two-sample testing: in two sample testing, we could just permute the joint kernel matrix (as there is a kernel between $X$ and $Y$).\n",
    "For dependence testing, however, the kernel only is defined between $X$ and itself and $Y$ and itself.\n",
    "\"Breaking\" any potential structure therefore means that we need to shuffle the samples within $X$ and within $Y$ so that any potential pairs $(x_i,y_i)$ do not occur together anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def HSIC(K_XX, K_YY, permute=False):\n",
    "    assert len(K_XX) == len(K_YY)\n",
    "    N = len(K_XX)\n",
    "    if permute:\n",
    "        # IMPLEMENT: permute the kernel matrices for X and Y\n",
    "        inds_X = np.random.permutation(len(K_XX))\n",
    "        inds_Y = np.random.permutation(len(K_YY))\n",
    "        K_XX_ = K_XX[inds_X, :][:, inds_X]\n",
    "        K_YY_ = K_YY[inds_Y, :][:, inds_Y]\n",
    "    else:\n",
    "        K_XX_ = K_XX\n",
    "        K_YY_ = K_YY\n",
    "\n",
    "    # IMPLEMENT: HSIC statistic\n",
    "    H = np.eye(N) - 1.0/N\n",
    "    statistic = np.trace(K_XX_.dot(H).dot(K_YY_.dot(H))) / (N**2)\n",
    "    return statistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a simple dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "data = np.load(\"./data/hsic2.npz\")\n",
    "X = data[\"X\"]\n",
    "Y = data[\"Y\"]\n",
    "plt.plot(X,Y,'.')\n",
    "plt.axis('equal')\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly, there is some very simple dependence going on.\n",
    "The first thing a statistician in the field would do is of course to check for correlation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENT: produce a seaborn pairplot to show the correlation between X and Y\n",
    "print(\"Correlation between X and Y:\", np.corrcoef(X,Y)[0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correlation is very low.\n",
    "A kernel test for independence is more powerful, even with a bandwidth parameter chosen by the median heuristic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENT: compute kernel matrices using the median heuristic\n",
    "sigma_median = gaussian_kernel_median_heuristic(np.vstack((X[:,np.newaxis],Y[:,np.newaxis])))\n",
    "my_kernel = lambda X,Y : gauss_kernel(X[:,np.newaxis],Y[:,np.newaxis],sigma=sigma_median)\n",
    "K_XX = my_kernel(X,X)\n",
    "K_YY = my_kernel(Y,Y)\n",
    "K_XY = my_kernel(X,Y)\n",
    "\n",
    "statistics = np.empty(num_permutations)\n",
    "for i in tqdm(range(num_permutations)):\n",
    "    # IMPLEMENT: compute HSIC statistic with permuted matrices\n",
    "    statistics[i] = HSIC(K_XX, K_YY, permute=True)\n",
    "\n",
    "# IMPLEMENT: visualise test\n",
    "my_statistic = HSIC(K_XX, K_YY)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Victory once again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## European parliament documents translations and string kernels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now do a slightly more elaborate test that involves some very mild NLP.\n",
    "More precisely we will analyze dependence between documents.\n",
    "We will use transcripts of the Canadian parliament's house debates, downloaded from [here](https://www.isi.edu/natural-language/download/hansard/).\n",
    "Those consist of pairs of French and English transcripts.\n",
    "\n",
    "Our question here is whether we can detect this supposedly strong dependence structure using the kernel HSIC.\n",
    "Note that this approach does not rely on attempting to translate the documents, but rather on comparing within-document structure. \n",
    "HSIC compares the self-similarity within the English documents with self-similarity of the French ones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a first step, we load the data, and store the transcript of each session into lists X and Y, for English and French respectively.\n",
    "We don't do any sophisticated preprocessing here, but feel free to make this more elaborate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download english and french stopwords (optional)\n",
    "try:\n",
    "    import nltk\n",
    "    from nltk.corpus import stopwords\n",
    "    nltk.download('stopwords');\n",
    "    stop_english = set(stopwords.words(\"english\"))\n",
    "    stop_french = set(stopwords.words(\"french\"))\n",
    "except Exception:\n",
    "    stop_english = set()\n",
    "    stop_french = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import re\n",
    "\n",
    "X = []\n",
    "Y = []\n",
    "for fname in tqdm(sorted(list(glob(\"transcripts/hansard.36.1.house.debates.*.*\")))):\n",
    "    is_french = fname.endswith(\"f\")\n",
    "    is_english = fname.endswith(\"e\")\n",
    "\n",
    "    if not (is_english or is_french):\n",
    "        continue\n",
    "\n",
    "    with open(fname, \"r\", encoding='latin-1') as f:\n",
    "        # some very very simple preprocessing, could be more elaborate with special characters\n",
    "        content = \"\".join(f.readlines())\n",
    "        if is_english:\n",
    "            letters_only = re.sub(\"[^a-zA-Z]\", \" \", content)\n",
    "        elif is_french:\n",
    "            letters_only = re.sub(\"[^a-zA-Z\\'ÁÀÂÉÈÊéèáàêâúùûÚÙÛçîô']\", \" \", content)\n",
    "        words = letters_only.lower().split()\n",
    "\n",
    "        if is_english:\n",
    "            stops = stop_english\n",
    "        elif is_french:\n",
    "            stops = stop_french\n",
    "        meaningful_words = [w for w in words if not w in stops]\n",
    "\n",
    "        result = \" \".join(meaningful_words)\n",
    "\n",
    "        if fname.endswith(\"e\"):\n",
    "            X += [result]\n",
    "        else:\n",
    "            Y += [result]\n",
    "N = len(X)\n",
    "assert N == len(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at some excerpts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(X[0][-100:])\n",
    "print(Y[0][-100:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we are going to construct a string kernel, a  \"bag of words\" kernel between documents $s$ and $t$,\n",
    "\n",
    "$$\n",
    "k(s,t) = \\frac{1}{|\\mathcal{W}|} \\phi(s)^\\top \\phi(t)\n",
    "$$\n",
    "\n",
    "where $\\mathcal{W}$ consists of all words on all considered documents, and each element of $\\phi(x)\\in\\mathbb{N}^{|\\mathcal{W}|}$ contains the number of times that a particular word $w\\in\\mathcal{W}$ appears in $x$.\n",
    "\n",
    "Naturally, the kernel value will be larger, if a word appears in both documents many times.\n",
    "\n",
    "Efficient implementations of string kernels are rare (Shogun has many!), and often based on low-level dynamic programming concepts.\n",
    "Instead, we will here explicitly embed the documents into a feature space and compute (gram) matrix of inner products manually. \n",
    "Note that most string kernel implementations are much more efficient in computing the kernel since they don't do the feature space mapping explicitly.\n",
    "\n",
    "Let's start by building a document embedding mechanism using scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# IMPLEMENT: fit a vectorizer for the joint set of documents\n",
    "vectorizer = CountVectorizer(analyzer = \"word\",\n",
    "                             decode_error = 'replace',\n",
    "                             tokenizer = None,\n",
    "                             preprocessor = None,\n",
    "                             stop_words = None,\n",
    "                             max_features = 50000)\n",
    "vectorizer.fit(X+Y),"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can look at associated words for each feature space dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "feature_names = np.array(vectorizer.get_feature_names())\n",
    "np.random.seed(0)\n",
    "list(feature_names[np.random.permutation(len(feature_names))[-10:]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's define the bag of words kernel, as a product of embedded documents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bag_of_words_kernel(fitted_vectoriser, X,Y):\n",
    "    \"\"\"\n",
    "    Computes the gram matrix between the features of X and Y, where the features are computed\n",
    "    using the provided (fitted) sklearn transformer.\n",
    "\n",
    "    The kernel is k(x,y) = 1/dim(x) * \\phi(x) \\cdot \\phi(y)\n",
    "    \"\"\"\n",
    "    # IMPLEMENT: transform X and Y documents\n",
    "    X_feats = fitted_vectoriser.transform(X)\n",
    "    if X is Y :\n",
    "        Y_feats = X_feats\n",
    "    else:\n",
    "        Y_feats = fitted_vectoriser.transform(Y)\n",
    "\n",
    "    # IMPLEMENT: compute (dense) gram matrix of pariwise inner products of feature vectors\n",
    "    K = X_feats.dot(Y_feats.T).todense() / len(vectorizer.get_feature_names())\n",
    "    return K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at the kernel matrices (takes some time to compute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPLEMENT: compute kernel matrices between feature vectors using the bag of words kernel\n",
    "my_kernel = lambda X,Y: bag_of_words_kernel(vectorizer, X,Y)\n",
    "K_XX = my_kernel(X,X)\n",
    "K_YY = my_kernel(Y,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "plt.subplot(121)\n",
    "plt.imshow(K_XX)\n",
    "plt.subplot(122)\n",
    "plt.imshow(K_YY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a lot of shared (self-similarity) structure between X and Y.\n",
    "The HSIC test quantifies this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# IMPLEMENT: visualise HSIC test for given kernel matrices\n",
    "statistics = np.empty(num_permutations)\n",
    "for i in tqdm(range(num_permutations)):\n",
    "    statistics[i] = HSIC(K_XX, K_YY, permute=True)\n",
    "my_statistic = HSIC(K_XX, K_YY)\n",
    "plot_permutation_samples(statistics, my_statistic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A clear reject of the null hypothesis that X and Y are independent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notes\n",
    "\n",
    "As for the MMD, there are various linear time tests available for the HSIC, in particular https://arxiv.org/abs/1610.04782."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Goodness of fit testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final topic is testing whether a given set of samples comes from a specified distribution.\n",
    "This problem is slightly different from two-sample and independence testing as we are only given a single set of samples, and the reference distribution will be only available through the gradient of the log density (we cannot sample from it).\n",
    "\n",
    "But there are also similarities, i.e. the test statistic is the RKHS norm of a witness function, we can evaluate the witness function, there is a simple kernel-based quadratic time statistic, etc.\n",
    "\n",
    "Unfortunately, as we cannot sample from the reference distribution, we cannot permute our samples in any way to approximate the null distribution.\n",
    "We will use a slightly more sophisticated (still sampling based) way, called the wild bootstrap.\n",
    "This method was originally developed to approximate null distributions for two-sample tests of correlated samples, however, it turns out that we can also utilise the technique for cases where we cannot permute samples.\n",
    "\n",
    "We start with a simple example where we provide you with code to compute test statistic and p-value.\n",
    "The reest of his section is intentionally kept more sparse, encouraging faster participants to implement more advanced concepts on their own.\n",
    "\n",
    "As usual, see the slides for details.\n",
    "\n",
    "The two main references are\n",
    " * https://arxiv.org/abs/1602.02964\n",
    " * https://arxiv.org/abs/1705.07673 (NIPS 2017 best paper award)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing samples of a student-t against a Gaussian\n",
    "\n",
    "We will begin with a simple synthetic example: given a number of samples from a student-t distribution, can we reject the null hypothesis that those samples came from a Gaussian.\n",
    "How does the test change as we make the student-t look more and more like a Gaussian?\n",
    "\n",
    "Remember, we will only use the gradient of the log-density of the reference Gaussian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_log_normal(x):\n",
    "    \"\"\"\n",
    "    Returns the gradient of the log Gaussian density (zero mean, std-dev)\n",
    "    \"\"\"\n",
    "\n",
    "    # IMPLEMENT:\n",
    "    grad = -x\n",
    "\n",
    "    return  grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distributions of p-values\n",
    "\n",
    "In the beginning of this notebook, we saw that every time a statistical test is computed, we only receive a single test statistic.\n",
    "This is a single sample from the alternative distribution, and leads to a single p-value  (remember the example where we explicitly sampled from the alternative distribution?).\n",
    "\n",
    "Again, this number clearly depends on the data used for the test, a different set of test data will lead to a different test statistic and p-value (while the estimated null distribution should be stable).\n",
    "Under the null hypothesis of any test, the distribution of p-values is uniform, since we just take a sample from the very same distribution and then compute its quantile.\n",
    "Long story short: we never know whether we just have been \"lucky\" when computing the test.\n",
    "\n",
    "In order to get a feeling for this effect, we will now run the goodness-of-fit test multiple times and plot the distribution over p-values.\n",
    "We will perform this experiment using samples from a [student-t distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution), and test the null hypothesis that these samples are distributed as a standard Gaussian.\n",
    "As the degrees of freedom are increasing, the samples look more and more Gaussian, and we will quantify the distribution of p-values along the way.\n",
    "\n",
    "Since we need to compute the test many times to sample the distribution of p-values, the quadratic time statistic would take a long time.\n",
    "This is why we have provided an implementation of a linear-time goodness-of-fit test using the kernel Stein discrepancy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "from ksd import GaussianSteinTest\n",
    "\n",
    "# parameter for the linear time test (see paper if interested)\n",
    "num_random_freq=2\n",
    "\n",
    "N = 500\n",
    "\n",
    "degrees_of_freedom = range(1, 10, 2)\n",
    "num_repetitions = 200\n",
    "results = []\n",
    "\n",
    "for dof, mc in tqdm(list(itertools.product(degrees_of_freedom, range(num_repetitions)))):\n",
    "    # IMPLEMENT: sample from student t with given degrees of freedom (dof)\n",
    "    X = np.random.standard_t(dof,N)\n",
    "\n",
    "    # this is how we run the linear time goodness-of-fit test\n",
    "    pvalue = GaussianSteinTest(grad_log_normal,num_random_freq).compute_pvalue(X)\n",
    "    results += [[dof, pvalue]]\n",
    "\n",
    "for mc in tqdm(range(num_repetitions)):\n",
    "        # IMPLEMENT: run the test to sample from the null distribution\n",
    "        X = np.random.randn(N)\n",
    "        pvalue = GaussianSteinTest(grad_log_normal,num_random_freq).compute_pvalue(X)\n",
    "\n",
    "        results += [[np.Inf, pvalue]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(results, columns=[\"dof\",\"p_value\"])\n",
    "sns.boxplot(y=\"p_value\",x=\"dof\",data=df);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that for a low number of degrees of freedom, the p-values tend to be mostly small (i.e. the test rejects the null hypothesis more often).\n",
    "As we make the distribution look more like a Gaussian, the p-values increase.\n",
    "Eventually, the student-t becomes a Gaussian for an infinite number of degrees of freedom, i.e. we are sampling from the (unitform!) distribution of p-values under the null hypothesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quadratic time test statistic\n",
    "\n",
    "Let's implement the quadratic time statistic to get a feeling for what quantities are needed: the gradient of the target log-density, the kernel, and the gradient of the kernel with respect to left and right arguments (individually and both).\n",
    "We will use a standard Gaussian kernel with unit scaling, for simplicity in 1D.\n",
    "The first step is to implement kernel gradients (we could do this using an autodiff framework!).\n",
    "\n",
    "See https://arxiv.org/abs/1602.02964 or the slides for the definition of the test statistic. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def k( x, y):\n",
    "    return np.exp(-np.dot(x - y,x - y))\n",
    "\n",
    "def g1k(x, y):\n",
    "    # IMPLEMENT: gradient wrt left argument\n",
    "    return -2.0 *  k(x, y) * (x - y)\n",
    "\n",
    "def g2k(x, y):\n",
    "    # IMPLEMENT: gradient wrt right argument\n",
    "    return -g1k(x, y)\n",
    "\n",
    "def gk(x, y):\n",
    "    # IMPLEMENT: gradient wrt to both arguments\n",
    "    return 2.0 * k(x, y) * ( - 2 * (x - y) ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from ksd import GaussianQuadraticTest\n",
    "\n",
    "X = np.random.standard_t(1,N)\n",
    "kernel_bw = 1.0\n",
    "# reference implementation: the function returns N*statistic. Nevermind the typo :)\n",
    "print(\"Reference\", GaussianQuadraticTest(grad_log_normal, scaling=kernel_bw).get_statistic_multiple(X)[1]/N)\n",
    "\n",
    "# all elements that the statistic sums over\n",
    "U_matrix = np.zeros((N, N))\n",
    "\n",
    "for i in tqdm(range(N)):\n",
    "    for j in range(N):\n",
    "        # IMPLEMENT: implement the quadratic time KSD test statistic (needs gradient of log-density and the gradient of the Gaussian kernel)\n",
    "        # hint: use four terms\n",
    "        x1 = X[i]\n",
    "        x2 = X[j]\n",
    "        a = grad_log_normal(x1) * grad_log_normal(x2) * k(x1, x2)\n",
    "        b = grad_log_normal(x2) * g1k(x1, x2)\n",
    "        c = grad_log_normal(x1) * g2k(x1, x2)\n",
    "        d = gk(x1, x2)\n",
    "        U_matrix[i, j] = a + b + c + d\n",
    "\n",
    "stat = np.mean(U_matrix)\n",
    "print(\"My implementation:\", stat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you like, try to visualize the witness function of the kernel Stein discrepancy, just as we visualized the witness function of the MMD above (see slides for details)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced exercise\n",
    "\n",
    "Let's see if we can quantify convergence of an MCMC chain using the goodness-of-fit test.\n",
    "For simplification, we will thin the MCMC samples so that they are not correlated (see the original KSD paper on how to run the test on correlated samples).\n",
    "This experiment loosely follows one in the KSD paper.\n",
    "\n",
    "In this open-ended las task you will:\n",
    "\n",
    "* Run an MCMC chain using stochastic gradient Langevin dynamics with a large step-size. See https://www.ics.uci.edu/~welling/publications/papers/stoclangevin_v6.pdf\n",
    "* Target a standard Gaussian distribution in 1D (or 2D if you like)\n",
    "* After the sampler is completed, thin the MCMC samples so that they are almost i.i.d.\n",
    "* Run the goodness-of-fit test to quantify at what step-size of the sampler the samples reach a good quality.\n",
    "\n",
    "Good luck :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The end"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}