04a-Bayesian-Neural-Network-Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bayesian Neural Network (Classification) MCMC\n",
    "Part of the Bayesian neural networks via MCMC: a Python-based tutorial.\n",
    "\n",
    "This section of the tutorial covers the development of an MCMC algorithm applied to a Neural Network for classification problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from ipywidgets import interact, fixed, widgets\n",
    "from tqdm import tqdm\n",
    "# visulisation function\n",
    "from functions.visualisations import (\n",
    "    histogram_trace, plot_confusion_matrix, boxplot_weights\n",
    ")\n",
    "\n",
    "from types import MethodType\n",
    "\n",
    "np.random.seed(2023)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define a class with the functions and attributes required for a neural network model\n",
    "First lets define our forward and backward pass functions which form the core of our model. These will be integrated into the NeuralNetwork class and thus contain references to class attributes.\n",
    "\n",
    "- `forward_pass`: Function to calculate the output of the network from the input data ($x$)\n",
    "    - for our hidden layer - $h_{output} = g\\left(x \\cdot w_{h} + \\delta_{h} \\right)$ \n",
    "    - subsequently for the output layer - $f\\left(x\\right) = o_{output} = g\\left(h_{output} \\cdot w_{o} + \\delta_{o} \\right)$\n",
    "    - where $g(\\cdot)$ is the sigmoid activation function, $w_{h}$ and $w_{o}$ are the weights for the hidden and output layers, and $\\delta_{h}$ and $\\delta_{o}$ are the biases for the hidden and output layers, respectively.\n",
    "- `backward_pass`: Function to update the model parameters using Langevin dynamics\n",
    "    - $\\bar{\\theta_p} = \\theta_p + r \\times \\nabla E_{y_{\\mathcal{A}_{D,T}}}\\left[\\theta_p\\right]$\n",
    "    - $\\nabla E_{y_{\\mathcal{A}_{D,T}}}\\left[\\theta_p\\right] = \\left(\\frac{\\delta E}{\\delta \\theta_1},\\dots, \\frac{\\delta E}{\\delta \\theta_L} \\right)$\n",
    "    - $E_{y_{\\mathcal{A}_{D,T}}}\\left[\\theta_p\\right] = \\sum_{t \\in \\mathcal{A}_{D,T}} \\left(y_t - f\\left(x_t\\right)^{[k]}\\right)^2$\n",
    "    - where $\\theta = \\left(w_{h},w_{o},\\delta_{h},\\delta_{o}\\right)$ comprises the weights and biases of the NN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NN prediction\n",
    "def forward_pass(self, X):\n",
    "    '''\n",
    "    Take an input X and return the output of the network\n",
    "    Input:\n",
    "        - X: (N x num_features) array of input data\n",
    "    Output:\n",
    "        - self.l2_output: (N) array of output data f(x) which can be \n",
    "        compared to observations (Y)\n",
    "    '''\n",
    "    # Hidden layer\n",
    "    l1_z = np.dot(X, self.l1_weights) + self.l1_biases\n",
    "    self.l1_output = self.sigmoid(l1_z) # activation function g(.)\n",
    "    # Output layer\n",
    "    l2_z = np.dot(self.l1_output, self.l2_weights) + self.l2_biases\n",
    "    self.l2_output = self.sigmoid(l2_z)\n",
    "    return self.l2_output\n",
    "\n",
    "def backward_pass(self, X, Y):\n",
    "    '''\n",
    "    Compute the gradients using a backward pass and undertake Langevin-gradient \n",
    "    updating of parameters\n",
    "    Input:\n",
    "        - X: (N x num_features) array of input data\n",
    "        - Y: (N) array of target data\n",
    "    '''\n",
    "    # transform to one-hot encoding\n",
    "    Y_transformed = np.zeros((self.output_num,))\n",
    "    Y_transformed[Y.astype(int)] = 1\n",
    "    # dE/dtheta\n",
    "    l2_delta = (Y_transformed - self.l2_output) * (self.l2_output * (1 - self.l2_output))\n",
    "    l2_weights_delta = np.outer(\n",
    "        self.l1_output,\n",
    "        l2_delta\n",
    "    )\n",
    "    # backprop of l2_delta and same as above\n",
    "    l1_delta = np.dot(l2_delta,self.l2_weights.T) * (self.l1_output * (1 - self.l1_output))        \n",
    "    l1_weights_delta = np.outer(\n",
    "        X,\n",
    "        l1_delta\n",
    "    )\n",
    "\n",
    "    # update for output layer\n",
    "    self.l2_weights += self.lrate * l2_weights_delta\n",
    "    self.l2_biases += self.lrate * l2_delta\n",
    "    # update for hidden layer\n",
    "    self.l1_weights += self.lrate * l1_weights_delta\n",
    "    self.l1_biases += self.lrate * l1_delta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we the NeuralNetwork class, which constitutes our model. For readability we have defined the forward and backward passes above, but we will add these to the NeuralNetwork class below. The class contains the following functions:\n",
    "\n",
    "- `initialise_network`: Function to initialise the weights and biases of the network in both the hidden and output layers\n",
    "- `evaluate_proposal`: Function to assign a proposed $\\theta$ to the weights and biases and forward_pass the input data\n",
    "- `langevin_gradient`: Function to calculate the Langevin gradient based parameter updates. This uses the gradient computation in the `backward_pass` detailed above\n",
    "- `sigmoid`: Sigmoid activation function\n",
    "- `encode`: Return a vector $\\theta$ of the current weights and biases of the network\n",
    "- `decode`: Take a vector $\\theta$ and assign it to the weights and biases of the network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork:\n",
    "    '''\n",
    "    Neural Network model with a single hidden layer and a single output (y)\n",
    "    '''\n",
    "    def __init__(self, layer_sizes,learning_rate=0.01):\n",
    "        '''\n",
    "        Initialize the model\n",
    "        Input:\n",
    "            - layer_sizes (input, hidden, output): array specifying the number of \n",
    "            nodes in each layer\n",
    "            - learning_rate: learning rate for the gradient update\n",
    "        '''\n",
    "        # Initial values of model parameters\n",
    "        self.input_num = layer_sizes[0]\n",
    "        self.hidden_num = layer_sizes[1]\n",
    "        self.output_num = layer_sizes[2]\n",
    "\n",
    "        # total number of parameters from weights and biases\n",
    "        self.n_params = (self.input_num * self.hidden_num) + (self.hidden_num * self.output_num) +\\\n",
    "            self.hidden_num + self.output_num\n",
    "        # learning params\n",
    "        self.lrate = learning_rate\n",
    "\n",
    "        # Initialize network structure\n",
    "        self.initialise_network()\n",
    "\n",
    "        # functions defined above - this is poor practice, but done for readability \n",
    "        # and clarity\n",
    "        self.forward_pass = MethodType(forward_pass, self)\n",
    "        self.backward_pass = MethodType(backward_pass, self)\n",
    "\n",
    "    def initialise_network(self):\n",
    "        '''\n",
    "        Initialize network structure - weights and biases for the hidden layer\n",
    "        and output layer\n",
    "        '''\n",
    "        # hidden layer\n",
    "        self.l1_weights = np.random.normal(\n",
    "            loc=0, scale=1/np.sqrt(self.input_num),\n",
    "            size=(self.input_num, self.hidden_num))\n",
    "        self.l1_biases = np.random.normal(\n",
    "            loc=0, scale=1/np.sqrt(self.hidden_num), \n",
    "            size=(self.hidden_num,))\n",
    "        # placeholder for storing the hidden layer values\n",
    "        self.l1_output = np.zeros((1, self.hidden_num))\n",
    "\n",
    "        # output layer\n",
    "        self.l2_weights = np.random.normal(\n",
    "            loc=0, scale=1/np.sqrt(self.hidden_num), \n",
    "            size=(self.hidden_num, self.output_num))\n",
    "        self.l2_biases = np.random.normal(\n",
    "            loc=0, scale=1/np.sqrt(self.hidden_num), \n",
    "            size=(self.output_num,))\n",
    "        # placeholder for storing the model outputs\n",
    "        self.l2_output = np.zeros((1, self.output_num))\n",
    "\n",
    "    def evaluate_proposal(self, x_data, theta):\n",
    "        '''\n",
    "        A helper function to take the input data and proposed parameter sample \n",
    "        and return the prediction\n",
    "        Input:\n",
    "            data: (N x num_features) array of data\n",
    "            theta: (w,v,b_h,b_o) vector of parameters with weights and biases\n",
    "        '''\n",
    "        self.decode(theta)  # method to decode w into W1, W2, B1, B2.\n",
    "        size = x_data.shape[0]\n",
    "\n",
    "        fx = np.zeros(size)\n",
    "        prob = np.zeros((size,self.output_num))\n",
    "\n",
    "        for i in range(0, size):  # to see what fx is produced by your current weight update\n",
    "            fx_tmp = self.forward_pass(x_data[i,])\n",
    "            # classification\n",
    "            fx[i] = np.argmax(fx_tmp)\n",
    "            prob[i,:] = self.softmax(fx_tmp)\n",
    "\n",
    "        return fx, prob\n",
    "\n",
    "    def langevin_gradient(self, x_data, y_data, theta, depth):\n",
    "        '''\n",
    "        Compute the Langevin gradient based proposal distribution\n",
    "        Input:\n",
    "            - x_data: (N x num_features) array of input data\n",
    "            - y_data: (N) array of target data\n",
    "            - theta: (w,v,b_h,b_o) vector of proposed parameters.\n",
    "            - depth: SGD depth\n",
    "        Output: \n",
    "            - theta_updated: Updated parameter proposal\n",
    "\n",
    "        '''\n",
    "        self.decode(theta)  # method to decode w into W1, W2, B1, B2.\n",
    "        size = x_data.shape[0] \n",
    "        # Update the parameters based on LG \n",
    "        for _ in range(0, depth):\n",
    "            for ii in range(0, size):\n",
    "                self.forward_pass(x_data[ii,])\n",
    "                self.backward_pass(x_data[ii,], y_data[ii])\n",
    "        theta_updated = self.encode()\n",
    "        return  theta_updated\n",
    "\n",
    "    # Helper functions\n",
    "    def sigmoid(self, x):\n",
    "        '''\n",
    "        Implentation of the sigmoid function\n",
    "        '''\n",
    "        return 1 / (1 + np.exp(-x))\n",
    "        \n",
    "    def softmax(self, x):\n",
    "        '''\n",
    "        Implentation of the softmax function\n",
    "        '''\n",
    "        prob = np.exp(x) / np.sum(np.exp(x))\n",
    "        return prob\n",
    "\n",
    "    def encode(self):\n",
    "        '''\n",
    "        Encode the model parameters into a vector\n",
    "        Output:\n",
    "            - theta: vector of parameters.\n",
    "        '''\n",
    "        w1 = self.l1_weights.ravel()\n",
    "        w2 = self.l2_weights.ravel()\n",
    "        theta = np.concatenate([w1, w2, self.l1_biases, self.l2_biases])\n",
    "        return theta\n",
    "        \n",
    "    def decode(self, theta):\n",
    "        '''\n",
    "        Decode the model parameters from a vector\n",
    "        Input:\n",
    "            - theta: vector of parameters.\n",
    "        '''\n",
    "        w_layer1size = self.input_num * self.hidden_num\n",
    "        w_layer2size = self.hidden_num * self.output_num\n",
    "\n",
    "        w_layer1 = theta[0:w_layer1size]\n",
    "        self.l1_weights = np.reshape(w_layer1, (self.input_num, self.hidden_num))\n",
    "\n",
    "        w_layer2 = theta[w_layer1size:w_layer1size + w_layer2size]\n",
    "        self.l2_weights = np.reshape(w_layer2, (self.hidden_num, self.output_num))\n",
    "        self.l1_biases = theta[w_layer1size + w_layer2size:w_layer1size + w_layer2size + self.hidden_num]\n",
    "        self.l2_biases = theta[w_layer1size + w_layer2size + self.hidden_num:w_layer1size + w_layer2size + self.hidden_num + self.output_num]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define a class for the MCMC sampling\n",
    "First we will define our `likelihood_function` and `prior` functions. These will be integrated into the MCMC class and thus contain references to class attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the likelihood function\n",
    "def likelihood_function(self, theta, test=False):\n",
    "    '''\n",
    "    Calculate the likelihood of the data given the parameters\n",
    "    Input:\n",
    "        theta: (M + 1) vector of parameters. The last element of theta consitutes the bias term (giving M + 1 elements)\n",
    "    Output:\n",
    "        log_likelihood: log likelihood of the data given the parameters\n",
    "        model_prediction: prediction of the model given the parameters\n",
    "        accuracy: accuracy of the model given the parameters\n",
    "    '''\n",
    "    # first make a prediction with parameters theta\n",
    "    if test:\n",
    "        x_data = self.x_test\n",
    "        y_data = self.y_test\n",
    "    else:\n",
    "        x_data = self.x_data\n",
    "        y_data = self.y_data\n",
    "    model_prediction, probs = self.model.evaluate_proposal(x_data, theta)\n",
    "    model_simulation = model_prediction # tausq unused for classification\n",
    "    accuracy = self.accuracy(model_prediction, y_data) #Accuracy error metric \n",
    "    # now calculate the log likelihood\n",
    "    log_likelihood = 0\n",
    "    for ii in np.arange(x_data.shape[0]):\n",
    "        for jj in np.arange(self.model.output_num):\n",
    "            if y_data[ii] == jj:\n",
    "                log_likelihood += np.log(probs[ii,jj])    \n",
    "    return [log_likelihood, model_prediction, model_simulation, accuracy] \n",
    "\n",
    "# Define the prior\n",
    "def prior(self, sigma_squared, theta): \n",
    "    '''\n",
    "    Calculate the prior of the parameters\n",
    "    Input:\n",
    "        sigma_squared: variance of normal prior for theta\n",
    "        theta: (M + 1) vector of parameters. The last element of theta consitutes the bias term (giving M + 1 elements)\n",
    "    Output:\n",
    "        log_prior: log prior\n",
    "    '''\n",
    "    n_params = self.theta_size # number of parameters in model\n",
    "    part1 = -1 * (n_params / 2) * np.log(sigma_squared)\n",
    "    part2 = 1 / (2 * sigma_squared) * (sum(np.square(theta)))\n",
    "    log_prior = part1 - part2\n",
    "    return log_prior"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we define the MCMC sampler as outlined in the text:\n",
    "\n",
    "<img src=\"img/LG_MCMC_algorithm.png\" width=\"50%\">\n",
    "\n",
    "- The acceptance probability is\n",
    "    - $\\alpha = \\Bigg(1, \\frac{p\\left(\\theta^p_s|Y\\right)q\\left(\\theta^{[i]}|\\theta^{p}\\right)}{p\\left(\\theta^{[i]}|Y\\right)q\\left(\\theta^{p}|\\theta^{[i]}\\right)}\\Bigg)$\n",
    "- the log posterior ratio:\n",
    "    - $\\frac{p\\left(\\theta^p_s|Y\\right)}{p\\left(\\theta^{[i]}|Y\\right)}$\n",
    "    - where the log posterior is given by the sum of the prior and likelihood:\n",
    "    - $\\log\\left(p\\left(\\theta|Y\\right)\\right) = \\log\\left(p\\left(\\theta\\right)\\right) + \\log\\left(p\\left(Y|X,\\theta\\right)\\right)$\n",
    "    - is calculated from the following parts:\n",
    "    - `diff_likelihood`: gives the likelihood - $\\log\\left(p\\left(Y|X,\\theta\\right)\\right)$ - component of log posterior ratio  \n",
    "    - `diff_prior` gives the prior - $\\log\\left(p\\left(\\theta\\right)\\right)$ - component of log posterior ratio  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MCMC sampler\n",
    "def sampler(self):\n",
    "    '''\n",
    "    Run the sampler for a defined Neural Network model\n",
    "    '''\n",
    "    # define empty arrays to store the sampled posterior values\n",
    "    # posterior of all weights and bias over all samples\n",
    "    pos_theta = np.ones((self.n_samples, self.theta_size)) \n",
    "\n",
    "    # record output f(x) over all samples\n",
    "    pred_y = np.zeros((self.n_samples, self.x_data.shape[0]))\n",
    "    # record simulated values f(x) + error over all samples \n",
    "    sim_y = np.zeros((self.n_samples, self.x_data.shape[0]))\n",
    "    # record the accuracy of each sample\n",
    "    accuracy_data = np.zeros(self.n_samples)\n",
    "    # now for test\n",
    "    test_pred_y = np.ones((self.n_samples, self.x_test.shape[0]))\n",
    "    test_sim_y = np.ones((self.n_samples, self.x_test.shape[0]))\n",
    "    test_accuracy_data = np.zeros(self.n_samples)\n",
    "\n",
    "    ## Initialisation\n",
    "    # initialise theta\n",
    "    theta = np.random.randn(self.theta_size)\n",
    "    # make initial prediction\n",
    "    pred_y[0,], _ = self.model.evaluate_proposal(self.x_data, theta)\n",
    "\n",
    "    # Hyperpriors - considered by looking at distribution of  similar trained  models - i.e distribution of weights and bias\n",
    "    sigma_squared = self.sigma_squared\n",
    "\n",
    "    # calculate the prior\n",
    "    prior_val = self.prior(sigma_squared, theta)\n",
    "    # calculate the likelihood considering observations\n",
    "    [likelihood, pred_y[0,], sim_y[0,], accuracy_data[0]] = self.likelihood_function(theta)\n",
    "\n",
    "    n_accept = 0  \n",
    "    n_langevin = 0\n",
    "    # Run the MCMC sample for n_samples\n",
    "    for ii in tqdm(np.arange(1,self.n_samples)):\n",
    "        # Sample new values for theta\n",
    "        theta_proposal = theta + np.random.normal(0, self.step_theta, self.theta_size)\n",
    "\n",
    "        lx = np.random.uniform(0,1,1)\n",
    "        if (self.use_langevin_gradients is True) and (lx < self.l_prob):  \n",
    "            theta_gd = self.model.langevin_gradient(self.x_data, self.y_data, theta.copy(), self.sgd_depth)  \n",
    "            theta_proposal = np.random.normal(theta_gd, self.step_theta, self.theta_size)\n",
    "            theta_proposal_gd = self.model.langevin_gradient(self.x_data, self.y_data, theta_proposal.copy(), self.sgd_depth) \n",
    "\n",
    "            # for numerical reasons, we will provide a simplified implementation that simplifies\n",
    "            # the MVN of the proposal distribution\n",
    "            wc_delta = (theta - theta_proposal_gd) \n",
    "            wp_delta = (theta_proposal - theta_gd)\n",
    "\n",
    "            sigma_sq = self.step_theta\n",
    "\n",
    "            first = -0.5 * np.sum(wc_delta * wc_delta) / sigma_sq  # this is wc_delta.T  *  wc_delta /sigma_sq\n",
    "            second = -0.5 * np.sum(wp_delta * wp_delta) / sigma_sq\n",
    "\n",
    "            diff_prop =  first - second\n",
    "            n_langevin += 1\n",
    "        else:\n",
    "            diff_prop = 0\n",
    "            theta_proposal = np.random.normal(theta, self.step_theta, self.theta_size)\n",
    "\n",
    "        # calculate the prior\n",
    "        prior_proposal = self.prior(\n",
    "            sigma_squared, theta_proposal\n",
    "        )  # takes care of the gradients\n",
    "        # calculate the likelihood considering observations\n",
    "        [likelihood_proposal, pred_y[ii,], sim_y[ii,], accuracy_data[ii]] = self.likelihood_function(theta_proposal)\n",
    "\n",
    "        # calculate the test likelihood\n",
    "        [_, test_pred_y[ii,], test_sim_y[ii,], test_accuracy_data[ii]] = self.likelihood_function(\n",
    "            theta_proposal, test=True\n",
    "        )\n",
    "\n",
    "        # since we using log scale: based on https://www.rapidtables.com/math/algebra/Logarithm.html\n",
    "        diff_likelihood = likelihood_proposal - likelihood\n",
    "        diff_prior = prior_proposal - prior_val\n",
    "        \n",
    "        mh_prob = min(1, np.exp(diff_likelihood + diff_prior + diff_prop))\n",
    "\n",
    "        u = np.random.uniform(0, 1)\n",
    "\n",
    "        # Accept/reject\n",
    "        if u < mh_prob:\n",
    "            # Update position\n",
    "            n_accept += 1\n",
    "            # update\n",
    "            likelihood = likelihood_proposal\n",
    "            prior_val = prior_proposal\n",
    "            theta = theta_proposal\n",
    "            # and store\n",
    "            pos_theta[ii,] = theta_proposal\n",
    "        else:\n",
    "            # store\n",
    "            pos_theta[ii,] = pos_theta[ii-1,]\n",
    "\n",
    "    # print the % of times the proposal was accepted\n",
    "    accept_ratio = (n_accept / self.n_samples) * 100\n",
    "    print('{:.3}% were acepted'.format(accept_ratio))\n",
    "\n",
    "    # store the posterior of theta\n",
    "    self.pos_theta = pos_theta[self.n_burnin:, ]\n",
    "\n",
    "    # Create a pandas dataframe to store the posterior samples of theta\n",
    "    results_dict = {'w{}'.format(_): self.pos_theta[:, _].squeeze() for _ in range(self.theta_size-2)}\n",
    "    results_dict['b0'] = self.pos_theta[:, self.theta_size-2].squeeze()\n",
    "    results_dict['b1'] = self.pos_theta[:, self.theta_size-1].squeeze()    \n",
    " \n",
    "    # return the predictions\n",
    "    pred_dict = {}\n",
    "    pred_dict['train_pred'] = pred_y[self.n_burnin:,:]\n",
    "    pred_dict['train_sim'] = sim_y[self.n_burnin:,:]\n",
    "    pred_dict['test_pred'] = test_pred_y[self.n_burnin:,:]\n",
    "    pred_dict['test_sim'] = test_sim_y[self.n_burnin:,:]\n",
    "    \n",
    "    results_df = pd.DataFrame.from_dict(\n",
    "        results_dict\n",
    "    )\n",
    "\n",
    "    return results_df, pred_dict"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we the put together MCMC class, which runs the sampling of our model. For readability we have defined the some key funtions above and we will add these to the MCMC class below. The class contains the following functions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MCMC:\n",
    "    def __init__(self, model, n_samples, n_burnin, x_data, y_data, x_test, y_test):\n",
    "        self.n_samples = n_samples # number of MCMC samples\n",
    "        self.n_burnin = n_burnin # number of burn-in samples\n",
    "        self.x_data = x_data # (N x num_features)\n",
    "        self.y_data = y_data # (N x 1)\n",
    "        self.x_test = x_test # (Nt x num_features)\n",
    "        self.y_test = y_test # (Nt x 1)\n",
    "\n",
    "        # MCMC parameters - defines how much variation you need in changes to theta\n",
    "        self.step_theta = 0.025;  \n",
    "        # Hyperpriors\n",
    "        self.sigma_squared = 25\n",
    "\n",
    "        # initisalise the linear model class\n",
    "        self.model = model\n",
    "        self.use_langevin_gradients = True\n",
    "        self.sgd_depth = 1\n",
    "        self.l_prob = 0.5 # likelihood prob\n",
    "        self.theta_size = self.model.n_params # weights for each feature and a bias term\n",
    "\n",
    "        # store output\n",
    "        self.pos_theta = None\n",
    "        self.accuracy_data = None\n",
    "\n",
    "        # functions defined above - this is poor practice, but done for readability \n",
    "        # and clarity\n",
    "        self.likelihood_function = MethodType(likelihood_function, self)\n",
    "        self.prior = MethodType(prior, self)\n",
    "        self.sampler = MethodType(sampler, self)\n",
    "\n",
    "    # Additional error metric\n",
    "    @staticmethod\n",
    "    def accuracy(predictions, targets):\n",
    "        '''\n",
    "        Additional error metric - accuracy\n",
    "        '''\n",
    "        count = (predictions == targets).sum()\n",
    "        return 100 * (count / predictions.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data\n",
    "- Load in the suspot data\n",
    "- You can also load in the other regeression datasets `Lazer` and `Energy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data shape: (105, 5)\n",
      "Test data shape: (45, 5)\n"
     ]
    }
   ],
   "source": [
    "# load the data\n",
    "name        = \"Iris\" # \"Sunspot\", \"Abalone\"\n",
    "train_data   = np.loadtxt(\"data/{}/train.txt\".format(name))\n",
    "test_data    = np.loadtxt(\"data/{}/test.txt\".format(name))\n",
    "\n",
    "print('Training data shape: {}'.format(train_data.shape))\n",
    "print('Test data shape: {}'.format(test_data.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sample using MCMC\n",
    "\n",
    "- Create the MCMC loop and sample the posterior distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
<<<<<<< Updated upstream
      "  0%|          | 13/4999 [00:00<00:39, 125.24it/s]"
=======
      "100%|██████████████████████████████████████| 4999/4999 [00:28<00:00, 172.72it/s]"
>>>>>>> Stashed changes
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
<<<<<<< Updated upstream
      "100%|██████████| 4999/4999 [00:42<00:00, 117.89it/s]"
=======
      "96.7% was accepted\n"
>>>>>>> Stashed changes
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
<<<<<<< Updated upstream
      "96.4% were acepted\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
=======
>>>>>>> Stashed changes
      "\n"
     ]
    }
   ],
   "source": [
    "## MCMC Settings and Setup\n",
    "n_samples       = 5000 # number of samples to draw from the posterior\n",
    "burn_in         = int(n_samples* 0.5) # number of samples to discard before recording draws from the posterior\n",
    "hidden          = 10\n",
    "learning_rate   = 0.01\n",
    "\n",
    "x_data = train_data[:,:-1]\n",
    "y_data = train_data[:,-1]\n",
    "x_test = test_data[:,:-1]\n",
    "y_test = test_data[:,-1]\n",
    "\n",
    "if name in ['Iris']:\n",
    "    layer_sizes = [x_data.shape[1], hidden, 3]\n",
    "    data_case = 'classification'\n",
    "elif name in ['Ionosphere']:\n",
    "    layer_sizes = [x_data.shape[1], hidden, 2]\n",
    "    data_case = 'classification'\n",
    "else:\n",
    "    raise ValueError('data_case is invalid.')\n",
    "\n",
    "# Initialise the MCMC class\n",
    "nn_model = NeuralNetwork(layer_sizes,learning_rate)\n",
    "mcmc = MCMC(nn_model,n_samples, burn_in, x_data, y_data, x_test, y_test)\n",
    "# Run the sampler\n",
    "results, pred = mcmc.sampler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gather the predicitons into useful variables\n",
    "pred_y = pred['train_pred']\n",
    "sim_y = pred['train_sim']\n",
    "pred_y_test = pred['test_pred']\n",
    "sim_y_test = pred['test_sim']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyse the results\n",
    "Plot the data with the mean linear fit and some uncertainty.\n",
    "\n",
    "Plot the posterior distribution and trace for each parameter using ipywidgets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
<<<<<<< Updated upstream
      "image/png": "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",
=======
      "image/png": "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",
>>>>>>> Stashed changes
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
<<<<<<< Updated upstream
      "image/png": "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",
=======
      "image/png": "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",
>>>>>>> Stashed changes
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(y_data, pred_y, title='Train - Confusion Matrix')\n",
    "plot_confusion_matrix(y_test, pred_y_test, title='Test - Confusion Matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
<<<<<<< Updated upstream
      "Train accuracy: 97.565% (0.519)\n",
      "Test accuracy: 97.982% (0.925)\n"
=======
      "Train accuracy: 97.014% (0.347)\n",
      "Test accuracy: 99.697% (0.851)\n"
>>>>>>> Stashed changes
     ]
    }
   ],
   "source": [
    "# Print the train/test accuracy\n",
    "trainacc = np.array([mcmc.accuracy(pred_y[_,:], y_data) for _ in np.arange(pred_y.shape[0])])\n",
    "testacc = np.array([mcmc.accuracy(pred_y_test[_,:], y_test) for _ in np.arange(pred_y_test.shape[0])])\n",
    "\n",
    "print('Train accuracy: {:.3f}% ({:.3f})'.format(trainacc.mean(), trainacc.std()))\n",
    "print('Test accuracy: {:.3f}% ({:.3f})'.format(testacc.mean(), testacc.std()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
<<<<<<< Updated upstream
       "model_id": "c2835e863e7f4c5bb0697b6690d3a41d",
=======
       "model_id": "398bded8ae494eebb904de71bb9dc551",
>>>>>>> Stashed changes
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='Parameter:', options=('w0', 'w1', 'w2', 'w3', 'w4', 'w5', 'w6', 'w…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_hist(results, param_name)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plot_hist(results, param_name):\n",
    "    posterior_mean = results[param_name].mean()\n",
    "    print('{:.3f} mean value of posterior'.format(posterior_mean))\n",
    "    histogram_trace(results[param_name].values)\n",
    "\n",
    "# use ipywidgets to get a \"gui\" dropdown to view all the parameters\n",
    "interact(\n",
    "    plot_hist, \n",
    "    results=fixed(results), \n",
    "    param_name=widgets.Dropdown(\n",
    "        options=results.columns,\n",
    "        value='w0',\n",
    "        description='Parameter:',\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
<<<<<<< Updated upstream
      "image/png": "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",
=======
      "image/png": "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",
>>>>>>> Stashed changes
      "text/plain": [
       "<Figure size 2000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualise all the network weights\n",
    "boxplot_weights(results,width=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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",
<<<<<<< Updated upstream
   "version": "3.10.13"
=======
   "version": "3.11.7"
>>>>>>> Stashed changes
  },
  "vscode": {
   "interpreter": {
    "hash": "87fbea7b3721842a93ed4da8a1ac4b18f42b1eaaedefc3a2702202c09bf233e1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}