Chapter_5.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter 5",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.7"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rnarkk/PPBMH/blob/main/Chapter_5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZQKEjPNGNzG"
      },
      "source": [
        "# Probabilistic Programming and Bayesian Methods for Hackers Chapter  5\n",
        "\n",
        "<table class = \"tfo-notebook-buttons\" align = \"left\">\n",
        "  <td>\n",
        "    <a target = \"_blank\" href = \"https://colab.research.google.com/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter5_LossFunctions/Ch5_LossFunctions_TFP.ipynb\"><img height = \"32px\" src = \"https://colab.research.google.com/img/colab_favicon.ico\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target = \"_blank\" href = \"https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter5_LossFunctions/Ch5_LossFunctions_TFP.ipynb\"><img src = \"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>\n",
        "<br>\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "Original content ([this Jupyter notebook](https://nbviewer.jupyter.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter5_LossFunctions/Ch5_LossFunctions_PyMC2.ipynb#Example:-Kaggle-contest-on-Observing-Dark-World)) created by Cam Davidson-Pilon ([`@Cmrn_DP`](https://twitter.com/Cmrn_DP)) and Tim Salimans ([`@TimSalimans`](https://twitter.com/TimSalimans))\n",
        "\n",
        "Welcome to Bayesian Methods for Hackers. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ApMhlTOELLf"
      },
      "source": [
        "### Table of Contents\n",
        "\n",
        "- Would you rather lose and arm or a leg?\n",
        "- Loss Functions\n",
        "- Loss functions in the real world\n",
        "- Example: optimising for the Showcase on The Price is Right\n",
        "  - Minimising our losses\n",
        "  - Shortcuts\n",
        "  - Machine Learning via Bayesian Methods\n",
        "- Example: Financial prediction\n",
        "- Example: Kaggle contest on Observing Dark World\n",
        "  - Setup\n",
        "  - Defining our galaxy-plotting function\n",
        "  - Examining Our Data\n",
        "  - Priors\n",
        "  - Training & Tensorflow implemenation\n",
        "    - Constructing a probabilistic model for the data (observed ellipcities o the galaxies) given the positions of the dark matter halos\n",
        "    - Using Bayes' rule to get the posterior distribution of the halo positions, i.e. to use the data to guess wherre the dark matter halos might be\n",
        "  - References"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4g7yzaiTEHY6"
      },
      "source": [
        "## Loss Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_WlZktnIE-aF",
        "outputId": "c034aa9c-f434-4a12-e252-7678f59c6cac"
      },
      "source": [
        "!pip3 install -Uq pip\n",
        "!pip3 uninstall -yq tensorflow tensorflow-probability\n",
        "!pip3 install -Uq jax oryx tfp-nightly[jax]\n",
        "\n",
        "!pip3 install -q praw wget"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
            "\u001b[0m\u001b[33mWARNING: Skipping tensorflow as it is not installed.\u001b[0m\u001b[33m\n",
            "\u001b[0m\u001b[33mWARNING: Skipping tensorflow-probability as it is not installed.\u001b[0m\u001b[33m\n",
            "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
            "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
            "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
            "\u001b[0m"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ZBkOe7soqtz"
      },
      "source": [
        "\"\"\"\n",
        "The book uses a custom matplotlibrc file, which provides the unique styles for\n",
        "matplotlib plots. If executing this book, and you wish to use the book's\n",
        "styling, provided are two options:\n",
        "    1. Overwrite your own matplotlibrc file with the rc-file provided in the\n",
        "       book's styles/ dir. See http://matplotlib.org/users/customizing.html\n",
        "    2. Also in the styles is  bmh_matplotlibrc.json file. This can be used to\n",
        "       update the styles in only this notebook. Try running the following code:\n",
        "\n",
        "        import json\n",
        "        s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n",
        "        matplotlib.rcParams.update(s)\n",
        "\"\"\"\n",
        "from jax import random\n",
        "from jax.numpy import *\n",
        "from jax.numpy import int32 as i32, float32 as f32\n",
        "from jax.lax import atan\n",
        "from jax.scipy.optimize import minimize\n",
        "from oryx import bijectors as tfb\n",
        "from oryx.distributions import (\n",
        "    Binomial, Exponential, Independent, MultivariateNormalDiag, Normal, Poisson, Uniform)\n",
        "from tensorflow_probability.substrates import jax as tfp\n",
        "\n",
        "from IPython.core.pylabtools import figsize\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import wget\n",
        "\n",
        "plt.style.use('fivethirtyeight')\n",
        "\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "sns.set_context('notebook')\n",
        "\n",
        "TFColor = [\n",
        "    '#F15854',\n",
        "    '#5DA5DA',\n",
        "    '#FAA43A',\n",
        "    '#60BD68',\n",
        "    '#F17CB0',\n",
        "    '#B2912F',\n",
        "    '#B276B2',\n",
        "    '#DECF3F',\n",
        "    '#4D4D4D']"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MIClIB5Dz0Mt"
      },
      "source": [
        "### Would you rather lose an arm or a leg?\n",
        "\n",
        "Statisticians can be a sour bunch. Instead of considering their winnings, they only measure how much they have lost. In fact, they consider their wins as *negative losses*. But what's interesting is *how they measure their losses.*\n",
        "\n",
        "For example, consider the following example:\n",
        "\n",
        ">   A meteorologist is predicting the probability of a possible hurricane striking his city. He estimates, with 95% confidence, that the probability of it *not* striking is between 99% - 100%. He is very happy with his precision and advises the city that a major evacuation is unnecessary. Unfortunately, the hurricane does strike and the city is flooded. \n",
        "\n",
        "This stylised example shows the flaw in using a pure accuracy metric to measure outcomes. Using a measure that emphasises estimation accuracy, while an appealing and *objective* thing to do, misses the point of why you are even performing the statistical inference in the first place: results of inference. The author Nassim Taleb of *The Black Swan* and *Antifragility* stresses the importance of the *payoffs* of decisions, *not the accuracy*. Taleb distills this quite succinctly: \"I would rather be vaguely right than very wrong.\"  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bvbT7rFEzwpw"
      },
      "source": [
        "## Loss Functions\n",
        "\n",
        "We introduce what statisticians and decision theorists call *loss functions*. A loss function is a function of the true parameter, and an estimate of that parameter\n",
        "\n",
        "$$ L( \\theta, \\hat{\\theta} ) = f( \\theta, \\hat{\\theta} )$$\n",
        "\n",
        "The important point of loss functions is that it measures how *bad* our current estimate is: the larger the loss, the worse the estimate is according to the loss function. A simple, and very common, example of a loss function is the *squared-error loss*:\n",
        "\n",
        "$$ L( \\theta, \\hat{\\theta} ) = ( \\theta -  \\hat{\\theta} )^2$$\n",
        "\n",
        "The squared-error loss function is used in estimators like linear regression, UMVUEs and many areas of machine learning. We can also consider an asymmetric squared-error loss function, something like:\n",
        "\n",
        "$$ L( \\theta, \\hat{\\theta} ) = \\begin{cases} ( \\theta -  \\hat{\\theta} )^2 & \\hat{\\theta} \\lt \\theta \\\\\\\\ c( \\theta -  \\hat{\\theta} )^2 & \\hat{\\theta} \\ge \\theta, \\;\\; 0\\lt c \\lt 1 \\end{cases}$$\n",
        "\n",
        "\n",
        "which represents that estimating a value larger than the true estimate is preferable to estimating a value below. A situation where this might be useful is in estimating web traffic for the next month, where an over-estimated outlook is preferred so as to avoid an underallocation of server resources. \n",
        "\n",
        "A negative property about the squared-error loss is that it puts a disproportionate emphasis on large outliers. This is because the loss increases quadratically, and not linearly, as the estimate moves away. That is, the penalty of being three units away is much less than being five units away, but the penalty is not much greater than being one unit away, though in both cases the magnitude of difference is the same:\n",
        "\n",
        "$$ \\frac{1^2}{3^2} \\lt \\frac{3^2}{5^2}, \\;\\; \\text{although} \\;\\; 3-1 = 5-3 $$\n",
        "\n",
        "This loss function imposes that large errors are *very* bad. A more *robust* loss function that increases linearly with the difference is the *absolute-loss*\n",
        "\n",
        "$$ L( \\theta, \\hat{\\theta} ) = | \\theta -  \\hat{\\theta} | $$\n",
        "\n",
        "Other popular loss functions include:\n",
        "\n",
        "-  $L( \\theta, \\hat{\\theta} ) = \\mathbb{1}_{ \\hat{\\theta} \\neq \\theta }$ is the zero-one loss often used in machine learning classification algorithms.\n",
        "-  $L( \\theta, \\hat{\\theta} ) = -\\theta\\log( \\hat{\\theta} ) - (1- \\theta)\\log( 1 - \\hat{\\theta} ), \\; \\; \\theta \\in {0,1}, \\; \\hat{\\theta} \\in [0,1]$, called the *log-loss*, also used in machine learning. \n",
        "\n",
        "Historically, loss functions have been motivated from 1) mathematical convenience, and 2) they are robust to application, i.e., they are objective measures of loss. The first reason has really held back the full breadth of loss functions. With computers being agnostic to mathematical convenience, we are free to design our own loss functions, which we take full advantage of later in this Chapter.\n",
        "\n",
        "With respect to the second point, the above loss functions are indeed objective, in that they are most often a function of the difference between estimate and true parameter, independent of signage or payoff of choosing that estimate. This last point, its independence of payoff, causes quite pathological results though. Consider our hurricane example above: the statistician equivalently predicted that the probability of the hurricane striking was between 0% to 1%. But if he had ignored being precise and instead focused on outcomes (99% chance of no flood, 1% chance of flood), he might have advised differently. \n",
        "\n",
        "By shifting our focus from trying to be incredibly precise about parameter estimation to focusing on the outcomes of our parameter estimation, we can customise our estimates to be optimised for our application. This requires us to design new loss functions that reflect our goals and outcomes. Some examples of more interesting loss functions:\n",
        "\n",
        "\n",
        "- $L( \\theta, \\hat{\\theta} ) = \\frac{ | \\theta - \\hat{\\theta} | }{ \\theta(1-\\theta) }, \\; \\; \\hat{\\theta}, \\theta \\in [0,1]$ emphasises an estimate closer to 0 or 1 since if the true value $\\theta$ is near 0 or 1, the loss will be *very* large unless $\\hat{\\theta}$ is similarly close to 0 or 1. \n",
        "This loss function might be used by a political pundit whose job requires him or her to give confident \"Yes/No\" answers. This loss reflects that if the true parameter is close to 1 (for example, if a political outcome is very likely to occur), he or she would want to strongly agree as not to look like a sceptic. \n",
        "\n",
        "-  $L( \\theta, \\hat{\\theta} ) =  1 - \\exp \\left( -(\\theta -  \\hat{\\theta} )^2 \\right)$ is bounded between 0 and 1 and reflects that the user is indifferent to sufficiently-far-away estimates. It is similar to the zero-one loss above, but not quite as penalising to estimates that are close to the true parameter. \n",
        "-  Complicated non-linear loss functions can be programmed: \n",
        "```python\n",
        "        def loss(true_value, estimate):\n",
        "            if estimate * true_value > 0:\n",
        "                return abs(estimate - true_value)\n",
        "            else:\n",
        "               return abs(estimate) * (estimate - true_value)**2\n",
        "```\n",
        "\n",
        "\n",
        "-  Another example is from the book *The Signal and The Noise*. Weather forecasters have an interesting loss function for their predictions.\n",
        "\n",
        "\n",
        ">  People notice one type of mistake &mdash; the failure to predict rain &mdash; more than other, false alarms. If it rains when it isn't supposed to, they curse the weatherman for ruining their picnic, whereas an unexpectedly sunny day is taken as a serendipitous bonus.\n",
        "\n",
        ">  [The Weather Channel's bias] is limited to slightly exaggerating the probability of rain when it is unlikely to occur &mdash; saying there is a 20 percent change when they know it is really a 5 or 10 percent chance &mdash; covering their butts in the case of an unexpected sprinkle.\n",
        "\n",
        "\n",
        "As you can see, loss functions can be used for good and evil: with great power, comes great &mdash; well you know.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "13afsKrzzqup"
      },
      "source": [
        "##  Loss functions in the real world\n",
        "\n",
        "So far we have been under the unrealistic assumption that we know the true parameter. Of course if we knew the true parameter, bothering to guess an estimate is pointless. Hence a loss function is really only practical when the true parameter is unknown. \n",
        "\n",
        "In Bayesian inference, we have a mindset that the unknown parameters are really random variables with prior and posterior distributions. Concerning the posterior distribution, a value drawn from it is a *possible* realisation of what the true parameter could be. Given that realisation, we can compute a loss associated with an estimate. As we have a whole distribution of what the unknown parameter could be (the posterior), we should be more interested in computing the *expected loss* given an estimate. This expected loss is a better estimate of the true loss than comparing the given loss from only a single sample from the posterior.\n",
        "\n",
        "First it will be useful to explain a *Bayesian point estimate*. The systems and machinery present in the modern world are not built to accept posterior distributions as input. It is also rude to hand someone over a distribution when all they asked for was an estimate. In the course of an individual's day, when faced with uncertainty we still act by distilling our uncertainty down to a single action. Similarly, we need to distill our posterior distribution down to a single value (or vector in the multivariate case). If the value is chosen intelligently, we can avoid the flaw of frequentist methodologies that mask the uncertainty and provide a more informative result. The value chosen, if from a Bayesian posterior, is a Bayesian point estimate. \n",
        "\n",
        "Suppose $P(\\theta | X)$ is the posterior distribution of $\\theta$ after observing data $X$, then the following function is understandable as the *expected loss of choosing estimate $\\hat{\\theta}$ to estimate $\\theta$*:\n",
        "\n",
        "$$ l(\\hat{\\theta} ) = E_{\\theta}\\left[L(\\theta, \\hat{\\theta}) \\right] $$\n",
        "\n",
        "This is also known as the *risk* of estimate $\\hat{\\theta}$. The subscript $\\theta$ under the expectation symbol is used to denote that $\\theta$ is the unknown (random) variable in the expectation, something that at first can be difficult to consider.\n",
        "\n",
        "We spent all of last chapter discussing how to approximate expected values. Given $N$ samples $\\theta_i,\\; i = 1,...,N$ from the posterior distribution, and a loss function $L$, we can approximate the expected loss of using estimate $\\hat{\\theta}$ by the Law of Large Numbers:\n",
        "\n",
        "$$\\frac{1}{N} \\sum_{i = 1}^N L(\\theta_i, \\hat{\\theta} ) \\approx E_{\\theta}\\left[L(\\theta, \\hat{\\theta}) \\right]  = l(\\hat{\\theta}) $$\n",
        "\n",
        "Notice that measuring your loss via an *expected value* uses more information from the distribution than the MAP estimate which, if you recall, will only find the maximum value of the distribution and ignore the shape of the distribution. Ignoring information can over-expose yourself to tail risks, like the unlikely hurricane, and leaves your estimate ignorant of how ignorant you really are about the parameter.\n",
        "\n",
        "Similarly, compare this with frequentist methods, that traditionally only aim to minimise the error, and do not consider the *loss associated with the result of that error*. Compound this with the fact that frequentist methods are almost guaranteed to never be absolutely accurate. Bayesian point estimates fix this by planning ahead: your estimate is going to be wrong, you might as well err on the right side of wrong."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfuxjSXhoqty"
      },
      "source": [
        "## Example: Optimising for the *Showcase* on *The Price is Right*\n",
        "\n",
        "Bless you if you are ever chosen as a contestant on the Price is Right, for here we will show you how to optimise your final price on the *Showcase*. For those who forget the rules:\n",
        "\n",
        "\n",
        "1. Two contestants compete in *The Showcase*. \n",
        "2. Each contestant is shown a unique suite of prizes.\n",
        "3. After the viewing, the contestants are asked to bid on the price for their unique suite of prizes.\n",
        "4. If a bid price is over the actual price, the bid's owner is disqualified from winning.\n",
        "5. If a bid price is under the true price by less than $250, the winner is awarded both prizes.\n",
        "\n",
        "The difficulty in the game is balancing your uncertainty in the prices, keeping your bid low enough so as not to bid over, and trying to bid close to the price.\n",
        "\n",
        "Suppose we have recorded the *Showcases* from previous *The Price is Right* episodes and have *prior* beliefs about what distribution the true price follows. For simplicity, suppose it follows a Normal:\n",
        "\n",
        "\n",
        "$$\\text{True Price} \\sim \\text{Normal}(\\mu_p, \\sigma_p )$$\n",
        "\n",
        "\n",
        "In a later chapter, we will actually use *real Price is Right Showcase data* to form the historical prior, but this requires some advanced Tensorflow use so we will not use it here. For now, we will assume $\\mu_p = 35 000$ and $\\sigma_p = 7500$.\n",
        "\n",
        "We need a model of how we should be playing the *Showcase*. For each prize in the prize suite, we have an idea of what it might cost, but this guess could differ significantly from the true price. (Couple this with increased pressure being onstage and you can see why some bids are so wildly off). Let's suppose your beliefs about the prices of prizes also follow Normal distributions:\n",
        "\n",
        "$$ \\text{Prize}_i \\sim \\text{Normal}(\\mu_i, \\sigma_i ),\\;\\; i = 1,2$$\n",
        "\n",
        "This is really why Bayesian analysis is great: we can specify what we think a fair price is through the $\\mu_i$ parameter, and express uncertainty of our guess in the $\\sigma_i$ parameter. \n",
        "\n",
        "We'll assume two prizes per suite for brevity, but this can be extended to any number. \n",
        "The true price of the prize suite is then given by $\\text{Prize}_1 + \\text{Prize}_2 + \\epsilon$, \n",
        "where $\\epsilon$ is some error term.\n",
        "\n",
        "We are interested in the updated $\\text{True Price}$ given we have observed both prizes and have belief distributions about them. We can perform this using Tensorflow Probability. \n",
        "\n",
        "Lets make some values concrete. Suppose there are two prizes in the observed prize suite: \n",
        "\n",
        "1. A trip to wonderful Toronto, Canada! \n",
        "2. A lovely new snowblower!\n",
        "\n",
        "We have some guesses about the true prices of these objects, but we are also pretty uncertain about them. I can express this uncertainty through the parameters of the Normals:\n",
        "\n",
        "\n",
        "\\begin{align*}\n",
        "\\text{snowblower} &\\sim \\text{Normal}(3 000, 500 ) \\\\\n",
        "\\text{Toronto} &\\sim \\text{Normal}(12 000, 3000 ) \\\\\n",
        "\\end{align*}\n",
        "\n",
        "For example, I believe that the true price of the trip to Toronto is 12 000 dollars, and that there is a 68.2% chance the price falls 1 standard deviation away from this, i.e. my confidence is that there is a 68.2% chance the trip is in [9 000, 15 000].\n",
        "\n",
        "We can create some TensorFlow code to perform inference on the true price of the suite. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOSDAQY9oqt5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 659
        },
        "outputId": "6ec840e5-19d4-4a0b-b06f-e112ac4bc6b3"
      },
      "source": [
        "plt.figure(figsize(12.5, 11))\n",
        "\n",
        "plt.subplot(311)\n",
        "x = linspace(0., 60000., 250)\n",
        "\n",
        "historical_prices = Normal(loc = 35000., scale = 7500.).prob(x)\n",
        "snowblower_price_guesses = Normal(loc = 3000., scale = 500.).prob(x)\n",
        "trip_price_guess = Normal(loc = 12000., scale = 3000.).prob(x)\n",
        "\n",
        "sp1 = plt.fill_between(x, 0, historical_prices, color = TFColor[3], lw = 3, \n",
        "                       alpha = .6, label = \"Historical total prices\")\n",
        "    \n",
        "p1 = plt.Rectangle((0, 0), 1, 1, fc = sp1.get_facecolor()[0])\n",
        "plt.legend([p1], [sp1.get_label()])\n",
        "\n",
        "plt.subplot(312)\n",
        "sp2 = plt.fill_between(x, 0, snowblower_price_guesses, color = TFColor[0], \n",
        "                       lw = 3, alpha = .6, label = \"Snowblower price guess\")\n",
        "    \n",
        "p2 = plt.Rectangle((0, 0), 1, 1, fc = sp2.get_facecolor()[0])\n",
        "plt.legend([p2], [sp2.get_label()])\n",
        "\n",
        "plt.subplot(313)\n",
        "sp3 = plt.fill_between(x, 0, trip_price_guess, color = TFColor[6], lw = 3, \n",
        "                       alpha = .6, label = \"Trip price guess\")\n",
        "p3 = plt.Rectangle((0, 0), 1, 1, fc = sp3.get_facecolor()[0])\n",
        "plt.legend([p3], [sp3.get_label()]);"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x792 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 859,
              "height": 642
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w3JI54U8oqt8"
      },
      "source": [
        "data_loc = [3000., 12000.]\n",
        "data_scale = [500., 3000.]\n",
        "\n",
        "loc_prior = 35000.\n",
        "scale_prior = 7500.\n",
        "    \n",
        "def posterior_log_prob(true_price, prize_1, prize_2):\n",
        "    \"\"\"Our posterior log probability, as a function of states\n",
        "    \n",
        "    Args:\n",
        "      true_price_: scalar of true price estimate, taken from state\n",
        "      prize_1: scalar of prize 1 estimate, to be added to the  prize 1 \n",
        "        estimate, taken from state\n",
        "      prize_2: scalar of prize 2 estimate, to be added to the prize 1 \n",
        "        estimate, taken from state\n",
        "    Returns: \n",
        "      Scalar sum of log probabilities\n",
        "    Closure over: data_loc, data_scale, loc_prior, scale_prior\n",
        "    \"\"\"\n",
        "    rv_true_price = Normal(loc = loc_prior, scale = scale_prior)\n",
        "    rv_prize_1 = Normal(loc = data_loc[0], scale = data_scale[0])\n",
        "    rv_prize_2 = Normal(loc = data_loc[1], scale = data_scale[1])\n",
        "    price_estimate = prize_1 + prize_2\n",
        "    rv_error = Normal(loc = price_estimate, scale = 3000.)\n",
        "    \n",
        "    return (\n",
        "          rv_true_price.log_prob(true_price)\n",
        "        + rv_prize_1.log_prob(prize_1)\n",
        "        + rv_prize_2.log_prob(prize_2)\n",
        "        + rv_error.log_prob(true_price))"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aI85hTgn6lU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b8b4693-8ef3-4a8a-f2e0-056b4d7ccbbf"
      },
      "source": [
        "num_results = 50000\n",
        "num_burnin_steps = 10000\n",
        "\n",
        "(true_price, prize_1, prize_2), kernel_results = tfp.mcmc.sample_chain(\n",
        "    num_results = num_results,\n",
        "    num_burnin_steps = num_burnin_steps,\n",
        "    current_state = [\n",
        "        full((1,), 20000.),\n",
        "        full((1,), 3000.),\n",
        "        full((1,), 12000.)],\n",
        "    kernel = tfp.mcmc.RandomWalkMetropolis(\n",
        "        # Specify a new callable that has the appropriate step size\n",
        "        new_state_fn = tfp.mcmc.random_walk_normal_fn(scale = 1000.),\n",
        "        target_log_prob_fn = posterior_log_prob),\n",
        "    parallel_iterations = 1,\n",
        "    seed = random.PRNGKey(0))\n",
        "\n",
        "posterior_price_predictive_samples = true_price[:, 0]\n",
        "\n",
        "# Performing computations\n",
        "# Can take up to 2 minutes in Graph Mode\n",
        "\n",
        "#  For metropolis hastings the acceptance probability should be around 0.234.\n",
        "#  See https://arxiv.org/pdf/1011.6217.pdf \n",
        "# print(\"Acceptance rate:\", mean(kernel_results.inner_results.inner_results.is_accepted))\n",
        "# print(\"Final step size:\", kernel_results.new_step_size[-100:].mean())\n",
        "\n",
        "print(\"posterior_price_predictive_sample trace:\\n   \", posterior_price_predictive_samples)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/tensorflow_probability/substrates/jax/mcmc/sample.py:339: UserWarning: Tracing all kernel results by default is deprecated. Set the `trace_fn` argument to None (the future default value) or an explicit callback that traces the values you are interested in.\n",
            "  warnings.warn('Tracing all kernel results by default is deprecated. Set '\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "posterior_price_predictive_sample trace:\n",
            "    [21141.94  22031.936 22031.936 ... 23656.396 23167.975 23167.975]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j_jDroqFETWA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "c51c3227-d8d7-430f-c6f3-16a4d3ec15d6"
      },
      "source": [
        "plt.figure(figsize(12.5, 4))\n",
        "prices = linspace(5000., 40000., 35000)\n",
        "prior = Normal(loc = 35000., scale = 7500.).prob(prices)\n",
        "\n",
        "plt.plot(prices, prior, c = 'k', lw = 2,\n",
        "         label = \"Prior dist. of suite price\")\n",
        "\n",
        "hist = plt.hist(posterior_price_predictive_samples, bins = 35, histtype = 'stepfilled')\n",
        "plt.title(\"Posterior of the true price estimate\")\n",
        "plt.vlines(loc_prior, 0, 1.1 * max(hist[0]), label = \"Prior's mean\",\n",
        "           linestyles = '--')\n",
        "plt.vlines(mean(posterior_price_predictive_samples), 0, 1.1 * max(hist[0]),\n",
        "           label = \"Posterior's mean\", linestyles = '-.')\n",
        "plt.legend(loc = 'upper left');"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 835,
              "height": 266
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZDvbxrMoquG"
      },
      "source": [
        "Notice that because of our two observed prizes and subsequent guesses (including uncertainty about those guesses), we shifted our mean price estimate down about $15 000 dollars from the previous mean price.\n",
        "\n",
        "A frequentist, seeing the two prizes and having the same beliefs about their prices, would bid $\\mu_1 + \\mu_2 = 35000$, regardless of any uncertainty. Meanwhile, the *naive Bayesian* would simply pick the mean of the posterior distribution. But we have more information about our eventual outcomes; we should incorporate this into our bid. We will use the loss function above to find the *best* bid (*best* according to our loss).\n",
        "\n",
        "What might a contestant's loss function look like? I would think it would look something like:\n",
        "\n",
        "```python\n",
        "def showcase_loss(guess, true_price, risk = 80000):\n",
        "    if true_price < guess:\n",
        "        return risk\n",
        "    elif abs(true_price - guess) <= 250:\n",
        "        return -2 * abs(true_price)\n",
        "    else:\n",
        "        return abs(true_price - guess - 250)\n",
        "```\n",
        "\n",
        "where `risk` is a parameter that defines of how bad it is if your guess is over the true price. A lower `risk` means that you are more comfortable with the idea of going over. If we do bid under and the difference is less than $250, we receive both prizes (modeled here as receiving twice the original prize). Otherwise, when we bid under the `true_price` we want to be as close as possible, hence the `else` loss is a increasing function of the distance between the guess and true price."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tIRbeW9aFLL8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "outputId": "2ea8c059-89e9-4da7-f8b8-125681d1d97c"
      },
      "source": [
        "def showdown_loss(guess, size, true_price, risk = 80000):\n",
        "    \"\"\"Stock Loss function.\n",
        "\n",
        "    Args:\n",
        "        guess: float32 Tensor, representing a range of guesses for the price, or one guess\n",
        "        size: int size of guess\n",
        "        true_price: float32 Tensor of size 50000 x num_guesses, representing the \n",
        "            prices from the HMC sampling, broadcast to each of the num_guesses guesses           \n",
        "        risk: a scalar value representing a penalizer for a score going over\n",
        "            (lower risk indicates more comfort with the price going over)\n",
        "\n",
        "    Returns:\n",
        "        loss: tensor of shape (true_price.shape,guess.shape), returning the loss function per definition in accompanying text\n",
        "    \"\"\"\n",
        "    true_price = transpose(broadcast_to(true_price, (size, true_price.shape[0])))\n",
        "    risk = broadcast_to(array(risk, dtype = f32), true_price.shape)\n",
        "    return where(true_price < guess,\n",
        "                    risk,\n",
        "                    where(abs(true_price - guess) <= 1,\n",
        "                             -2 * abs(true_price),\n",
        "                             abs(true_price - guess - 250)))\n",
        "       \n",
        "num_guesses = 70\n",
        "num_risks = 6\n",
        "guesses = linspace(5000., 50000., num_guesses) \n",
        "risks = linspace(30000, 150000, num_risks)\n",
        "results_cache = zeros((num_risks, num_guesses))\n",
        "\n",
        "def expected_loss(guess, size, risk):\n",
        "    return mean(\n",
        "        showdown_loss(guess, size, posterior_price_predictive_samples, risk),\n",
        "        axis = 0)\n",
        "\n",
        "risk_num = 0\n",
        "for risk in risks:\n",
        "    results = expected_loss(guesses, num_guesses, risk)\n",
        "    plt.plot(guesses, results, label = str(risk))\n",
        "    results_cache.at[risk_num, :].set(results)\n",
        "    risk_num += 1\n",
        "plt.title(\"Expected loss of different guesses, \\nvarious risk-levels of overestimating\")\n",
        "plt.legend(loc = 'upper left', title = \"Risk parameter\")\n",
        "plt.xlabel(\"Price bid\")\n",
        "plt.ylabel(\"Expected loss\")\n",
        "plt.xlim(7000, 30000)\n",
        "plt.ylim(-1000, 80000);"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 875,
              "height": 296
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zWmZhrFoquH"
      },
      "source": [
        "For every possible bid, we calculate the *expected loss* associated with that bid. We vary the `risk` parameter to see how it affects our loss:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yNi7TZ2PoquL"
      },
      "source": [
        "### Minimising our losses\n",
        "\n",
        "It would be wise to choose the estimate that minimises our expected loss. This corresponds to the minimum point on each of the curves above. More formally, we would like to minimise our expected loss by finding the solution to\n",
        "\n",
        "$$ \\text{arg} \\min_{\\hat{\\theta}} E_{\\theta}\\left[ L(\\theta, \\hat{\\theta}) \\right] $$\n",
        "\n",
        "The minimum of the expected loss is called the *Bayes action*. \n",
        "\n",
        "We'll compute the minimum loss for the *Showcase* example above:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7MwzwYAltIhY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 495
        },
        "outputId": "ac151082-7eba-4c02-f165-0ba6d3a19a0b"
      },
      "source": [
        "ax = plt.subplot(111)\n",
        "\n",
        "risk_num = 0\n",
        "\n",
        "for _p in risks:  \n",
        "    color = next(ax._get_lines.prop_cycler)\n",
        "    results = results_cache[risk_num, :]\n",
        "    value = tf.Variable(15000., trainable = True)\n",
        "\n",
        "    loss = -expected_loss(value, 1, tf.constant(_p, dtype = f32))\n",
        "    optimizer = tf.optimizers.Adam(10)\n",
        "    opt_min = optimizer.minimize(loss, var_list = [value])\n",
        "    min_losses = []\n",
        "    min_values = []\n",
        "    for i in range(500):\n",
        "        min_losses.append(loss)\n",
        "        min_values.append(value)\n",
        "    min_losses = asarray(min_losses)\n",
        "    min_values = asarray(min_values)\n",
        "    min_results = min_values[argmax(min_losses)]\n",
        "    plt.plot(guesses, results , color= color['color'])\n",
        "    plt.scatter(min_results, 0, s = 60,\n",
        "                color = color['color'], label = str(_p))\n",
        "    plt.vlines((min_results), 0, 120000, color= color['color'], linestyles = '--')\n",
        "    print(f\"minimum at risk {_p}: {min_results:.2f}\")\n",
        "    risk_num += 1\n",
        "                                    \n",
        "plt.title(\"Expected loss & Bayes actions of different guesses, \\n \\\n",
        "various risk-levels of overestimating\")\n",
        "plt.legend(loc = \"upper left\", scatterpoints = 1, title = \"Bayes action at risk:\")\n",
        "plt.xlabel(\"Price guess\")\n",
        "plt.ylabel(\"Expected loss\")\n",
        "plt.xlim(7000, 30000)\n",
        "plt.ylim(-1000, 80000);\n"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-31-c617b969670c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprop_cycler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresults_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrisk_num\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mVariable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m15000.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mexpected_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_p\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf32\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'tf' is not defined"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 833,
              "height": 255
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_J0GQqAoquO"
      },
      "source": [
        "As intuition suggests, as we decrease the risk threshold (care about overbidding less), we increase our bid, willing to edge closer to the true price. It is interesting how far away our optimised loss is from the posterior mean, which was about 20 000. \n",
        "\n",
        "Suffice to say, in higher dimensions being able to eyeball the minimum expected loss is impossible. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9LykAt1JoquO"
      },
      "source": [
        "### Shortcuts\n",
        "\n",
        "For some loss functions, the Bayes action is known in closed form. We list some of them below:\n",
        "\n",
        "-  If using the mean-squared loss, the Bayes action is the mean of the posterior distribution, i.e. the value \n",
        "$$ E_{\\theta}\\left[ \\theta \\right] $$\n",
        "\n",
        ">  minimises $E_{\\theta}\\left[ (\\theta - \\hat{\\theta})^2 \\right]$. Computationally this requires us to calculate the average of the posterior samples [See chapter 4 on The Law of Large Numbers]\n",
        "\n",
        "-  Whereas the *median* of the posterior distribution minimises the expected absolute-loss. The sample median of the posterior samples is an appropriate and very accurate approximation to the true median.\n",
        "\n",
        "-  In fact, it is possible to show that the MAP estimate is the solution to using a loss function that shrinks to the zero-one loss.\n",
        "\n",
        "\n",
        "Maybe it is clear now why the first-introduced loss functions are used most often in the mathematics of Bayesian inference: no complicated optimisations are necessary. Luckily, we have machines to do the complications for us. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8noiGrAoquO"
      },
      "source": [
        "## Machine Learning via Bayesian Methods\n",
        "\n",
        "Whereas frequentist methods strive to achieve the best precision about all possible parameters, machine learning cares to achieve the best *prediction* among all possible parameters. Of course, one way to achieve accurate predictions is to aim for accurate predictions, but often your prediction measure and what frequentist methods are optimising for are very different. \n",
        "\n",
        "For example, least-squares linear regression is the most simple active machine learning algorithm. I say active as it engages in some learning, whereas predicting the sample mean is technically *simpler*, but is learning very little if anything. The loss that determines the coefficients of the regressors is a squared-error loss. On the other hand, if your prediction loss function (or score function, which is the negative loss) is not a squared-error, like AUC, ROC, precision, etc., your least-squares line will not be optimal for the prediction loss function. This can lead to prediction results that are suboptimal. \n",
        "\n",
        "Finding Bayes actions is equivalent to finding parameters that optimise *not parameter accuracy* but an arbitrary performance measure, however we wish to define performance (loss functions, AUC, ROC, precision/recall etc.).\n",
        "\n",
        "The next two examples demonstrate these ideas. The first example is a linear model where we can choose to predict using the least-squares loss or a novel, outcome-sensitive loss. \n",
        "\n",
        "The second example is adapted from a Kaggle data science project. The loss function associated with our predictions is incredibly complicated. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mhqQdIx3ofeh"
      },
      "source": [
        "# Example: Financial prediction\n",
        "\n",
        "\n",
        "Suppose the future return of a stock price is very small, say 0.01 (or 1%). We have a model that predicts the stock's future price, and our profit and loss is directly tied to us acting on the prediction.  How should we measure the loss associated with the model's predictions, and subsequent future predictions? A squared-error loss is agnostic to the signage and would penalise a prediction of -0.01 equally as bad a prediction of 0.03:\n",
        "\n",
        "$$ (0.01 - (-0.01))^2 = (0.01 - 0.03)^2 = 0.004$$\n",
        "\n",
        "If you had made a bet based on your model's prediction, you would have earned money with a prediction of 0.03, and lost money with a prediction of -0.01, yet our loss did not capture this. We need a better loss that takes into account the *sign* of the prediction and true value. We design a new loss that is better for financial applications below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_fMRPjosoquR"
      },
      "source": [
        "plt.figure(figsize(12.5, 6.5))\n",
        "\n",
        "def stock_loss(true_return, yhat, alpha = 100.):\n",
        "    \"\"\"Stock Loss function\n",
        "    \n",
        "    Args:\n",
        "      true_return: float32 Tensor representing the true stock return\n",
        "      yhat: float32\n",
        "      alpha: float32\n",
        "      \n",
        "    Returns:\n",
        "      float: absolute value of the difference\n",
        "      between `true_return` and `yhat`\n",
        "    \"\"\"\n",
        "    if true_return * yhat < 0:\n",
        "        # opposite signs, not good\n",
        "        return alpha * yhat ** 2 - sign(true_return) * yhat \\\n",
        "            + abs(true_return)\n",
        "    else:\n",
        "        return abs(true_return - yhat)\n",
        "\n",
        "\n",
        "true_value_0 = .05\n",
        "true_value_1 = -.02\n",
        "pred = linspace(-.04, .12, 75)\n",
        "\n",
        "plt.plot(pred, [stock_loss(true_value_0, p) for p in pred],\n",
        "         label = \"Loss associated with\\n prediction if true value = 0.05\", lw = 3)\n",
        "plt.vlines(0, 0, .25, linestyles = '--')\n",
        "plt.xlabel('Prediction')\n",
        "plt.ylabel('Loss')\n",
        "plt.xlim(-.04, .12)\n",
        "plt.ylim(0, .25)\n",
        "\n",
        "true_value = -.02\n",
        "plt.plot(pred, [stock_loss(true_value_1, p) for p in pred], alpha = .6,\n",
        "         label = \"Loss associated with\\n prediction if true value = -0.02\", lw = 3)\n",
        "plt.legend()\n",
        "plt.title(\"Stock returns loss if true value = 0.05, -0.02\");"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HOeAHc5ToquT"
      },
      "source": [
        "Note the change in the shape of the loss as the prediction crosses zero. This loss reflects that the user really does not want to guess the wrong sign, especially be wrong *and* a large magnitude. \n",
        "\n",
        "Why would the user care about the magnitude? Why is the loss not 0 for predicting the correct sign? Surely, if the return is 0.01 and we bet millions we will still be (very) happy.\n",
        "\n",
        "Financial institutions treat downside risk, as in predicting a lot on the wrong side, and upside risk, as in predicting a lot on the right side, similarly. Both are seen as risky behaviour and discouraged. Hence why we have an increasing loss as we move further away from the true price. (With less extreme loss in the direction of the correct sign.)\n",
        "\n",
        "We will perform a regression on a trading signal that we believe predicts future returns well. Our dataset is artificial, as most financial data is not even close to linear. Below, we plot the data along with the least-squares line."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PaDyigdCy85d"
      },
      "source": [
        "# Code for creating artificial 'dummy' data\n",
        "# This is a common strategy for testing our models\n",
        "# before applying it to real-world data\n",
        "\n",
        "num_data = 100\n",
        "X_data = .025 * Normal(loc = 0., scale = 1.).sample(sample_shape = (num_data,))\n",
        "Y_data = .5 * X_data + .01 * Normal(loc = 0., scale = 1.).sample(sample_shape = (num_data,))\n",
        "\n",
        "tf_var_data = var(X_data, axes = 0)\n",
        "covar = tfp.stats.covariance(X_data, Y_data, sample_axis = 0, event_axis = None)\n",
        "ls_coef = covar / tf_var_data\n",
        "\n",
        "ls_intercept = mean(Y_data) - ls_coef * mean(X_data)\n",
        "\n",
        "plt.figure(figsize(12.5, 7))\n",
        "plt.scatter(X_data, Y_data, c = 'k')\n",
        "plt.xlabel('Trading signal')\n",
        "plt.ylabel('Returns')\n",
        "plt.title(\"Empirical returns vs trading signal\")\n",
        "plt.plot(X_data, ls_coef * X_data + ls_intercept, label = \"Least-squares line\")\n",
        "plt.xlim(min(X_data), max(X_data))\n",
        "plt.ylim(min(Y_data), max(Y_data))\n",
        "plt.legend(loc = 'upper left');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uxusMfftoquW"
      },
      "source": [
        "We perform a simple Bayesian linear regression on this dataset. We look for a model like:\n",
        "\n",
        "$$ R = \\alpha + \\beta x + \\epsilon$$\n",
        "\n",
        "where $\\alpha, \\beta$ are our unknown parameters and $\\epsilon \\sim \\text{Normal}(0, 1/\\tau)$. The most common priors on $\\beta$ and $\\alpha$ are Normal priors. We will also assign a prior on $\\tau$, so that $\\sigma = 1/\\sqrt{\\tau}$ is uniform over 0 to 100 (equivalently then $\\tau = 1/\\text{Uniform}(0, 100)^2$)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QeBL-LhtoquX"
      },
      "source": [
        "obs_stdev = sqrt(\n",
        "    mean(tf.math.squared_difference(Y_data, mean(Y_data, axis = 0)),  # conj (x - y) (x - y)\n",
        "            axis = 0))\n",
        "\n",
        "# Define the log probability of the bayesian regression function\n",
        "def finance_posterior_log_prob(X_data, Y_data, alpha, beta, sigma):\n",
        "    \"\"\"Posterior log probability, as a function of states\n",
        "    \n",
        "    Args:\n",
        "      alpha_: scalar, taken from state of the HMC\n",
        "      beta_: scalar, taken from state of the HMC\n",
        "      sigma_: scalar, the standard deviation of , taken from state of the HMC\n",
        "    Returns: \n",
        "      Scalar sum of log probabilities\n",
        "    Closure over: Y_data, X_data\n",
        "    \"\"\"\n",
        "    rv_alpha = Normal(loc = 0., scale = 100.)\n",
        "    rv_beta = Normal(loc = 0., scale = 100.)\n",
        "    rv_std = Uniform(low = 0., high = 100.)\n",
        "    mean = alpha + beta * X_data\n",
        "    rv_observed = Normal(loc = mean, scale = sigma)\n",
        "    \n",
        "    return (\n",
        "          rv_alpha.log_prob(alpha) \n",
        "        + rv_beta.log_prob(beta) \n",
        "        + rv_std.log_prob(sigma)\n",
        "        + sum(rv_observed.log_prob(Y_data)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YIH8NhDHoquZ"
      },
      "source": [
        "num_results = 5000\n",
        "num_burnin_steps = 1000\n",
        "\n",
        "# Set the chain's start state.\n",
        "initial_chain_state = [\n",
        "    1. * ones(()),  # TODO f32\n",
        "    .01 * ones(()),  # TODO f32\n",
        "    obs_stdev * ones(())]  # TODO f32\n",
        "\n",
        "# Since HMC operates over unconstrained space, we need to transform the\n",
        "# samples so they live in real-space.\n",
        "# Beta and sigma are 100x and 10x of alpha, approximately, so apply Affine scalar bijector\n",
        "# to multiply the unconstrained beta and sigma by 100x and 10x to get back to \n",
        "# the problem space\n",
        "unconstraining_bijectors = [\n",
        "    tfb.Identity(),  # alpha\n",
        "    tfb.AffineScalar(100.),  # beta\n",
        "    tfb.AffineScalar(10.)]  # sigma\n",
        "\n",
        "# Define a closure over the joint_log_prob\n",
        "def unnormalised_posterior_log_prob(*args):\n",
        "    return finance_posterior_log_prob(X_data, Y_data, *args)\n",
        "\n",
        "# Initialise the step_size (it will be automatically adapted.)\n",
        "step_size = tf.Variable(\n",
        "    initial_value = tf.constant(.5, dtype = f32),\n",
        "    trainable = False,\n",
        "    name = 'step_size')\n",
        "\n",
        "# Define the HMC\n",
        "kernel = tfp.mcmc.TransformedTransitionKernel(\n",
        "    inner_kernel = tfp.mcmc.HamiltonianMonteCarlo(\n",
        "        target_log_prob_fn = unnormalised_posterior_log_prob,\n",
        "        num_leapfrog_steps = 2,\n",
        "        step_size = step_size,\n",
        "        state_gradients_are_stopped = True),\n",
        "    bijector = unconstraining_bijectors)\n",
        "\n",
        "kernel = tfp.mcmc.SimpleStepSizeAdaptation(\n",
        "    inner_kernel = kernel,\n",
        "    num_adaptation_steps = int(num_burnin_steps * .8))\n",
        "\n",
        "# Sample from the chain\n",
        "(alpha,  beta,  sigma), kernel_results = tfp.mcmc.sample_chain(\n",
        "    num_results = num_results,\n",
        "    num_burnin_steps = num_burnin_steps,\n",
        "    current_state = initial_chain_state,\n",
        "    kernel = kernel)\n",
        "\n",
        "# performing computations\n",
        "# can take up to about 4 mins in graph mode\n",
        "# print(\"Acceptance rate:\", mean(kernel_results.inner_results.inner_results.is_accepted))\n",
        "# print(\"Final step size:\", kernel_results.new_step_size[-100:].mean())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jFFZDRcLoVBY"
      },
      "source": [
        "# Plotting the Posterior Samples\n",
        "plt.figure(figsize = (15, 3))\n",
        "plt.plot(arange(num_results), sigma, color = TFColor[6])\n",
        "plt.title('HMC sigma (σ) convergence progression', fontsize = 14)\n",
        "\n",
        "plt.figure(figsize = (15, 3))\n",
        "plt.plot(arange(num_results), beta, color = TFColor[0])\n",
        "plt.title('HMC beta (β) convergence progression', fontsize = 14)\n",
        "\n",
        "plt.figure(figsize = (15, 3))\n",
        "plt.plot(arange(num_results), alpha, color = TFColor[3])\n",
        "plt.title('HMC alpha (α) convergence progression', fontsize = 14)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j013lhwnoUxt"
      },
      "source": [
        "# Plotting the Posterior Samples\n",
        "\n",
        "plt.figure(figsize = (15, 12))\n",
        "plt.subplot(3, 2, 1)\n",
        "plt.hist(sigma, \n",
        "         bins = 100, color = TFColor[6], alpha = .8)\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Posterior std (σ) samples', fontsize = 14)\n",
        "plt.subplot(3, 2, 2)\n",
        "plt.plot(arange(num_results), \n",
        "         sigma, color = TFColor[6], alpha = .8)\n",
        "plt.ylabel('Sample Value')\n",
        "plt.title('Posterior std (σ) samples', fontsize = 14)\n",
        "\n",
        "plt.subplot(3, 2, 3)\n",
        "plt.hist(beta, \n",
        "         bins = 100, color = TFColor[0], alpha = .8)\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Posterior beta (β) samples', fontsize = 14)\n",
        "plt.subplot(3, 2, 4)\n",
        "plt.plot(arange(num_results), \n",
        "         beta, color = TFColor[0], alpha = .8)\n",
        "plt.ylabel('Sample Value')\n",
        "plt.title('Posterior beta (β) samples', fontsize = 14)\n",
        "\n",
        "plt.subplot(3, 2, 5)\n",
        "plt.hist(alpha, bins = 100, \n",
        "         color = TFColor[3], alpha = .8)\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Posterior alpha (α) samples', fontsize = 14)\n",
        "plt.subplot(3, 2, 6)\n",
        "plt.plot(arange(num_results), alpha, \n",
        "         color = TFColor[3], alpha = .8)\n",
        "plt.ylabel('Sample Value')\n",
        "plt.title('Posterior alpha (α) samples', fontsize = 14)\n",
        "\n",
        "# KDE Plots\n",
        "plt.figure(figsize = (15,9))\n",
        "plt.subplot(2, 2, 1)\n",
        "ax1 = sns.kdeplot(sigma, \n",
        "                  shade = True, color = TFColor[6], bw = .000075)\n",
        "plt.ylabel('Probability density')\n",
        "plt.title('KDE plot for std (σ)', fontsize = 14)\n",
        "plt.subplot(2, 2, 2)\n",
        "ax2 = sns.kdeplot(beta, \n",
        "                  shade = True, color = TFColor[0], bw = .0030)\n",
        "plt.ylabel('Probability density')\n",
        "plt.title('KDE plot for beta (β) samples', fontsize = 14)\n",
        "plt.subplot(2, 2, 3)\n",
        "ax3 = sns.kdeplot(alpha, \n",
        "                  shade = True, color = TFColor[3], bw = .0001)\n",
        "plt.ylabel('Probability density')\n",
        "plt.title('KDE plot for alpha (α) samples', fontsize = 14)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gVuArwZcoquf"
      },
      "source": [
        "It appears the MCMC has converged so we may continue.\n",
        "\n",
        "For a specific trading signal, call it $x$, the distribution of possible returns has the form:\n",
        "\n",
        "$$ R_i(x) =  \\alpha_i + \\beta_ix + \\epsilon $$\n",
        "\n",
        "where $\\epsilon \\sim \\text{Normal}(0, 1/\\tau_i) $ and $i$ indexes our posterior samples. We wish to find the solution to \n",
        "\n",
        "$$ \\arg \\min_{r} E_{R(x)}\\left[ L(R(x), r) \\right] $$\n",
        "\n",
        "according to the loss given above. This $r$ is our Bayes action for trading signal $x$. Below we plot the Bayes action over different trading signals. What do you notice?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kGKdj6B79Y4-"
      },
      "source": [
        "plt.figure(figsize(12.5, 6))\n",
        "\n",
        "def stock_loss(\n",
        "    price, pred, coef = 500):\n",
        "    \"\"\"Vectorised Stock Loss function\n",
        "    \n",
        "    Args:\n",
        "        price: A (<num_results>,) Tensor of prices (independent variable)\n",
        "        pred: A (1,) Tensor prediction based on the price\n",
        "        coef: Integer Tensor representing coeficient for Bayes action function\n",
        "    Returns:\n",
        "        sol: A (<num_results>,) array Tensor of data points for Bayes action solution minima\n",
        "    \"\"\"\n",
        "    sol = zeros_like(price)\n",
        "    ix = price * pred < 0\n",
        "    sol[ix] = coef * pred ** 2 - sign(price[ix]) * pred + abs(price[ix])\n",
        "    sol[~ix] = abs(price[~ix] - pred)\n",
        "    return sol\n",
        "\n",
        "N = sigma.shape[0]\n",
        "noise = sigma * Normal(loc = 0., scale = 1.).sample(N)\n",
        "\n",
        "possible_outcomes = lambda signal: alpha + beta * signal + noise\n",
        "\n",
        "opt_predictions = zeros(50)\n",
        "trading_signals = linspace(min(X_data), max(X_data), 50)\n",
        "for i, signal in enumerate(trading_signals):\n",
        "    _possible_outcomes = possible_outcomes(signal)\n",
        "    tomin = lambda pred: stock_loss(_possible_outcomes, pred).mean()\n",
        "    opt_predictions[i] = minimize(tomin, 0, disp = False)\n",
        "    \n",
        "plt.xlabel(\"Trading signal\")\n",
        "plt.ylabel(\"Prediction\")\n",
        "plt.title(\"Least-squares prediction vs. Bayes action prediction\")\n",
        "plt.plot(X_data, ls_coef * X_data + ls_intercept, label = \"Least-squares prediction\")\n",
        "plt.xlim(min(X_data), max(X_data))\n",
        "plt.plot(trading_signals, opt_predictions, label = \"Bayes action prediction\")\n",
        "plt.legend(loc = 'upper left');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dDQHUSh8oquh"
      },
      "source": [
        "What is interesting about the above graph is that when the signal is near 0, and many of the possible  returns outcomes are possibly both positive and negative, our best (with respect to our loss) prediction is to predict close to 0, hence *take on no position*. Only when we are very confident do we enter into a position. I call this style of model a *sparse prediction*, where we feel uncomfortable with our uncertainty so choose not to act. (Compare with the least-squares prediction which will rarely, if ever, predict zero). \n",
        "\n",
        "A good sanity check that our model is still reasonable: as the signal becomes more and more extreme, and we feel more and more confident about the positive/negativeness of returns, our position converges with that of the least-squares line. \n",
        "\n",
        "The sparse-prediction model is not trying to *fit* the data the best (according to a *squared-error loss* definition of *fit*). That honor would go to the least-squares model. The sparse-prediction model is trying to find the best prediction *with respect to our `stock_loss`-defined loss*. We can turn this reasoning around: the least-squares model is not trying to *predict* the best (according to a *`stock-loss`* definition of *predict*). That honor would go the *sparse prediction* model. The least-squares model is trying to find the best fit of the data *with respect to the squared-error loss*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yeH42zITtIGW"
      },
      "source": [
        "# Example: Kaggle contest on *Observing Dark World*\n",
        "\n",
        "\n",
        "A personal motivation for learning Bayesian methods was trying to piece together the winning solution to Kaggle's [*Observing Dark Worlds*](http://www.kaggle.com/c/DarkWorlds) contest. From the contest's website:\n",
        "\n",
        "\n",
        "\n",
        ">There is more to the Universe than meets the eye. Out in the cosmos exists a form of matter that outnumbers the stuff we can see by almost 7 to 1, and we don’t know what it is. What we do know is that it does not emit or absorb light, so we call it Dark Matter. Such a vast amount of aggregated matter does not go unnoticed. In fact we observe that this stuff aggregates and forms massive structures called Dark Matter Halos. Although dark, it warps and bends spacetime such that any light from a background galaxy which passes close to the Dark Matter will have its path altered and changed. This bending causes the galaxy to appear as an ellipse in the sky.\n",
        "\n",
        "<img src = \"http://timsalimans.com/wp-content/uploads/2012/12/dm.jpg\">\n",
        "\n",
        "\n",
        "The contest required predictions about where dark matter was likely to be. The winner, [Tim Salimans](http://timsalimans.com/), used Bayesian inference to find the best locations for the halos (interestingly, the second-place winner also used Bayesian inference). With Tim's permission, we provided his solution [1] here:\n",
        "\n",
        "1. Construct a prior distribution for the halo positions $p(x)$, i.e. formulate our expectations about the halo positions before looking at the data.\n",
        "2. Construct a probabilistic model for the data (observed ellipticities of the galaxies) given the positions of the dark matter halos: $p(e | x)$.\n",
        "3. Use Bayes’ rule to get the posterior distribution of the halo positions, i.e. use to the data to guess where the dark matter halos might be.\n",
        "4. Minimise the expected loss with respect to the posterior distribution over the predictions for the halo positions: $\\hat{x} = \\arg \\min_{\\text{prediction} } E_{p(x|e)}[ L( \\text{prediction}, x) ]$ , i.e. tune our predictions to be as good as possible for the given error metric.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "innhxnSNJhZu"
      },
      "source": [
        "The loss function in this problem is very complicated. For the very determined, the loss function is contained in the file DarkWorldsMetric.py in the parent folder. Though I suggest not reading it all, suffice to say the loss function is about 160 lines of code &mdash; not something that can be written down in a single mathematical line. The loss function attempts to measure the accuracy of prediction, in a Euclidean distance sense, such that no shift-bias is present. More details can be found on the metric's [main page](http://www.kaggle.com/c/DarkWorlds/details/evaluation). \n",
        "\n",
        "We will attempt to implement Tim's winning solution using [Tensorflow Probability](https://medium.com/tensorflow/introducing-tensorflow-probability-dca4c304e245) and our knowledge of loss functions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hUVLtGVpIS6s"
      },
      "source": [
        "# Downloading the zip file containing the Galaxy Data\n",
        "url1 = 'https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter5_LossFunctions/data.zip?raw = true'\n",
        "filename1 = wget.download(url1)\n",
        "filename1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ORWxu0qjBHiS"
      },
      "source": [
        "!unzip -q data.zip -d data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JnYd2IbTKLNg"
      },
      "source": [
        "We also want to import the data files and Loss functions specific to this Kaggle Competition. You can download the files directly from the [Observing Dark Worlds competition's Data page](https://www.kaggle.com/c/DarkWorlds/data) or, if you already have a Kaggle account, install the [Kaggle API](https://github.com/Kaggle/kaggle-api) and run the following terminal command:\n",
        "\n",
        "```\n",
        "kaggle competitions download -c DarkWorlds\n",
        "```\n",
        "\n",
        "And once the competition information is available locally, we can simply unzip the data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l36JzQ3wKWzK"
      },
      "source": [
        "\n",
        "One last thing to set up is the function we use for plotting galaxies from the files, which we define here:\n",
        "\n",
        "#### Defining our galaxy-plotting function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C1KzXzbjKbmd"
      },
      "source": [
        "def draw_sky(galaxies):\n",
        "    \"\"\"From a given file of galaxy data, \n",
        "    plots the shapes and positions of galaxies.\n",
        "    \n",
        "    Args:\n",
        "      galaxies: 4-column, float32 Numpy array containing x-coordinates, y-coordinates,\n",
        "        and the two axes of ellipcity.\n",
        "    Returns:\n",
        "      fig: image of galaxy plot\n",
        "    \"\"\"\n",
        "    size_multiplier = 45\n",
        "    fig = plt.figure(figsize = (10, 10))\n",
        "    ax = fig.add_subplot(111, aspect = 'equal')\n",
        "    n = galaxies.shape[0]\n",
        "    for i in range(n):\n",
        "        g = galaxies[i, :]\n",
        "        x, y = g[0], g[1]\n",
        "        d = sqrt(g[2] ** 2 + g[3] ** 2)\n",
        "        a = 1.0 / (1 - d)\n",
        "        b = 1.0 / (1 + d)\n",
        "        theta = degrees(arctan2(g[3], g[2]) * 0.5)\n",
        "        \n",
        "        ax.add_patch(Ellipse(xy = (x, y), width = size_multiplier * a, height = size_multiplier * b, angle = theta))\n",
        "    ax.autoscale_view(tight = True)\n",
        "    \n",
        "    return fig"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ds4g4NTmKsFU"
      },
      "source": [
        "### Examining Our Data\n",
        "\n",
        "The dataset is actually 300 separate files, each representing a sky. In each file, or sky, are between 300 and 720 galaxies. Each galaxy has an $x$ and $y$ position associated with it, ranging from 0 to 4200, and measures of ellipticity: $e_1$ and $e_2$. Information about what these measures mean can be found [here](https://www.kaggle.com/c/DarkWorlds/details/an-introduction-to-ellipticity), but for our purposes it does not matter besides for visualization purposes. Thus a typical sky might look like the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6ltTec8K6ve"
      },
      "source": [
        "num_sky = 3  # choose a file/sky to examine\n",
        "data = genfromtxt(f'data/Train_Skies/Train_Skies/Training_Sky{num_sky}.csv',\n",
        "                      dtype = f32,\n",
        "                      skip_header = 1,\n",
        "                      delimiter = ',',\n",
        "                      usecols = [1, 2, 3, 4])\n",
        "              # It's handy to specify the data type beforehand\n",
        "\n",
        "galaxy_positions = array(data[:, :2], dtype = f32)\n",
        "gal_ellipticities = array(data[:, 2:], dtype = f32)\n",
        "ellipticity_mean = mean(data[:, 2:], axis = 0)\n",
        "ellipticity_stddev = std(data[:, 2:], axis = 0)\n",
        "num_galaxies = array(galaxy_positions).shape[0]\n",
        "\n",
        "print(f\"Data on galaxies in sky {num_sky}.\")\n",
        "print(\"position_x, position_y, e_1, e_2 \")\n",
        "print(data[:3])\n",
        "print(\"Number of Galaxies: \", num_galaxies)\n",
        "print(\"e_1 & e_2 mean: \", ellipticity_mean)\n",
        "print(\"e_1 & e_2 std_dev: \", ellipticity_stddev)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "021sa-vWK7XK"
      },
      "source": [
        "Nice, as we can see above we have the data organized into columns according to their x and y coordinates, and the degrees of elipticity along each axis of the galaxies. If we want to reference the positions directly, we can use the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4UKLxWPnuUz8"
      },
      "source": [
        "fig = draw_sky(data)\n",
        "plt.title(f\"Galaxy positions and ellipcities of sky {num_sky}.\")\n",
        "plt.xlabel(\"x-position\")\n",
        "plt.ylabel(\"y-position\");"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hIExuMFLI0O"
      },
      "source": [
        "\n",
        "...beautiful!\n",
        "\n",
        "\n",
        "### Priors\n",
        "\n",
        "Each sky has one, two or three dark matter halos in it. Tim's solution details that his prior distribution of halo positions was uniform, i.e.\n",
        "$$\n",
        "\\begin{align}\n",
        "& x_i \\sim \\text{Uniform}( 0, 4200)\\\\\n",
        "& y_i \\sim \\text{Uniform}( 0, 4200), \\;\\; i = 1,2,3\\\\\n",
        "\\end{align}\n",
        "$$\n",
        "Tim and other competitors noted that most skies had one large halo and other halos, if present, were much smaller. Larger halos, having more mass, will influence the surrounding galaxies more. He decided that the large halos would have a mass distributed as a *log*-uniform random variable between 40 and 180 i.e.\n",
        "\n",
        "$$  m_{\\text{large} } = \\log \\text{Uniform}( 40, 180 ) $$\n",
        "\n",
        "and in Tensorflow Probability, \n",
        "\n",
        "```python\n",
        "# Log-Uniform Distribution\n",
        "mass_large = TransformedDistribution(\n",
        "    distribution = Uniform(low = 40.0, high = 180.0),\n",
        "    bijector = tfb.Exp())\n",
        "```\n",
        "\n",
        "(This is what we mean when we say *log*-uniform.) For smaller galaxies, Tim set the mass to be the logarithm of 20. Why did Tim not create a prior for the smaller mass, nor treat it as a unknown? I believe this decision was made to speed up convergence of the algorithm. This is not too restrictive, as by construction the smaller halos have less influence on the galaxies.\n",
        "\n",
        "Tim logically assumed that the ellipticity of each galaxy is dependent on the position of the halos, the distance between the galaxy and halo, and the mass of the halos. Thus the vector of ellipticity of each galaxy, $\\mathbf{e}_i$, are *children* variables of the vector of halo positions $(\\mathbf{x},\\mathbf{y})$, distance (which we will formalize), and halo masses.\n",
        "\n",
        "Tim conceived a relationship to connect positions and ellipticity by reading literature and forum posts. He supposed the following was a reasonable relationship:\n",
        "\n",
        "$$ e_i | ( \\mathbf{x}, \\mathbf{y} ) \\sim \\text{Normal}( \\sum_{j = \\text{halo positions} }d_{i,j} m_j f( r_{i,j} ), \\sigma^2 ) $$\n",
        "\n",
        "where $d_{i,j}$ is the *tangential direction* (the direction in which halo $j$ bends the light of galaxy $i$), $m_j$ is the mass of halo $j$, $f(r_{i,j})$ is a *decreasing function* of the Euclidean distance between halo $j$ and galaxy $i$. \n",
        "\n",
        "The variance, or $\\sigma^2$, was simply estimated to be 0.05 from eyeballing the data. This means the Standard deviation (SD) of the measurement of $e_i$ for the full range of $i$ works out to approximately 0.223607......\n",
        "\n",
        "Tim's function $f$ was defined:\n",
        "\n",
        "$$ f( r_{i,j} ) = \\frac{1}{\\min( r_{i,j}, 240 ) } $$\n",
        "\n",
        "for large halos, and for small halos\n",
        "\n",
        "$$ f( r_{i,j} ) = \\frac{1}{\\min( r_{i,j}, 70 ) } $$\n",
        "\n",
        "This fully bridges our observations and unknown. This model is incredibly simple, and Tim mentions this simplicity was purposefully designed: it prevents the model from overfitting.  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OVhlxdf1xr-4"
      },
      "source": [
        "### Training & Tensorflow implementation\n",
        "\n",
        "For each sky, we run our Bayesian model to find the posteriors for the halo positions &mdash; we ignore the (known) halo position. This is slightly different than perhaps traditional approaches to Kaggle competitions, where this model uses no data from other skies nor the known halo location. That does not mean other data are not necessary &mdash; in fact, the model was created by comparing different skies. \n",
        "\n",
        "***Constructing a prior distribution for the halo positions $p(x)$, i.e. formulate our expectations about the halo positions before looking at the data.***\n",
        "\n",
        "When constructing our prior and likelihood distributions, we're going to use these to set up a loss function that is very similar to that of a [Variational Auto Encoder](https://github.com/tensorflow/probability/blob/master/tensorflow_probability/examples/vae.py) (although a much lower-dimensional one)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nCCZEsmRyak7"
      },
      "source": [
        "def euclidean_distance(x, y):\n",
        "    \"\"\"Calculates the euclidian distance between point x and poin y.\n",
        "    \n",
        "    Args:\n",
        "      x: a Tensorflow tensor for element-wise\n",
        "      calculation\n",
        "      y: a Tensorflow tensor for element-wise\n",
        "      calculation\n",
        "    Returns: \n",
        "      a Tensor containing the euclidian \n",
        "      distance between x and y\n",
        "    \"\"\"\n",
        "    return sqrt(sum(tf.squared_difference(x, y), axis = 1))\n",
        "\n",
        "\n",
        "def f_distance(gxy_pos, halo_pos, c):\n",
        "    \"\"\"Provides our element-wise maximum as in NumPy, \n",
        "    but instead for TensorFlow tensors\n",
        "    \n",
        "    Args:\n",
        "      gxy_pos: a 2-d numpy array of observed galaxy\n",
        "        positions\n",
        "      halo_pos: a 2-d numpy array with halo positions\n",
        "      c: a scalar of shape order 0\n",
        "    Returns: \n",
        "      Maximum of either the uclidian distance of gxy_pos\n",
        "      & halo_pos, or the constant c.\n",
        "    \"\"\"\n",
        "    return maximum(euclidean_distance(gxy_pos, halo_pos), c)[:, None]\n",
        "\n",
        "\n",
        "def tangential_distance(glxy_position, halo_position):\n",
        "    \"\"\"Calculates the tangential distance between coordinates glxy_position & halo_position.\n",
        "    \n",
        "    Args:\n",
        "      glxy_position: a 2-d numpy array of observed galaxy\n",
        "        positions\n",
        "      halo_position: a 2-d numpy array with halo positions\n",
        "    Returns: \n",
        "      vectors with direction of dominant halo.\n",
        "    \"\"\"\n",
        "    \n",
        "    x_delta, y_delta = tf.unstack(\n",
        "        glxy_position - halo_position, num = 2, axis = -1)\n",
        "    angle = 2. * atan(y_delta / x_delta)\n",
        "    return stack([-cos(angle), -sin(angle)], axis = -1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OPJ9YE9-LVrN"
      },
      "source": [
        "def posterior_log_prob(mass_large, halo_pos):\n",
        "    \"\"\"Posterior log probability, as a function of states\n",
        "    Closure over: data\n",
        "    \n",
        "    Args:\n",
        "      mass_large: scalar of halo mass, taken from state\n",
        "      halo_pos: tensor of halo position(s), taken from state\n",
        "    Returns: \n",
        "      Scalar sum of log probabilities\n",
        "    \"\"\"\n",
        "    rv_mass_large = Uniform(low = 40., high = 180.)    \n",
        "    \n",
        "    # Set the random size of the halo's mass (the big halo for now)\n",
        "    # We use Independent to change the batch and event shapes\n",
        "    rv_halo_pos = Independent(\n",
        "        Uniform(low = (0., 0.), high = (4200., 4200.)),\n",
        "        reinterpreted_batch_ndims = 1)\n",
        "    ellpty_mvn_loc = (mass_large\n",
        "                      / f_distance(data[:, :2], halo_pos, 240.)\n",
        "                      * tangential_distance(data[:, :2], halo_pos))\n",
        "    ellpty = MultivariateNormalDiag(\n",
        "        loc = ellpty_mvn_loc, \n",
        "        scale_diag = (0.223607, 0.223607))\n",
        "    \n",
        "    return (sum(ellpty.log_prob(data[:, 2:]), axis = 0) + \n",
        "            rv_halo_pos.log_prob(halo_pos) + \n",
        "            rv_mass_large.log_prob(mass_large))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "svjLrY2sLdQW"
      },
      "source": [
        "Let's go onto the next part:\n",
        "\n",
        "***Constructing a probabilistic model for the data (observed ellipticities of the galaxies) given the positions of the dark matter halos: $p(e | x)$***\n",
        "\n",
        "Given data, we use a Metropolis Random Walk (MRW) Markov chain Monte Carlo method to calculate the precise posterior distribution over the model's parameters. It is possible to use Hamiltoniam Monte Carlo (HMC) for problems like this, but Metropolis is more appropriate for this case due to its comparative simplicity.\n",
        "\n",
        "Tim's model gives us an approximate posterior to start with. That is, we asume the posterior must be proportional to the normal distribution of distances inferred from galaxy ellipcities.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yKp1CAxlxr-_"
      },
      "source": [
        "# Infer the posterior distribution\n",
        "\n",
        "num_results = 10000\n",
        "num_burnin_steps = 5000\n",
        "\n",
        "# Set the chain's start state\n",
        "initial_chain_state = [\n",
        "    fill((1,), 80.),\n",
        "    fill((1, 2), 2100.)]\n",
        "\n",
        "# Since HMC operates over unconstrained space, we need to transform the\n",
        "# samples so they live in real-space.\n",
        "unconstraining_bijectors = [\n",
        "    tfb.Identity(),\n",
        "    tfb.Identity()]\n",
        "\n",
        "# Define a closure over our joint_log_prob\n",
        "unnormalised_posterior_log_prob = lambda *args: posterior_log_prob(*args)\n",
        "\n",
        "# Initialise the step_size (it will be automatically adapted.)\n",
        "step_size = tf.Variable(\n",
        "    initial_value = tf.constant(.06, dtype = f32),\n",
        "    trainable = False,\n",
        "    name = 'step_size')\n",
        "\n",
        "kernel = tfp.mcmc.HamiltonianMonteCarlo(\n",
        "        target_log_prob_fn = unnormalised_posterior_log_prob,\n",
        "        num_leapfrog_steps = 6,\n",
        "        step_size = step_size)\n",
        "\n",
        "kernel = tfp.mcmc.TransformedTransitionKernel(\n",
        "    inner_kernel = kernel,\n",
        "    bijector = unconstraining_bijectors)\n",
        "\n",
        "kernel = tfp.mcmc.SimpleStepSizeAdaptation(\n",
        "    inner_kernel = kernel,\n",
        "    num_adaptation_steps = int(num_burnin_steps * .8))\n",
        "\n",
        "# Sampling from the chain\n",
        "(mass_large, posterior_predictive_samples), kernel_results = tfp.mcmc.sample_chain(\n",
        "    num_results = num_results,\n",
        "    num_burnin_steps = num_burnin_steps,\n",
        "    current_state = initial_chain_state,\n",
        "    kernel = kernel)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xpl5Lw0tZmWx"
      },
      "source": [
        "We new have the setup for our probabilistic model. We can now go onto the third step:\n",
        "\n",
        "\n",
        "#### Using Bayes’ rule to get the posterior distribution of the halo positions, i.e. use to the data to guess where the dark matter halos might be.\n",
        "\n",
        "We're going to take the results of the outputs of the Markov chain, take the mean and standard deviation, and then use those to create a lower-dimensional multivariate normal distribution of halo distributions. This will be our posterior predictive distribution.\n",
        "\n",
        "First, we can create the convenience functions to set up our session"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fI4tDYE5xr_K"
      },
      "source": [
        "# print(\"Acceptance rate:\", mean(kernel_results.inner_results.inner_results.is_accepted))\n",
        "# print(\"Final step size:\", kernel_results.new_step_size[-100:].mean())\n",
        "print(\"posterior_predictive_samples value:\\n\", posterior_predictive_samples)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ak2DGvKmLqyv"
      },
      "source": [
        "Below we plot a \"heatmap\" of the posterior predictive distribution. (Which is just a scatter plot of the posterior, but we can visualise it as a heatmap.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5HddB8d1A7X"
      },
      "source": [
        "t = posterior_predictive_samples.reshape(num_results, 2)\n",
        "fig = draw_sky(data)\n",
        "plt.title(f\"Galaxy positions and ellipcities of sky {num_sky}.\")\n",
        "plt.xlabel('x-position')\n",
        "plt.ylabel('y-position')\n",
        "plt.scatter(t[:, 0], t[:, 1], alpha = .015, c = '#F15854')  # Red\n",
        "plt.xlim(0, 4200)\n",
        "plt.ylim(0, 4200);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LCk0Wd5SL2Ah"
      },
      "source": [
        "The most probable position reveals itself like a lethal wound.\n",
        "\n",
        "Associated with each sky is another data point, located in `./data/Training_halos.csv` that holds the locations of up to three dark matter halos contained in the sky. For example, the night sky we trained on has halo locations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xSnboDWINzs9"
      },
      "source": [
        "halo_data = genfromtxt('data/Training_halos.csv', \n",
        "                          delimiter = ',',\n",
        "                          usecols = [1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
        "                          skip_header = 1)\n",
        "print(halo_data[num_sky])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HIccg51VN1bp"
      },
      "source": [
        "The third and fourth column represent the true x and y position of the halo. It appears that the Bayesian method has located the halo within a tight vicinity."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zpRSL5sZ1ZdY"
      },
      "source": [
        "fig = draw_sky(data)\n",
        "plt.title(f\"Galaxy positions and ellipcities of sky {num_sky}.\")\n",
        "plt.xlabel(\"x-position\")\n",
        "plt.ylabel(\"y-position\")\n",
        "plt.scatter(t[:, 0], t[:, 1], alpha = .015, c = '#F15854') # Red\n",
        "plt.scatter(halo_data[num_sky - 1][3], halo_data[num_sky - 1][4], \n",
        "            label = \"True halo position\",\n",
        "            c = 'k', s = 70)\n",
        "plt.legend(scatterpoints = 1, loc = 'lower left')\n",
        "plt.xlim(0, 4200)\n",
        "plt.ylim(0, 4200);\n",
        "\n",
        "print(\"True halo location:\", halo_data[num_sky][3], halo_data[num_sky][4])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4qTGj4xGMD3o"
      },
      "source": [
        "Perfect. Our next step is to use the loss function to optimise our location. A naive strategy would be to simply choose the mean:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nh9yUghy1dkp"
      },
      "source": [
        "mean_posterior = t.mean(axis = 0).reshape(1, 2)\n",
        "print(f\"Mean posterior: \\n {mean_posterior[0]}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bmdi8Oiz0tJd"
      },
      "source": [
        "but we also want to determine how good this mean score is. We can use the [DarkWorldsMetric.py](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter5_LossFunctions/DarkWorldsMetric.py) script to judge that."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EhqC4ZzxVbba"
      },
      "source": [
        "url = 'https://raw.githubusercontent.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/master/Chapter5_LossFunctions/DarkWorldsMetric.py'\n",
        "filename = wget.download(url)\n",
        "filename"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rh_R7W5l1hGD"
      },
      "source": [
        "from DarkWorldsMetric import main_score\n",
        "\n",
        "halo_data_sub = halo_data[num_sky - 1]\n",
        "\n",
        "nhalo_all  = halo_data_sub[0].reshape(1, 1)\n",
        "x_true_all = halo_data_sub[3].reshape(1, 1)\n",
        "y_true_all = halo_data_sub[4].reshape(1, 1)\n",
        "x_ref_all  = halo_data_sub[1].reshape(1, 1)\n",
        "y_ref_all  = halo_data_sub[2].reshape(1, 1)\n",
        "sky_prediction = mean_posterior\n",
        "\n",
        "print(\"Using the mean:\", sky_prediction[0])\n",
        "main_score(nhalo_all, x_true_all, y_true_all,\n",
        "           x_ref_all, y_ref_all, sky_prediction)\n",
        "\n",
        "# What's a bad score?\n",
        "random_guess = Independent(\n",
        "    Uniform(low = (0., 0.), high = (4200., 4200.)),\n",
        "    reinterpreted_batch_ndims = 1).sample()\n",
        "\n",
        "print(\"\\n Using a random location:\", random_guess[0])\n",
        "main_score(nhalo_all, x_true_all, y_true_all,\n",
        "            x_ref_all, y_ref_all, random_guess)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JgVnP8jOui8"
      },
      "source": [
        "This is a good guess, it is not very far from the true location, but it ignores the loss function that was provided to us. We also need to extend our code to allow for up to two additional, *smaller* halos: Let's create a function for automatizing our Tensorflow workflow from before. \n",
        "\n",
        "First let's reset our Tensorflow Graph and import the new dataset:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BrpRo49n1yyZ"
      },
      "source": [
        "num_sky = 215  # Choosing a file/sky to examine\n",
        "data = genfromtxt(f'data/Train_Skies/Train_Skies/Training_Sky{num_sky}.csv',\n",
        "                     dtype = f32,  # It's handy to specify the data type beforehand\n",
        "                     skip_header = 1,\n",
        "                     delimiter = ',',\n",
        "                     usecols = [1, 2, 3, 4])\n",
        "\n",
        "galaxy_positions = array(data[:, :2], dtype = f32)\n",
        "gal_ellipticities = array(data[:, 2:], dtype = f32)\n",
        "ellipticity_mean = mean(data[:, 2:], axis = 0)\n",
        "ellipticity_stddev = std(data[:, 2:], axis = 0)\n",
        "num_galaxies = array(galaxy_positions).shape[0]\n",
        "\n",
        "print(f\"Data on galaxies in sky {num_sky}.\")\n",
        "print(\"position_x, position_y, e_1, e_2\")\n",
        "print(data[:3])\n",
        "print(\"Number of Galaxies:\", num_galaxies)\n",
        "print(\"e_1 & e_2 mean:\", ellipticity_mean)\n",
        "print(\"e_1 & e_2 std_dev:\", ellipticity_stddev)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lQB0dpy81p6f"
      },
      "source": [
        "def multi_posterior_log_prob(mass_large, halo_pos):\n",
        "    \"\"\"Our modified posterior log probability, as a function of states\n",
        "    Closure over: data\n",
        "    \n",
        "    Args:\n",
        "      mass_large: scalar of halo mass, taken from state\n",
        "      halo_pos: tensor of halo position(s), taken from state\n",
        "    Closure over: \n",
        "      data\n",
        "    Returns: \n",
        "      Scalar sum of log probabilities\n",
        "    \"\"\"\n",
        "    # Set the random size of the halo's mass (we have multiple)\n",
        "    rv_mass_large = Uniform(low = 40., high = 180.)    \n",
        "    rv_mass_small_0 = 20.\n",
        "    rv_mass_small_1 = 20.\n",
        "             \n",
        "    # Set the initial prior positions of the halos, \n",
        "    # these are a set of 2-d Uniform distributions\n",
        "\n",
        "    rv_halo_pos = Independent(\n",
        "        Uniform(\n",
        "            low = reshape(\n",
        "                tile([0., 0.], num_halos_inum_sky),\n",
        "                (num_halos_inum_sky, 2)).astype(f32),\n",
        "            high = reshape(\n",
        "                tile([4200., 4200.], num_halos_inum_sky),\n",
        "                (num_halos_inum_sky, 2)).astype(f32)\n",
        "        ),\n",
        "        einterpreted_batch_ndims = 1)  # Notice this size\n",
        "      \n",
        "    fdist_constants = array([240., 70., 70.])\n",
        "       \n",
        "    # For our calculations of ellipcity derived from halo position, we derive means based\n",
        "    # on the sum of the means of forces from multiple halos\n",
        "\n",
        "    mean_sum = 0\n",
        "    mean_sum += (mass_large[0] / f_distance(data[:, :2], halo_pos[0, :], fdist_constants[0]) *\n",
        "        tangential_distance(data[:, :2], halo_pos[0, :]))\n",
        "    mean_sum += (rv_mass_small_0 / f_distance(data[:, :2], halo_pos[1, :], fdist_constants[1]) *\n",
        "        tangential_distance(data[:,:2], halo_pos[1, :]))\n",
        "    mean_sum += (rv_mass_small_1 / f_distance(data[:, :2], halo_pos[2, :], fdist_constants[2]) *\n",
        "        tangential_distance(data[:, :2], halo_pos[2, :]))\n",
        "        \n",
        "    ellpty = MultivariateNormalDiag(\n",
        "        loc = (mean_sum,),\n",
        "        scale_diag = (0.223607, 0.223607))\n",
        "\n",
        "    return (sum(ellpty.log_prob(data[:, 2:]), axis = 0) + \n",
        "            rv_halo_pos.log_prob(halo_pos[0, :].astype(f32))[0] + \n",
        "            rv_halo_pos.log_prob(tf.cast(halo_pos[1, :], f32))[1] +\n",
        "            rv_halo_pos.log_prob(tf.cast(halo_pos[2, :], f32))[2] + \n",
        "            rv_mass_large.log_prob(tf.cast(mass_large[0][0], f32)))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IsfBD04hxr_y",
        "cellView": "code"
      },
      "source": [
        "# Inferring the posterior distribution\n",
        "num_results = 5000\n",
        "num_burnin_steps = 1000\n",
        "num_leapfrog_steps = 6\n",
        "    \n",
        "# We have three halos in the sky instead of one\n",
        "num_halos_inum_sky = 3\n",
        "\n",
        "# Set the chain's start state\n",
        "initial_chain_state = [\n",
        "    tf.constant([80., 20., 20.],\n",
        "                shape = (num_halos_inum_sky, 1), \n",
        "                dtype = f32),\n",
        "    tf.constant([1000., 500., 2100., 1500., 3500., 4000.], \n",
        "                shape = (num_halos_inum_sky, 2), \n",
        "                dtype = f32)]\n",
        "\n",
        "# Since HMC operates over unconstrained space, we need to transform the\n",
        "# samples so they live in real-space.\n",
        "unconstraining_bijectors = [\n",
        "    tfb.Identity(),\n",
        "    tfb.Identity()]\n",
        "\n",
        "# Define a closure over our joint_log_prob\n",
        "unnormalised_posterior_log_prob = lambda *args: multi_posterior_log_prob( *args)\n",
        "\n",
        "# Initialise the step_size (it will be automatically adapted)\n",
        "step_size = tf.Varible(\n",
        "    initial_value = tf.constant(.6, dtype = f32),\n",
        "    trainable = False,\n",
        "    name = 'step_size')\n",
        "\n",
        "# Define the HMC\n",
        "kernel = tfp.mcmc.TransformedTransitionKernel(\n",
        "    inner_kernel = tfp.mcmc.HamiltonianMonteCarlo(\n",
        "        target_log_prob_fn = unnormalised_posterior_log_prob,\n",
        "        num_leapfrog_steps = num_leapfrog_steps,\n",
        "        step_size = step_size,\n",
        "        state_gradients_are_stopped = True),\n",
        "    bijector = unconstraining_bijectors)\n",
        "\n",
        "kernel = tfp.mcmc.SimpleStepSizeAdaptation(\n",
        "    inner_kernel = kernel,\n",
        "    num_adaptation_steps = int(num_burnin_steps * .8))\n",
        "\n",
        "# Sampling from the chain\n",
        "(mass_large, halo_pos), kernel_results = tfp.mcmc.sample_chain(\n",
        "    num_results = num_results,\n",
        "    num_burnin_steps = num_burnin_steps,\n",
        "    current_state = initial_chain_state,\n",
        "    kernel = kernel)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QMn0V1Zj4qhc"
      },
      "source": [
        "large_halo_pos = halo_pos[:,0]\n",
        "small1_halo_pos = halo_pos[:,1]\n",
        "small2_halo_pos = halo_pos[:,2]\n",
        "\n",
        "# print(\"Acceptance rate:\", mean(kernel_results.inner_results.inner_results.is_accepted))\n",
        "# print(\"Final step size:\", kernel_results.new_step_size[-100:].mean())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOh30jd719rq"
      },
      "source": [
        "fig = draw_sky(data)\n",
        "plt.title(f\"Galaxy positions and ellipcities of sky {num_sky}.\")\n",
        "plt.xlabel(\"x-position\")\n",
        "plt.ylabel(\"y-position\")\n",
        "\n",
        "# Hex for red, purple, and yellow-orange\n",
        "colors = ['#F15854', '#B276B2', '#FAA43A']\n",
        "\n",
        "t1 = large_halo_pos\n",
        "t2 = small1_halo_pos\n",
        "t3 = small2_halo_pos\n",
        "\n",
        "plt.scatter(t1[:,0], t1[:,1], alpha = .015, c = colors[0])\n",
        "plt.scatter(t2[:,0], t2[:,1], alpha = .015, c = colors[1])\n",
        "plt.scatter(t3[:,0], t3[:,1], alpha = .015, c = colors[2])\n",
        "    \n",
        "for i in range(3):\n",
        "    plt.scatter(halo_data[num_sky - 1][3 + 2 * i],\n",
        "                halo_data[num_sky - 1][4 + 2 * i], \n",
        "                label = \"True halo position\", c = 'k', s = 90)\n",
        "    \n",
        "# plt.legend(scatterpoints = 1)\n",
        "plt.xlim(0, 4200)\n",
        "plt.ylim(0, 4200);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1kfhERKKPdp-"
      },
      "source": [
        "This looks pretty good, though it took a long time for the system to (sort of) converge. Our optimisation step would look something like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q23126YI2CQ5"
      },
      "source": [
        "from DarkWorldsMetric import main_score\n",
        "\n",
        "halo_data_sub = halo_data[num_sky - 1]\n",
        "\n",
        "\n",
        "halo_lar_mean = mean(large_halo_pos, axis = 0)\n",
        "halo_sm1_mean = mean(small1_halo_pos, axis = 0) \n",
        "halo_sm2_mean = mean(small2_halo_pos, axis = 0)\n",
        "\n",
        "mean_posterior = [concatenate([halo_lar_mean, halo_sm1_mean, halo_sm2_mean_])]\n",
        "\n",
        "nhalo_all  = halo_data_sub[0].reshape(1, 1)\n",
        "x_true_all = halo_data_sub[3].reshape(1, 1)\n",
        "y_true_all = halo_data_sub[4].reshape(1, 1)\n",
        "x_ref_all  = halo_data_sub[3].reshape(1, 1)\n",
        "y_ref_all  = halo_data_sub[4].reshape(1, 1)\n",
        "sky_prediction1 = mean_posterior[0][:2]\n",
        "sky_prediction2 = mean_posterior[0][2:4]\n",
        "sky_prediction3 = mean_posterior[0][4:]\n",
        "\n",
        "print(\"Using the means:\",\n",
        "      sky_prediction1, \n",
        "      sky_prediction2, \n",
        "      sky_prediction3)\n",
        "main_score([1], x_true_all, y_true_all,\n",
        "           x_ref_all, y_ref_all, [sky_prediction3])\n",
        "\n",
        "# what's a bad score?\n",
        "print(\"\\n\")\n",
        "random_guess = random.randint(0, 4200, size = (1, 2))\n",
        "print(\"Using a random location:\", random_guess[0])\n",
        "main_score([1], x_true_all, y_true_all,\n",
        "           x_ref_all, y_ref_all, random_guess)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8DC8sam2Q65-"
      },
      "source": [
        "## References\n",
        "[1] Antifragile: Things That Gain from Disorder. New York: Random House. 2012. ISBN 978-1-4000-6782-4.\n",
        "\n",
        "[2]  [Tim Saliman's solution to the Dark World's Contest](http://www.timsalimans.com/observing-dark-worlds)\n",
        "\n",
        "[3] Silver, Nate. The Signal and the Noise: Why So Many Predictions Fail — but Some Don't. 1. Penguin Press HC, The, 2012. Print."
      ]
    }
  ]
}