alex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Review and tutorial of \n",
    "\n",
    "# Deep Neural Networks as Gaussian Processes \n",
    "Jaehoon Lee, Yasaman Bahri, Roman Novak , Samuel S. Schoenholz, Jeffrey Pennington, Jascha Sohl-Dickstein\n",
    "  \n",
    "#### Presented by  \n",
    "[Jason Deng](mailto:dengzj@Hotmail.com)  \n",
    "[Alexander Dubitskiy](mailto:ald028@g.harvard.edu)  \n",
    "[Zheng Yang](mailto:zhengyang@g.harvard.edu)  \n",
    "[Sean Tierney](mailto:set936@g.harvard.edu) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Background information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The question of defining meaningful priors for a neural network was first addressed by Radford M. Neal in his 1994 paper [Priors for infinite networks](ftp://www.cs.toronto.edu/dist/radford/pin.pdf).  \n",
    "In the paper he studied a neural network with a real valued input of size I, one hidden layer of size H with sigmoidal transfer function and real valued output of size O. This network can be described with the following equations:\n",
    "$$ f_k(x) = b_k + \\sum_{i=1}^{H} v_{jk} h_j(x) $$ \n",
    "$$ h_j(x) = tanh( a_j + \\sum_{i=1}^{I} u_{ij} x_i) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The author suggested Gaussian priors over the network weights $ b_k \\propto \\mathcal{N}(0, \\sigma_b) , v_{jk} \\propto \\mathcal{N}(0, \\sigma_v), a_j \\propto \\mathcal{N}(0, \\sigma_a) , u_{ij} \\propto \\mathcal{N}(0, \\sigma_u) $ and showed that when $H \\to \\infty$ the prior joint distribution converges to a multivariate Gaussian with zero means and covarinace:\n",
    "  \n",
    "$$ E[f_k(x) f_k(x\\prime)]  = \\sigma_{b}^2 + \\sum_{j} \\sigma_{v}^2 E[h_{j}(x)h_{j}(x \\prime)] = \\sigma_{b}^2 + w_{v}^2 C(x, x \\prime) $$\n",
    "and this is a Gaussian process."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This work was further extended by Christopher K. I. Williams in his 1996 paper [Computing with infinite networks](https://papers.nips.cc/paper/1197-computing-with-infinite-networks.pdf).  \n",
    "Williams showed how to calculate the corresponding kernels for single-layered neural networks with sigmoidal and Gaussian transfer functions.  \n",
    "  \n",
    "$$ C_{erf}(x, x \\prime) = \\frac{2}{\\pi} \\sin^{-1} \\frac{2 x^{T} \\Sigma x \\prime }{\\sqrt{(1 + 2 x^{T} \\Sigma x ) (1 + 2 x \\prime^{T} \\Sigma x \\prime )}} $$\n",
    "  \n",
    "$$ C_{G}(x, x \\prime) = (\\frac{\\sigma_e}{\\sigma_u})^d \\exp(- \\frac{x^{T}x}{2 \\sigma_{m}^2}) \\exp(- \\frac{(x - x^{T})^{T} (x - x^{T})}{2 \\sigma_{s}^2}) \\exp(- \\frac{x \\prime^{T}x \\prime}{2 \\sigma_{m}^2}) $$  \n",
    "where \n",
    "$$ \\frac{1}{\\sigma_{e}^2} = \\frac{2}{\\sigma_{g}^2} + \\frac{1}{\\sigma_{u}^2} , \\sigma_{s}^2 = 2 \\sigma_{g}^2 + \\frac{\\sigma_{g}^4}{\\sigma_{u}^2} , \\sigma_{m}^2 = 2 \\sigma_{u}^2 + \\sigma_{g}^2 $$  \n",
    "and $ \\sigma_{g} $ is the width of the Gaussian transfer function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Summary of the kernel computation for a multi-layer neural network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider an $L$-hidden-layer fully-connected neural network with hidden layers of width $N_l$ (for layer $l$) and pointwise nonlinearities $\\phi$. Let $x \\in \\Re^{d_{in}}$ denote the input to the network, and let $z^L \\in \\Re^{d_{out}}$ denote it output. The $i$th component of activations in the $l$th layer, post-nonlinearity and post-affine trnsformatin, are denoted $x_i^l$ and $z_i^l$ repectively. Weight and bias parameters for the $l$th layer have components $W_{ij}^l, b_i^l$, which are independent and randomly drawn, and we take them all to have zero mean and variances $\\sigma_w^2/N_l$ and $\\sigma_b^2$, repectively. $GP(\\mu, K)$ denotes a Gaussian process with mean and covariance functions $\\mu(\\cdotp), K(\\cdotp, \\cdotp)$, repectively.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's review the multidimentional Central Limit Theorem first.  \n",
    "\n",
    "We assume each infdividual $X_i$ is a random vector in $\\Re^k$, with mean vector $\\mu  = E(X_i)$ and these random vectors are i.i.d.,  \n",
    "$$\\frac{1}{n}\\Sigma^n_{i = 1}X_i = \n",
    "\\frac{1}{n}\n",
    "\\begin{bmatrix}\n",
    "    \\Sigma^n_{i = 1}X_{i(1)}\\\\\n",
    "    \\vdots \\\\\n",
    "    \\Sigma^n_{i = 1}X_{i(k)}\n",
    "\\end{bmatrix}\n",
    " = \\bar{X_n}$$\n",
    "And therefore, \n",
    "$$\\frac{1}{\\sqrt{n}}\\Sigma^n_{i = 1}[X_i - E(X_i)] = \\frac{1}{\\sqrt{n}}\\Sigma^n_{i = 1}(X_i - \\mu) = \\sqrt{n}(\\bar{X_n} - \\mu).$$  \n",
    "\n",
    "The multidimentional Central Limit Theorem states that\n",
    "$$\\sqrt{n}(\\bar{X_n} - \\mu) \\sim N_k(0, \\Sigma)$$  \n",
    "\n",
    "In a multi-layer neural network, the weights and bias parameters are taken to be i.i.d., and the post-activations $x_j^l, x_{j'}^l$, are independent for $j \\neq j'$. From the multidimentional Center Limit Theorem, as $N_l \\rightarrow \\infty$, any finite collection of $\\{z_i^l(x^{\\alpha=1}), \\ldots, z_i^l(x^{\\alpha=k})\\}$ will have a joint multivariate Guassian distribution and $z_i^l \\sim GP(0, K^l).$  \n",
    "\n",
    "The covariance is \n",
    "$$K^l(x, x') \\equiv E[z^l_i(x)z^l_i(x')] = \\sigma^2_b + \\sigma^2_wE_{z_i^{l-1}\\sim GP(0, K^{l-1})}[\\phi(z_i^{l-1}(x))\\phi(z_i^{l-1}(x'))].$$  \n",
    "\n",
    "Since the expectation in above equation is over the GP governing $z_i^{l-1}$, which is equivalent to integrating against the joint distribution of only $z_i^{l-1}(x)$ and $z_i^{l-1}(x')$. This joint distirbution has zero mean and covariance matrix \n",
    "$$K = \n",
    "\\begin{bmatrix}\n",
    "    K^{l-1}(x, x) & K^{l-1}(x, x')\\\\\n",
    "     K^{l-1}(x', x) &  K^{l-1}(x', x') \\\\\n",
    "\\end{bmatrix}$$  \n",
    "\n",
    "Thus, we can introduce the shorthand\n",
    "$$K^l(x, x') = \\sigma^2_b + \\sigma^2_wF_\\phi(K^{l-1}(x, x'), K^{l-1}(x, x), K^{l-1}(x', x'))$$\n",
    "to emphasize the recursive relationship between $K^l$ and $K^{l-1}$ via a deterministic function F whose form depends only on the nonlinearity $\\phi$. This gives an iterative series of computations which can be performed to obtain $K^L$ for the GP describing the network's final output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the base case $K^0$, suppose $W^0_{ij} \\sim N(0, \\sigma^2_x/d_{in}), b_j^0 \\sim N(0, \\sigma_b^2)$; we can utilize the recursion relating $K^1$ and $K^0$, where\n",
    "$$K^0(x, x') = E[z_j^0(x)z_j^0(x')] = \\sigma^2_b + \\sigma^2_w(\\frac{x\\cdot x'}{d_{in}})$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary of the NNGP implementation\n",
    "\n",
    "In a nutshell, this notebook implemented a Gaussian process regression with a NNGP kernel to return predicted Y_test given X_test. The followings are to explain how the implementation allows the computation of the GP regression and the kernel from a reverse-engineering perspective.\n",
    "\n",
    "First of all, the Gaussian Process regression model was based on GPflow, and it is to estimate a GP $p(y^* | x, y, x^*) \\sim N(\\bar{\\mu},\\bar{K})$ according to the following equations (ref: equaiton (8 and 9), Lee etal, V3 March, 2018):\n",
    "\n",
    "$$\n",
    "\\bar{\\mu} = K^L_{x^*, D} (K^L_{D, D} + \\sigma^2 \\mathbb{I}_n)^{-1} t \n",
    "$$\n",
    "and \n",
    "$$\n",
    "\\bar{K}=K^L_{x^*,x^*} - K^L_{x^*,D}(K^L_{D, D} + \\sigma^2 \\mathbb{I}_n)^{-1} K^{L,T}_{x^*, D} \n",
    "$$\n",
    "\n",
    "where $\\bar{\\mu}$ is the mean of predicted Y, $\\bar{K}$ represents the variance of the prediction. The model computes the Cholesky decompositionthe of $K^L$ as part of the algorithm for finding $\\bar{\\mu}$ and $\\bar{K}$, using the functions defined under the class GaussianProcessRegression. This implementation was explained somewhere else (Rasmussen and Williams, Gaussian processes for machine learning, 2006). \n",
    "\n",
    "In order to get the $K^L$ for the model, a NNGP kernel was implemented with The key function k_full(). k_full() first computes $K^l$ that is the covariance of post-activation at given pre-activation variance and correlation. It then returns a fully stacked $K^L$ over all the layers in the neural network. The implementation was based on the following euqation (ref: equaiton (4), Lee etal, V3 March, 2018):\n",
    "\n",
    "$$\n",
    "K^l(x,x') = \\sigma^2_b + \\sigma^2_w \\mathbb{E}_{z^{l-1}_i \\sim GP(0, K^{l-1})}[\\phi(z^{l-1}_i (x))\\phi(z^{l-1}_i (x')]\n",
    "$$\n",
    "\n",
    "where $\\sigma^2_b$ and $\\sigma^2_w$ are initial values of the variance, which are initialized with the kernel. The expectation term $\\mathbb{E}_{z^{l-1}_i \\sim GP(0, K^{l-1})}[\\phi(z^{l-1}_i (x))\\phi(z^{l-1}_i (x')]$, which is a Gaussian integral, was computed via numerical integration implmentation. Briefly, a numerical integration is achieved by the linear interpolation method for all pairs of training-training and training-test points for layer $l$. First, all the inputs are processed to have identical norms. This preprocessing guarantees the identical marginal variance for each datapoint. Next, a matrix F is populated, containing a lookup table for the function $F_\\phi$ , in the following euqation  (ref: equaiton (5), Lee etal, V3 March, 2018):\n",
    "\n",
    "$$\n",
    "K^l(x,x') = \\sigma^2_b + \\sigma^2_w F_\\phi (K^{l-1}(x,x'), K^{l-1}(x,x),K^{l-1}(x',x'))\n",
    "$$\n",
    "\n",
    "The the function $F_\\phi$  was approximately by bilinear interpolation into the matrix F. This is repeated recursively over all the layers. The bilinear interpolation has constant cost. \n",
    "Noted, these paramters are initialzed with the kernel: n_gauss, n_var and n_corr, determining the sampling densities for the numerical integration.  \n",
    "\n",
    "\n",
    "To describe the implementation of k_full() in peudocodes.\n",
    "\n",
    "k_full (): \n",
    "    \n",
    "    Normalize input to unit variance or to fixed point variance\n",
    "    \n",
    "    For each hidden layer l:\n",
    "        q_ab = interp.interp_lin_2d(...) # numerical integration for the expectation of the prevoius layer, E(z^{l-1}) (equation 4)\n",
    "        q_ab = self.weight_var * q_ab + self.bias_var #This computes the covariance of the current layer, K^l\n",
    "        \n",
    "    q_ab_all = parallelly_stack(q_ab)  #K^L over all the layers\n",
    "    \n",
    "    return q_ab_all\n",
    "\n",
    "\n",
    "\n",
    "In addition, the following tensorboard graph captures the workflow of k_full() .\n",
    "<img src=\"kfull.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #2\n",
      "  (fname, cnt))\n",
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #3\n",
      "  (fname, cnt))\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append('nngp')\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.datasets import load_boston\n",
    "from sklearn.datasets import fetch_mldata\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.optimizers import SGD\n",
    "from keras.models import load_model\n",
    "\n",
    "from matplotlib import cm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This block defines functions for linear interpretation, used for calculating the function F as described in the implementation section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Interpolate in NNGP grid.\n",
    "\"\"\"\n",
    "\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def interp_lin(x, y, xp, log_spacing=False):\n",
    "    \"\"\"Linearly interpolate.\n",
    "\n",
    "    x is evenly spaced grid coordinates, with values y,\n",
    "    xp are the locations to which to interpolate.\n",
    "    x and xp must be 1d tensors.\n",
    "    \"\"\"\n",
    "    with tf.name_scope('interp_lin'):\n",
    "        if log_spacing:\n",
    "            x = tf.log(x)\n",
    "            xp = tf.log(xp)\n",
    "\n",
    "        spacing = x[1] - x[0]\n",
    "        grid = (xp - x[0]) / spacing\n",
    "        ind1 = tf.cast(grid, tf.int32)\n",
    "        ind2 = ind1 + 1\n",
    "        max_ind = x.shape[0].value\n",
    "        # set top and bottom indices identical if extending past end of range\n",
    "        ind2 = tf.minimum(max_ind - 1, ind2)\n",
    "\n",
    "        weight1 = tf.abs(xp - tf.gather(x, ind1)) / spacing\n",
    "        weight2 = tf.abs(xp - tf.gather(x, ind2)) / spacing\n",
    "        if log_spacing:\n",
    "            weight1 = tf.exp(weight1)\n",
    "            weight2 = tf.exp(weight2)\n",
    "\n",
    "        weight1 = 1. - tf.reshape(weight1, [-1] + [1] * (len(y.shape) - 1))\n",
    "        weight2 = 1. - tf.reshape(weight2, [-1] + [1] * (len(y.shape) - 1))\n",
    "\n",
    "        weight_sum = weight1 + weight2\n",
    "        weight1 /= weight_sum\n",
    "        weight2 /= weight_sum\n",
    "\n",
    "        y1 = tf.gather(y, ind1)\n",
    "        y2 = tf.gather(y, ind2)\n",
    "        yp = y1 * weight1 + y2 * weight2\n",
    "        return yp\n",
    "\n",
    "\n",
    "def _get_interp_idxs_weights_2d(x, xp, y, yp, x_log_spacing=False):\n",
    "    with tf.name_scope('get_interp_idxs_weights_2d'):\n",
    "        if x_log_spacing:\n",
    "            x = tf.log(x)\n",
    "            xp = tf.log(xp)\n",
    "\n",
    "        with tf.control_dependencies([yp]):\n",
    "            xp = tf.tile(xp, yp.shape)\n",
    "        xyp = tf.expand_dims(tf.parallel_stack([xp, yp]), 1)\n",
    "        xy0 = tf.reshape(tf.parallel_stack([x[0], y[0]]), [2, 1, 1])\n",
    "        xy1 = tf.reshape(tf.parallel_stack([x[1], y[1]]), [2, 1, 1])\n",
    "\n",
    "        spacing = xy1 - xy0\n",
    "        ind_grid = (xyp - xy0) / spacing\n",
    "        ind = tf.cast(ind_grid, tf.int32) + [[[0], [1]]]\n",
    "\n",
    "        max_ind = [[[x.shape[0].value - 1]], [[y.shape[0].value - 1]]]\n",
    "        ind = tf.minimum(ind, max_ind)\n",
    "        ind_float = tf.cast(ind, tf.float64)\n",
    "\n",
    "        xy_grid = ind_float * spacing + xy0\n",
    "\n",
    "        weight = tf.abs(xyp - xy_grid) / spacing\n",
    "        if x_log_spacing:\n",
    "            weight = tf.parallel_stack([tf.exp(weight[0]), weight[1]])\n",
    "        weight = 1. - weight\n",
    "\n",
    "        weight_sum = tf.reduce_sum(weight, axis=1, keep_dims=True)\n",
    "        weight /= weight_sum\n",
    "\n",
    "        return ind, weight\n",
    "\n",
    "\n",
    "def interp_lin_2d(x, y, z, xp, yp, x_log_spacing=False):\n",
    "    with tf.name_scope('interp_lin_2d'):\n",
    "        ind, weight = _get_interp_idxs_weights_2d(x, xp, y, yp, x_log_spacing)\n",
    "        zp_accum = 0.\n",
    "\n",
    "        for ind_x, weight_x in [(ind[0, 0], weight[0, 0]),\n",
    "                                (ind[0, 1], weight[0, 1])]:\n",
    "            for ind_y, weight_y in [(ind[1, 0], weight[1, 0]),\n",
    "                                    (ind[1, 1], weight[1, 1])]:\n",
    "                zp = tf.gather_nd(z, tf.stack([ind_x, ind_y], axis=1))\n",
    "                zp_accum += zp * weight_x * weight_y\n",
    "\n",
    "        return zp_accum\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The class defined below defines the GP kernel. It's initialized with a number of hyperparameters, including the variance of bias and weight values, number of layers, and nonlinearity. Included are functions for calculating $K^L$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Neural Network Gaussian Process (nngp) kernel computation.\n",
    "\n",
    "Implementaion based on\n",
    "\"Deep Neural Networks as Gaussian Processes\" by\n",
    "Jaehoon Lee, Yasaman Bahri, Roman Novak, Samuel S. Schoenholz,\n",
    "Jeffrey Pennington, Jascha Sohl-Dickstein\n",
    "arXiv:1711.00165 (https://arxiv.org/abs/1711.00165).\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import multiprocessing\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "import interp\n",
    "\n",
    "\n",
    "class NNGPKernel(object):\n",
    "    \"\"\"The iterative covariance Kernel for Neural Network Gaussian Process.\n",
    "\n",
    "  Args:\n",
    "    depth: int, number of hidden layers in corresponding NN.\n",
    "    nonlin_fn: tf ops corresponding to point-wise non-linearity in corresponding\n",
    "      NN. e.g.) tf.nn.relu, tf.nn.sigmoid, lambda x: x * tf.nn.sigmoid(x), ...\n",
    "    weight_var: initial value for the weight_variances parameter.\n",
    "    bias_var: initial value for the bias_variance parameter.\n",
    "    n_gauss: Number of gaussian integration grid. Choose odd integer, so that\n",
    "      there is a gridpoint at 0.\n",
    "    n_var: Number of variance grid points.\n",
    "    n_corr: Number of correlation grid points.\n",
    "    use_fixed_point_norm: bool, normalize input to variance fixed point.\n",
    "      Defaults to False, normalizing input to unit norm over input dimension.\n",
    "  \"\"\"\n",
    "\n",
    "    def __init__(self,\n",
    "                 depth=1,\n",
    "                 nonlin_fn=tf.tanh,\n",
    "                 weight_var=1.,\n",
    "                 bias_var=1.,\n",
    "                 n_gauss=101,\n",
    "                 n_var=151,\n",
    "                 n_corr=131,\n",
    "                 max_var=100,\n",
    "                 max_gauss=100,\n",
    "                 use_fixed_point_norm=False,\n",
    "                 fraction_of_int32=32,\n",
    "                 use_precomputed_grid=False,\n",
    "                 grid_path=None,\n",
    "                 sess=None):\n",
    "        self.depth = depth\n",
    "        self.weight_var = weight_var\n",
    "        self.bias_var = bias_var\n",
    "        self.use_fixed_point_norm = use_fixed_point_norm\n",
    "        self.sess = sess\n",
    "        self.fraction_of_int32 = fraction_of_int32\n",
    "        self.use_precomputed_grid = use_precomputed_grid\n",
    "\n",
    "        if use_precomputed_grid and (grid_path is None):\n",
    "            raise ValueError(\"grid_path must be specified to use precomputed grid.\")\n",
    "        self.grid_path = grid_path\n",
    "\n",
    "        self.nonlin_fn = nonlin_fn\n",
    "        (self.var_aa_grid, self.corr_ab_grid, self.qaa_grid,\n",
    "         self.qab_grid) = self.get_grid(n_gauss, n_var, n_corr, max_var, max_gauss)\n",
    "\n",
    "        if self.use_fixed_point_norm:\n",
    "            self.var_fixed_point_np, self.var_fixed_point = self.get_var_fixed_point()\n",
    "\n",
    "    def get_grid(self, n_gauss, n_var, n_corr, max_var, max_gauss):\n",
    "        \"\"\"Get covariance grid by loading or computing a new one.\n",
    "    \"\"\"\n",
    "        # File configuration for precomputed grid\n",
    "        if self.use_precomputed_grid:\n",
    "            grid_path = self.grid_path\n",
    "            # TODO(jaehlee) np.save have broadcasting error when n_var==n_corr.\n",
    "            if n_var == n_corr:\n",
    "                n_var += 1\n",
    "            grid_file_name = \"grid_{0:s}_ng{1:d}_ns{2:d}_nc{3:d}\".format(\n",
    "                self.nonlin_fn.__name__, n_gauss, n_var, n_corr)\n",
    "            grid_file_name += \"_mv{0:d}_mg{1:d}\".format(max_var, max_gauss)\n",
    "\n",
    "        # Load grid file if it exists already\n",
    "        if (self.use_precomputed_grid and\n",
    "                tf.gfile.Exists(os.path.join(grid_path, grid_file_name))):\n",
    "            with tf.gfile.Open(os.path.join(grid_path, grid_file_name), \"rb\") as f:\n",
    "                grid_data_np = np.load(f)\n",
    "                tf.logging.info(\"Loaded interpolation grid from %s\" %\n",
    "                                os.path.join(grid_path, grid_file_name))\n",
    "                grid_data = (tf.convert_to_tensor(grid_data_np[0], dtype=tf.float64),\n",
    "                             tf.convert_to_tensor(grid_data_np[1], dtype=tf.float64),\n",
    "                             tf.convert_to_tensor(grid_data_np[2], dtype=tf.float64),\n",
    "                             tf.convert_to_tensor(grid_data_np[3], dtype=tf.float64))\n",
    "\n",
    "        else:\n",
    "            tf.logging.info(\"Generating interpolation grid...\")\n",
    "            grid_data = _compute_qmap_grid(self.nonlin_fn, n_gauss, n_var, n_corr,\n",
    "                                           max_var=max_var, max_gauss=max_gauss)\n",
    "            if self.use_precomputed_grid:\n",
    "                with tf.Session() as sess:\n",
    "                    grid_data_np = sess.run(grid_data)\n",
    "                tf.gfile.MakeDirs(grid_path)\n",
    "                with tf.gfile.Open(os.path.join(grid_path, grid_file_name), \"wb\") as f:\n",
    "                    np.save(f, grid_data_np)\n",
    "\n",
    "                with tf.gfile.Open(os.path.join(grid_path, grid_file_name), \"rb\") as f:\n",
    "                    grid_data_np = np.load(f)\n",
    "                    tf.logging.info(\"Loaded interpolation grid from %s\" %\n",
    "                                    os.path.join(grid_path, grid_file_name))\n",
    "                    grid_data = (tf.convert_to_tensor(grid_data_np[0], dtype=tf.float64),\n",
    "                                 tf.convert_to_tensor(grid_data_np[1], dtype=tf.float64),\n",
    "                                 tf.convert_to_tensor(grid_data_np[2], dtype=tf.float64),\n",
    "                                 tf.convert_to_tensor(grid_data_np[3], dtype=tf.float64))\n",
    "\n",
    "        return grid_data\n",
    "\n",
    "    def get_var_fixed_point(self):\n",
    "        with tf.name_scope(\"get_var_fixed_point\"):\n",
    "            # If normalized input length starts at 1.\n",
    "            current_qaa = self.weight_var * tf.constant(\n",
    "                [1.], dtype=tf.float64) + self.bias_var\n",
    "\n",
    "            diff = 1.\n",
    "            prev_qaa_np = 1.\n",
    "            it = 0\n",
    "            while diff > 1e-6 and it < 300:\n",
    "                samp_qaa = interp.interp_lin(\n",
    "                    self.var_aa_grid, self.qaa_grid, current_qaa)\n",
    "                samp_qaa = self.weight_var * samp_qaa + self.bias_var\n",
    "                current_qaa = samp_qaa\n",
    "\n",
    "                with tf.Session() as sess:\n",
    "                    current_qaa_np = sess.run(current_qaa)\n",
    "                diff = np.abs(current_qaa_np - prev_qaa_np)\n",
    "                it += 1\n",
    "                prev_qaa_np = current_qaa_np\n",
    "            return current_qaa_np, current_qaa\n",
    "\n",
    "    def k_diag(self, input_x, return_full=True):\n",
    "        \"\"\"Iteratively building the diagonal part (variance) of the NNGP kernel.\n",
    "\n",
    "    Args:\n",
    "      input_x: tensor of input of size [num_data, input_dim].\n",
    "      return_full: boolean for output to be [num_data] sized or a scalar value\n",
    "        for normalized inputs\n",
    "\n",
    "    Sets self.layer_qaa_dict of {layer #: qaa at the layer}\n",
    "\n",
    "    Returns:\n",
    "      qaa: variance at the output.\n",
    "    \"\"\"\n",
    "        with tf.name_scope(\"Kdiag\"):\n",
    "            # If normalized input length starts at 1.\n",
    "            if self.use_fixed_point_norm:\n",
    "                current_qaa = self.var_fixed_point\n",
    "            else:\n",
    "                current_qaa = self.weight_var * tf.convert_to_tensor(\n",
    "                    [1.], dtype=tf.float64) + self.bias_var\n",
    "            self.layer_qaa_dict = {0: current_qaa}\n",
    "            for l in range(self.depth):\n",
    "                with tf.name_scope(\"layer_%d\" % l):\n",
    "                    samp_qaa = interp.interp_lin(\n",
    "                        self.var_aa_grid, self.qaa_grid, current_qaa)\n",
    "                    samp_qaa = self.weight_var * samp_qaa + self.bias_var\n",
    "                    self.layer_qaa_dict[l + 1] = samp_qaa\n",
    "                    current_qaa = samp_qaa\n",
    "\n",
    "            if return_full:\n",
    "                qaa = tf.tile(current_qaa[:1], ([input_x.shape[0].value]))\n",
    "            else:\n",
    "                qaa = current_qaa[0]\n",
    "            return qaa\n",
    "\n",
    "    def k_full(self, input1, input2=None):\n",
    "        \"\"\"Iteratively building the full NNGP kernel.\n",
    "    \"\"\"\n",
    "        input1 = self._input_layer_normalization(input1)\n",
    "        if input2 is None:\n",
    "            input2 = input1\n",
    "        else:\n",
    "            input2 = self._input_layer_normalization(input2)\n",
    "\n",
    "        with tf.name_scope(\"k_full\"):\n",
    "            cov_init = tf.matmul(\n",
    "                input1, input2, transpose_b=True) / input1.shape[1].value\n",
    "\n",
    "            self.k_diag(input1)\n",
    "            q_aa_init = self.layer_qaa_dict[0]\n",
    "\n",
    "            q_ab = cov_init\n",
    "            q_ab = self.weight_var * q_ab + self.bias_var\n",
    "            corr = q_ab / q_aa_init[0]\n",
    "\n",
    "            if self.fraction_of_int32 > 1:\n",
    "                batch_size, batch_count = self._get_batch_size_and_count(input1, input2)\n",
    "                with tf.name_scope(\"q_ab\"):\n",
    "                    q_ab_all = []\n",
    "                    for b_x in range(batch_count):\n",
    "                        with tf.name_scope(\"batch_%d\" % b_x):\n",
    "                            corr_flat_batch = corr[\n",
    "                                              batch_size * b_x: batch_size * (b_x + 1), :]\n",
    "                            corr_flat_batch = tf.reshape(corr_flat_batch, [-1])\n",
    "\n",
    "                            for l in range(self.depth):\n",
    "                                with tf.name_scope(\"layer_%d\" % l):\n",
    "                                    q_aa = self.layer_qaa_dict[l]\n",
    "                                    q_ab = interp.interp_lin_2d(x=self.var_aa_grid,\n",
    "                                                                y=self.corr_ab_grid,\n",
    "                                                                z=self.qab_grid,\n",
    "                                                                xp=q_aa,\n",
    "                                                                yp=corr_flat_batch)\n",
    "\n",
    "                                    q_ab = self.weight_var * q_ab + self.bias_var\n",
    "                                    corr_flat_batch = q_ab / self.layer_qaa_dict[l + 1][0]\n",
    "\n",
    "                            q_ab_all.append(q_ab)\n",
    "\n",
    "                    q_ab_all = tf.parallel_stack(q_ab_all)\n",
    "            else:\n",
    "                with tf.name_scope(\"q_ab\"):\n",
    "                    corr_flat = tf.reshape(corr, [-1])\n",
    "                    for l in range(self.depth):\n",
    "                        with tf.name_scope(\"layer_%d\" % l):\n",
    "                            q_aa = self.layer_qaa_dict[l]\n",
    "                            q_ab = interp.interp_lin_2d(x=self.var_aa_grid,\n",
    "                                                        y=self.corr_ab_grid,\n",
    "                                                        z=self.qab_grid,\n",
    "                                                        xp=q_aa,\n",
    "                                                        yp=corr_flat)\n",
    "                            q_ab = self.weight_var * q_ab + self.bias_var\n",
    "                            corr_flat = q_ab / self.layer_qaa_dict[l + 1][0]\n",
    "                        q_ab_all = q_ab\n",
    "\n",
    "        return tf.reshape(q_ab_all, cov_init.shape, \"qab\")\n",
    "\n",
    "    def _input_layer_normalization(self, x):\n",
    "        \"\"\"Input normalization to unit variance or fixed point variance.\n",
    "    \"\"\"\n",
    "        with tf.name_scope(\"input_layer_normalization\"):\n",
    "            # Layer norm, fix to unit variance\n",
    "            eps = 1e-15\n",
    "            mean, var = tf.nn.moments(x, axes=[1], keep_dims=True)\n",
    "            x_normalized = (x - mean) / tf.sqrt(var + eps)\n",
    "            if self.use_fixed_point_norm:\n",
    "                x_normalized *= tf.sqrt(\n",
    "                    (self.var_fixed_point[0] - self.bias_var) / self.weight_var)\n",
    "            return x_normalized\n",
    "\n",
    "    def _get_batch_size_and_count(self, input1, input2):\n",
    "        \"\"\"Compute batch size and number to split when input size is large.\n",
    "\n",
    "    Args:\n",
    "      input1: tensor, input tensor to covariance matrix\n",
    "      input2: tensor, second input tensor to covariance matrix\n",
    "\n",
    "    Returns:\n",
    "      batch_size: int, size of each batch\n",
    "      batch_count: int, number of batches\n",
    "    \"\"\"\n",
    "        input1_size = input1.shape[0].value\n",
    "        input2_size = input2.shape[0].value\n",
    "\n",
    "        batch_size = min(np.iinfo(np.int32).max // (self.fraction_of_int32 * input2_size), input1_size)\n",
    "        while input1_size % batch_size != 0:\n",
    "            batch_size -= 1\n",
    "\n",
    "        batch_count = input1_size // batch_size\n",
    "        return batch_size, batch_count\n",
    "\n",
    "\n",
    "def _fill_qab_slice(idx, z1, z2, var_aa, corr_ab, nonlin_fn):\n",
    "    \"\"\"Helper method used for parallel computation for full qab.\"\"\"\n",
    "    log_weights_ab_unnorm = -(z1 ** 2 + z2 ** 2 - 2 * z1 * z2 * corr_ab) / (\n",
    "            2 * var_aa[idx] * (1 - corr_ab ** 2))\n",
    "    log_weights_ab = log_weights_ab_unnorm - tf.reduce_logsumexp(\n",
    "        log_weights_ab_unnorm, axis=[0, 1], keep_dims=True)\n",
    "    weights_ab = tf.exp(log_weights_ab)\n",
    "\n",
    "    qab_slice = tf.reduce_sum(\n",
    "        nonlin_fn(z1) * nonlin_fn(z2) * weights_ab, axis=[0, 1])\n",
    "    qab_slice = tf.Print(qab_slice, [idx], \"Generating slice: \")\n",
    "    return qab_slice\n",
    "\n",
    "\n",
    "def _compute_qmap_grid(nonlin_fn,\n",
    "                       n_gauss,\n",
    "                       n_var,\n",
    "                       n_corr,\n",
    "                       log_spacing=False,\n",
    "                       min_var=1e-8,\n",
    "                       max_var=100.,\n",
    "                       max_corr=0.99999,\n",
    "                       max_gauss=10.):\n",
    "    \"\"\"Construct graph for covariance grid to use for kernel computation.\n",
    "\n",
    "  Given variance and correlation (or covariance) of pre-activation, perform\n",
    "  Gaussian integration to get covariance of post-activation.\n",
    "\n",
    "  Raises:\n",
    "    ValueError: if n_gauss is even integer.\n",
    "\n",
    "  Args:\n",
    "    nonlin_fn: tf ops corresponding to point-wise non-linearity in\n",
    "      corresponding NN. e.g.) tf.nn.relu, tf.nn.sigmoid,\n",
    "      lambda x: x * tf.nn.sigmoid(x), ...\n",
    "    n_gauss: int, number of Gaussian integration points with equal spacing\n",
    "      between (-max_gauss, max_gauss). Choose odd integer, so that there is a\n",
    "      gridpoint at 0.\n",
    "    n_var: int, number of variance grid points.get_grid\n",
    "    n_corr: int, number of correlation grid points.\n",
    "    log_spacing: bool, whether to use log-linear instead of linear variance\n",
    "      grid.\n",
    "    min_var: float, smallest variance value to generate grid.\n",
    "    max_var: float, largest varaince value to generate grid.\n",
    "    max_corr: float, largest correlation value to generate grid. Should be\n",
    "      slightly smaller than 1.\n",
    "    max_gauss: float, range (-max_gauss, max_gauss) for Gaussian integration.\n",
    "\n",
    "  Returns:\n",
    "    var_grid_pts: tensor of size [n_var], grid points where variance are\n",
    "      evaluated at.\n",
    "    corr_grid_pts: tensor of size [n_corr], grid points where correlation are\n",
    "      evalutated at.\n",
    "    qaa: tensor of size [n_var], variance of post-activation at given\n",
    "      pre-activation variance.\n",
    "    qab: tensor of size [n_var, n_corr], covariance of post-activation at\n",
    "      given pre-activation variance and correlation.\n",
    "  \"\"\"\n",
    "    if n_gauss % 2 != 1:\n",
    "        raise ValueError(\"n_gauss=%d should be an odd integer\" % n_gauss)\n",
    "\n",
    "    with tf.name_scope(\"compute_qmap_grid\"):\n",
    "        min_var = tf.convert_to_tensor(min_var, dtype=tf.float64)\n",
    "        max_var = tf.convert_to_tensor(max_var, dtype=tf.float64)\n",
    "        max_corr = tf.convert_to_tensor(max_corr, dtype=tf.float64)\n",
    "        max_gauss = tf.convert_to_tensor(max_gauss, dtype=tf.float64)\n",
    "\n",
    "        # Evaluation points for numerical integration over a Gaussian.\n",
    "        z1 = tf.reshape(tf.linspace(-max_gauss, max_gauss, n_gauss), (-1, 1, 1))\n",
    "        z2 = tf.transpose(z1, perm=[1, 0, 2])\n",
    "\n",
    "        if log_spacing:\n",
    "            var_aa = tf.exp(tf.linspace(tf.log(min_var), tf.log(max_var), n_var))\n",
    "        else:\n",
    "            # Evaluation points for pre-activations variance and correlation\n",
    "            var_aa = tf.linspace(min_var, max_var, n_var)\n",
    "        corr_ab = tf.reshape(tf.linspace(-max_corr, max_corr, n_corr), (1, 1, -1))\n",
    "\n",
    "        # compute q_aa\n",
    "        log_weights_aa_unnorm = -0.5 * (z1 ** 2 / tf.reshape(var_aa, [1, 1, -1]))\n",
    "        log_weights_aa = log_weights_aa_unnorm - tf.reduce_logsumexp(\n",
    "            log_weights_aa_unnorm, axis=[0, 1], keep_dims=True)\n",
    "        weights_aa = tf.exp(log_weights_aa)\n",
    "        qaa = tf.reduce_sum(nonlin_fn(z1) ** 2 * weights_aa, axis=[0, 1])\n",
    "\n",
    "        # compute q_ab\n",
    "        # weights to reweight uniform samples by, for q_ab.\n",
    "        # (weights are probability of z1, z2 under Gaussian\n",
    "        #  w/ variance var_aa and covariance var_aa*corr_ab)\n",
    "        # weights_ab will have shape [n_g, n_g, n_v, n_c]\n",
    "        def fill_qab_slice(idx):\n",
    "            return _fill_qab_slice(idx, z1, z2, var_aa, corr_ab, nonlin_fn)\n",
    "\n",
    "        qab = tf.map_fn(\n",
    "            fill_qab_slice,\n",
    "            tf.range(n_var),\n",
    "            dtype=tf.float64,\n",
    "            parallel_iterations=multiprocessing.cpu_count())\n",
    "\n",
    "        var_grid_pts = tf.reshape(var_aa, [-1])\n",
    "        corr_grid_pts = tf.reshape(corr_ab, [-1])\n",
    "\n",
    "        return var_grid_pts, corr_grid_pts, qaa, qab\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Gaussian process regression model based on GPflow.\n",
    "\"\"\"\n",
    "\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import time\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "class GaussianProcessRegression(object):\n",
    "    \"\"\"Gaussian process regression model based on GPflow.\n",
    "\n",
    "    Args:\n",
    "      input_x: numpy array, [data_size, input_dim]\n",
    "      output_x: numpy array, [data_size, output_dim]\n",
    "      kern: NNGPKernel class\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_x, output_y, kern, print_kernel=False):\n",
    "        with tf.name_scope(\"init\"):\n",
    "            self.input_x = input_x\n",
    "            self.output_y = output_y\n",
    "            self.num_train, self.input_dim = input_x.shape\n",
    "            _, self.output_dim = output_y.shape\n",
    "\n",
    "            self.kern = kern\n",
    "            self.print_kernel = print_kernel\n",
    "            self.stability_eps = tf.identity(tf.placeholder(tf.float64))\n",
    "            self.current_stability_eps = 1e-10\n",
    "\n",
    "            self.y_pl = tf.placeholder(tf.float64, [self.num_train, self.output_dim], name=\"y_train\")\n",
    "            self.x_pl = tf.identity(tf.placeholder(tf.float64, [self.num_train, self.input_dim], name=\"x_train\"))\n",
    "\n",
    "            self.l_np = None\n",
    "            self.v_np = None\n",
    "            self.k_np = None\n",
    "\n",
    "        self.k_data_data = tf.identity(self.kern.k_full(self.x_pl))\n",
    "\n",
    "    def _build_predict(self, n_test, full_cov=False):\n",
    "        with tf.name_scope(\"build_predict\"):\n",
    "            self.x_test_pl = tf.identity(\n",
    "                tf.placeholder(tf.float64, [n_test, self.input_dim], name=\"x_test_pl\")\n",
    "            )\n",
    "\n",
    "        tf.logging.info(\"Using pre-computed Kernel\")\n",
    "        self.k_data_test = self.kern.k_full(self.x_pl, self.x_test_pl)\n",
    "\n",
    "        with tf.name_scope(\"build_predict\"):\n",
    "            a = tf.matrix_triangular_solve(self.l, self.k_data_test)\n",
    "            fmean = tf.matmul(a, self.v, transpose_a=True)\n",
    "\n",
    "            if full_cov:\n",
    "                fvar = self.kern.k_full(self.x_test_pl) - tf.matmul(\n",
    "                    a, a, transpose_a=True)\n",
    "                shape = [1, 1, self.y_pl.shape[1]]\n",
    "                fvar = tf.tile(tf.expand_dims(fvar, 2), shape)\n",
    "            else:\n",
    "                fvar = self.kern.k_diag(self.x_test_pl) - tf.reduce_sum(tf.square(a), 0)\n",
    "                fvar = tf.tile(tf.reshape(fvar, (-1, 1)), [1, self.output_y.shape[1]])\n",
    "\n",
    "            self.fmean = fmean\n",
    "            self.fvar = fvar\n",
    "\n",
    "    def _build_cholesky(self):\n",
    "        tf.logging.info(\"Computing Kernel\")\n",
    "        self.k_data_data_reg = self.k_data_data + tf.eye(\n",
    "            self.input_x.shape[0], dtype=tf.float64) * self.stability_eps\n",
    "        if self.print_kernel:\n",
    "            self.k_data_data_reg = tf.Print(\n",
    "                self.k_data_data_reg, [self.k_data_data_reg],\n",
    "                message=\"K_DD = \", summarize=100)\n",
    "        self.l = tf.cholesky(self.k_data_data_reg)\n",
    "        self.v = tf.matrix_triangular_solve(self.l, self.y_pl)\n",
    "\n",
    "    def predict(self, test_x, sess, get_var=False):\n",
    "        \"\"\"Compute mean and varaince prediction for test inputs.\n",
    "\n",
    "        Raises:\n",
    "          ArithmeticError: Cholesky fails even after increasing to large values of\n",
    "            stability epsilon.\n",
    "        \"\"\"\n",
    "        if self.l_np is None:\n",
    "            self._build_cholesky()\n",
    "            start_time = time.time()\n",
    "            self.k_np = sess.run(self.k_data_data,\n",
    "                                 feed_dict={self.x_pl: self.input_x})\n",
    "            tf.logging.info(\"Computed K_DD in %.3f secs\" % (time.time() - start_time))\n",
    "\n",
    "            while self.current_stability_eps < 1:\n",
    "                try:\n",
    "                    start_time = time.time()\n",
    "                    self.l_np, self.v_np = sess.run(\n",
    "                        [self.l, self.v],\n",
    "                        feed_dict={self.y_pl: self.output_y,\n",
    "                                   self.k_data_data: self.k_np,\n",
    "                                   self.stability_eps: self.current_stability_eps})\n",
    "                    tf.logging.info(\n",
    "                        \"Computed L_DD in %.3f secs\" % (time.time() - start_time))\n",
    "                    break\n",
    "\n",
    "                except tf.errors.InvalidArgumentError:\n",
    "                    self.current_stability_eps *= 10\n",
    "                    tf.logging.info(\"Cholesky decomposition failed, trying larger epsilon\"\n",
    "                                    \": {}\".format(self.current_stability_eps))\n",
    "\n",
    "        if self.current_stability_eps > 0.2:\n",
    "            raise ArithmeticError(\"Could not compute Cholesky decomposition.\")\n",
    "\n",
    "        n_test = test_x.shape[0]\n",
    "        self._build_predict(n_test)\n",
    "        feed_dict = {\n",
    "            self.x_pl: self.input_x,\n",
    "            self.x_test_pl: test_x,\n",
    "            self.l: self.l_np,\n",
    "            self.v: self.v_np\n",
    "        }\n",
    "\n",
    "        start_time = time.time()\n",
    "        if get_var:\n",
    "            mean_pred, var_pred = sess.run(\n",
    "                [self.fmean, self.fvar], feed_dict=feed_dict)\n",
    "            tf.logging.info(\"Did regression in %.3f secs\" % (time.time() - start_time))\n",
    "            return mean_pred, var_pred, self.current_stability_eps\n",
    "\n",
    "        else:\n",
    "            mean_pred = sess.run(self.fmean, feed_dict=feed_dict)\n",
    "            tf.logging.info(\"Did regression in %.3f secs\" % (time.time() - start_time))\n",
    "            return mean_pred, self.current_stability_eps\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mldata.org dataset: mnist-original'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist = fetch_mldata('MNIST original', data_home='mnist')\n",
    "mnist.DESCR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "lb = LabelBinarizer()\n",
    "lb.fit(mnist.target)\n",
    "# encode target labels as zero-mean one hot encoded vector \n",
    "# with negative class = -0.1 and positive class as 0.9\n",
    "encode = lambda y: lb.transform(y) - .1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_train, image_test, label_train, label_test = train_test_split(\n",
    "    mnist.data, mnist.target, stratify = mnist.target, random_state = 444, test_size=.15)\n",
    "\n",
    "X_test = image_test\n",
    "y_test = encode(label_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_subset(n):\n",
    "    x, _, y, _ = train_test_split(image_train, label_train, stratify = label_train, random_state=333, train_size = n)\n",
    "    return x, encode(y)\n",
    "\n",
    "def get_test_subset(n):\n",
    "    _, x, _, y = train_test_split(image_train, label_train, stratify = label_train, random_state=333, train_size = n)\n",
    "    return x, encode(y)\n",
    "\n",
    "def accuracy(y, y_hat):\n",
    "    return np.mean(np.argmax(y, axis = 1) == np.argmax(y_hat, axis = 1))\n",
    "\n",
    "def do_nngp_experiment(layers, sample_size):\n",
    "    X_train, y_train = get_train_subset(sample_size)\n",
    "    config = tf.ConfigProto(\n",
    "           intra_op_parallelism_threads = 32,\n",
    "           inter_op_parallelism_threads = 32,\n",
    "           allow_soft_placement = True,\n",
    "           device_count = {'CPU' : 32, 'GPU' : 0}\n",
    "        )\n",
    "    with tf.Session(config=config) as sess:\n",
    "        nngp_kernel = NNGPKernel(\n",
    "            depth=layers,\n",
    "            weight_var=1.79,\n",
    "            bias_var=0.83,\n",
    "            nonlin_fn=tf.tanh,\n",
    "            grid_path='grid',\n",
    "            use_precomputed_grid=True,\n",
    "            n_gauss=501,\n",
    "            n_var=501,\n",
    "            n_corr=501,\n",
    "            max_gauss=10,\n",
    "            max_var=100,\n",
    "            use_fixed_point_norm=False)\n",
    "\n",
    "        model = GaussianProcessRegression(X_train, y_train, kern=nngp_kernel)\n",
    "        y_hat, test_eps = model.predict(X_test, sess)\n",
    "\n",
    "    return mean_squared_error(y_test, y_hat), accuracy(y_test, y_hat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.backend.tensorflow_backend import set_session\n",
    "\n",
    "def train_or_load_nn_model(nn_width, nn_depth, sample_size):\n",
    "    model_path = 'models/mnist_w%d_s%d' % (nn_width, sample_size)\n",
    "    config = tf.ConfigProto()\n",
    "    set_session(tf.Session(config=config))\n",
    "\n",
    "    if (os.path.isfile(model_path)):\n",
    "        model = load_model(model_path)\n",
    "    else:\n",
    "        model = Sequential()\n",
    "        model.add(Dense(nn_width, input_dim=784, kernel_initializer='normal', activation='tanh'))\n",
    "        for i in np.arange(1, nn_depth):\n",
    "            model.add(Dense(nn_width, kernel_initializer='normal', activation='tanh'))\n",
    "        model.add(Dense(10, kernel_initializer='normal'))\n",
    "        model.compile(loss='mean_squared_error', optimizer = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True))\n",
    "        X_train, y_train = get_train_subset(sample_size)\n",
    "        model.fit(X_train, y_train, epochs = 100, batch_size = 256, verbose = 0)\n",
    "        #model.save(model_path)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sample_sizes = np.array([1000, 3000, 5000,  10000])\n",
    "sample_sizes = np.array([1000, 3000, 5000,  10000, 20000, 50000])\n",
    "nn_depths    = np.array([8,    8,    4,     4,     2,     1])\n",
    "nn_widths = np.array([8, 16, 64, 128, 512, 1024])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample Size: 1000, Depth: 8, Width: 8\n",
      "WARNING:tensorflow:Variable *= will be deprecated. Use variable.assign_mul if you want assignment to the variable value or 'x = x * y' if you want a new python Tensor object.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2026: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample Size: 1000, Depth: 8, Width: 16\n",
      "Sample Size: 1000, Depth: 8, Width: 64\n",
      "Sample Size: 1000, Depth: 8, Width: 128\n",
      "Sample Size: 1000, Depth: 8, Width: 512\n",
      "Sample Size: 1000, Depth: 8, Width: 1024\n",
      "done sample size 1000\n",
      "Sample Size: 3000, Depth: 8, Width: 8\n",
      "Sample Size: 3000, Depth: 8, Width: 16\n",
      "Sample Size: 3000, Depth: 8, Width: 64\n",
      "Sample Size: 3000, Depth: 8, Width: 128\n",
      "Sample Size: 3000, Depth: 8, Width: 512\n",
      "Sample Size: 3000, Depth: 8, Width: 1024\n",
      "done sample size 3000\n",
      "Sample Size: 5000, Depth: 4, Width: 8\n",
      "Sample Size: 5000, Depth: 4, Width: 16\n",
      "Sample Size: 5000, Depth: 4, Width: 64\n",
      "Sample Size: 5000, Depth: 4, Width: 128\n",
      "Sample Size: 5000, Depth: 4, Width: 512\n",
      "Sample Size: 5000, Depth: 4, Width: 1024\n",
      "done sample size 5000\n",
      "Sample Size: 10000, Depth: 4, Width: 8\n",
      "Sample Size: 10000, Depth: 4, Width: 16\n",
      "Sample Size: 10000, Depth: 4, Width: 64\n",
      "Sample Size: 10000, Depth: 4, Width: 128\n",
      "Sample Size: 10000, Depth: 4, Width: 512\n",
      "Sample Size: 10000, Depth: 4, Width: 1024\n",
      "done sample size 10000\n",
      "Sample Size: 20000, Depth: 2, Width: 8\n",
      "Sample Size: 20000, Depth: 2, Width: 16\n",
      "Sample Size: 20000, Depth: 2, Width: 64\n",
      "Sample Size: 20000, Depth: 2, Width: 128\n",
      "Sample Size: 20000, Depth: 2, Width: 512\n",
      "Sample Size: 20000, Depth: 2, Width: 1024\n",
      "done sample size 20000\n",
      "Sample Size: 50000, Depth: 1, Width: 8\n",
      "Sample Size: 50000, Depth: 1, Width: 16\n",
      "Sample Size: 50000, Depth: 1, Width: 64\n",
      "Sample Size: 50000, Depth: 1, Width: 128\n",
      "Sample Size: 50000, Depth: 1, Width: 512\n",
      "Sample Size: 50000, Depth: 1, Width: 1024\n",
      "done sample size 50000\n"
     ]
    }
   ],
   "source": [
    "#nn_results = np.empty((sample_sizes.shape[0], nn_widths.shape[0], 2))\n",
    "columns = ['Model Name', 'Sample Size', 'MSE', 'Accuracy']\n",
    "results_df = pd.DataFrame(columns=columns)\n",
    "\n",
    "for i, sample_size in enumerate(sample_sizes):\n",
    "    for j, nn_width in enumerate(nn_widths):\n",
    "        print('Sample Size: {}, Depth: {}, Width: {}'.format(sample_size, nn_depths[i], nn_width))\n",
    "        m = train_or_load_nn_model(nn_width = nn_width, nn_depth = nn_depths[i], sample_size = sample_size)\n",
    "        y_hat = m.predict(X_test)\n",
    "        model_name = 'NN-{}'.format(nn_width)\n",
    "        acc_result = accuracy(y_test, y_hat)  \n",
    "        mse_result = mean_squared_error(y_test, y_hat)\n",
    "        #nn_results[i, j, 0] = accuracy(y_test, y_hat)  \n",
    "        #nn_results[i, j, 1] = mean_squared_error(y_test, y_hat)\n",
    "        results_df = pd.concat([results_df, pd.DataFrame([[model_name, sample_size, mse_result, acc_result]], columns=columns)], ignore_index=True)\n",
    "    print('done sample size %d' % sample_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample size: 1000, Depth: 8\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2026: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From nngp/interp.py:91: calling reduce_sum (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "keep_dims is deprecated, use keepdims instead\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 2.501 secs\n",
      "INFO:tensorflow:Computed L_DD in 0.172 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 9.288 secs\n",
      "Sample size: 3000, Depth: 8\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 7.727 secs\n",
      "INFO:tensorflow:Computed L_DD in 0.637 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 27.043 secs\n",
      "Sample size: 5000, Depth: 4\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 10.122 secs\n",
      "INFO:tensorflow:Computed L_DD in 2.056 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 26.880 secs\n",
      "Sample size: 10000, Depth: 4\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 35.057 secs\n",
      "INFO:tensorflow:Computed L_DD in 13.104 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 68.142 secs\n",
      "Sample size: 20000, Depth: 2\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 66.156 secs\n",
      "INFO:tensorflow:Computed L_DD in 92.722 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 173.554 secs\n",
      "Sample size: 50000, Depth: 1\n",
      "INFO:tensorflow:Loaded interpolation grid from grid/grid_tanh_ng501_ns502_nc501_mv100_mg10\n",
      "INFO:tensorflow:Computing Kernel\n",
      "INFO:tensorflow:Computed K_DD in 198.930 secs\n",
      "INFO:tensorflow:Computed L_DD in 1422.618 secs\n",
      "INFO:tensorflow:Using pre-computed Kernel\n",
      "INFO:tensorflow:Did regression in 1065.014 secs\n"
     ]
    }
   ],
   "source": [
    "for i, sample_size in enumerate(sample_sizes):\n",
    "    print('Sample size: {}, Depth: {}'.format(sample_size, nn_depths[i]))\n",
    "    mse_result, acc_result = do_nngp_experiment(layers=nn_depths[i], sample_size=sample_size)\n",
    "    model_name = 'NNGP'\n",
    "    results_df = pd.concat([results_df, pd.DataFrame([[model_name, sample_size, mse_result, acc_result]], columns=columns)], ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Model Name</th>\n",
       "      <th>Sample Size</th>\n",
       "      <th>MSE</th>\n",
       "      <th>Accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.089971</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.089971</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.089962</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.083207</td>\n",
       "      <td>0.405333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.061800</td>\n",
       "      <td>0.749143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.117121</td>\n",
       "      <td>0.629238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.089971</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.089971</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.089911</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.063064</td>\n",
       "      <td>0.623429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.040880</td>\n",
       "      <td>0.852571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.062435</td>\n",
       "      <td>0.805429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.089961</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.086535</td>\n",
       "      <td>0.209810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.043849</td>\n",
       "      <td>0.796952</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.040168</td>\n",
       "      <td>0.830095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.038129</td>\n",
       "      <td>0.878190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.048642</td>\n",
       "      <td>0.862571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.089871</td>\n",
       "      <td>0.112571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.072920</td>\n",
       "      <td>0.335429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.024777</td>\n",
       "      <td>0.880952</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.024667</td>\n",
       "      <td>0.887333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.027087</td>\n",
       "      <td>0.911905</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.031409</td>\n",
       "      <td>0.912095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.045158</td>\n",
       "      <td>0.690190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.026882</td>\n",
       "      <td>0.852286</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.017097</td>\n",
       "      <td>0.904381</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.017251</td>\n",
       "      <td>0.910571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.020885</td>\n",
       "      <td>0.926571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.025147</td>\n",
       "      <td>0.928667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>NN-8</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.033742</td>\n",
       "      <td>0.849810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>NN-16</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.020873</td>\n",
       "      <td>0.885333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>NN-64</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.015931</td>\n",
       "      <td>0.914857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>NN-128</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.014475</td>\n",
       "      <td>0.925810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>NN-512</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.015142</td>\n",
       "      <td>0.933048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>NN-1024</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.019558</td>\n",
       "      <td>0.941429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>1000</td>\n",
       "      <td>0.020460</td>\n",
       "      <td>0.928762</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.013834</td>\n",
       "      <td>0.954571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>5000</td>\n",
       "      <td>0.011747</td>\n",
       "      <td>0.962952</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.009235</td>\n",
       "      <td>0.973048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>20000</td>\n",
       "      <td>0.007221</td>\n",
       "      <td>0.979619</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>NNGP</td>\n",
       "      <td>50000</td>\n",
       "      <td>0.005330</td>\n",
       "      <td>0.985619</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Model Name Sample Size       MSE  Accuracy\n",
       "0        NN-8        1000  0.089971  0.112571\n",
       "1       NN-16        1000  0.089971  0.112571\n",
       "2       NN-64        1000  0.089962  0.112571\n",
       "3      NN-128        1000  0.083207  0.405333\n",
       "4      NN-512        1000  0.061800  0.749143\n",
       "5     NN-1024        1000  0.117121  0.629238\n",
       "6        NN-8        3000  0.089971  0.112571\n",
       "7       NN-16        3000  0.089971  0.112571\n",
       "8       NN-64        3000  0.089911  0.112571\n",
       "9      NN-128        3000  0.063064  0.623429\n",
       "10     NN-512        3000  0.040880  0.852571\n",
       "11    NN-1024        3000  0.062435  0.805429\n",
       "12       NN-8        5000  0.089961  0.112571\n",
       "13      NN-16        5000  0.086535  0.209810\n",
       "14      NN-64        5000  0.043849  0.796952\n",
       "15     NN-128        5000  0.040168  0.830095\n",
       "16     NN-512        5000  0.038129  0.878190\n",
       "17    NN-1024        5000  0.048642  0.862571\n",
       "18       NN-8       10000  0.089871  0.112571\n",
       "19      NN-16       10000  0.072920  0.335429\n",
       "20      NN-64       10000  0.024777  0.880952\n",
       "21     NN-128       10000  0.024667  0.887333\n",
       "22     NN-512       10000  0.027087  0.911905\n",
       "23    NN-1024       10000  0.031409  0.912095\n",
       "24       NN-8       20000  0.045158  0.690190\n",
       "25      NN-16       20000  0.026882  0.852286\n",
       "26      NN-64       20000  0.017097  0.904381\n",
       "27     NN-128       20000  0.017251  0.910571\n",
       "28     NN-512       20000  0.020885  0.926571\n",
       "29    NN-1024       20000  0.025147  0.928667\n",
       "30       NN-8       50000  0.033742  0.849810\n",
       "31      NN-16       50000  0.020873  0.885333\n",
       "32      NN-64       50000  0.015931  0.914857\n",
       "33     NN-128       50000  0.014475  0.925810\n",
       "34     NN-512       50000  0.015142  0.933048\n",
       "35    NN-1024       50000  0.019558  0.941429\n",
       "36       NNGP        1000  0.020460  0.928762\n",
       "37       NNGP        3000  0.013834  0.954571\n",
       "38       NNGP        5000  0.011747  0.962952\n",
       "39       NNGP       10000  0.009235  0.973048\n",
       "40       NNGP       20000  0.007221  0.979619\n",
       "41       NNGP       50000  0.005330  0.985619"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (14, 5))\n",
    "ax1 = plt.subplot(121)\n",
    "results_df.pivot(index='Sample Size', columns='Model Name', values='Accuracy').plot(ax=ax1)\n",
    "plt.ylabel('accuracy')\n",
    "ax2 = plt.subplot(122)\n",
    "results_df.pivot(index='Sample Size', columns='Model Name', values='MSE').plot(ax=ax2)\n",
    "plt.ylabel('mse')\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_tensorflow_p36)",
   "language": "python",
   "name": "conda_tensorflow_p36"
  },
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}