Variational Inference.ipynb

variational-inference.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Variational Inference.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/gist/NTT123/ab2f0c496cb72df46c2f69eafd3ea69d/variational-inference.ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "Rf8ggzpaseW3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "# Differential Privacy for Bayesian Inference\n",
        "\n",
        "*Abstract*. \n",
        "\n",
        "We propose a novel method to protect privacy for Bayesian inference.  We first transform the log-likelihood function into a bounded function using a sanitizer function. Then, we use mean field variational inference to approximate the posterior distribution. Next, we use the exponential mechanism with Kullback–Leibler divergence as the utility function to define a probability distribution of all mean-field approximations. \n",
        "Finally, we use stochastic gradient Langevin dynamics to draw a random mean field approximation from the probability distribution defined by the exponential mechanism with Kullback–Leibler divergence. The random mean field approximation guarantees differential privacy for individuals in the dataset.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "z8822g-SszFY",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Introduction\n"
      ]
    },
    {
      "metadata": {
        "id": "0KtcTFxCghct",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "The objective of Bayesian inference (previously known as inverse probability) is to compute the posterior distribution of latent parameters given the observed data. Let $\\theta$ be the parameter vector of the model and $x$ be the observed data. By Bayes' theorem, we have:\n",
        "$$\n",
        "P(\\theta \\mid x) = \\frac{P(x \\mid \\theta) \\times P(\\theta)}{P(x)}\n",
        "$$\n",
        "\n",
        "Here $P(\\theta \\mid x)$ is the posterior distribution of $\\theta$, $P(\\theta)$ is the prior distribution, $P(x \\mid \\theta)$ is the likelihood function and $P(x)$ is  the evidence. $P(x)$ can be computed as follows:\n",
        "$$\n",
        "P(x) =  \\int_\\theta P(x \\mid \\theta) P(\\theta) d\\theta\n",
        "$$\n",
        "\n",
        "However,  this integral is untractable in general. There are two general approach to tackle this problem: (1) monte carlo markov chains (MCMC) algorithm and (2) variational inference (VI). MCMC algorithm constructs a markov chain whose statationary distribution is $P(\\theta \\mid x)$. Meanwhile, VI approximates $P(\\theta \\mid x)$ by a parametrized  and tractable distribution $Q(\\theta \\mid z)$ such that $Q(\\theta \\mid z)$ is as close as possible to $P(\\theta \\mid x)$.\n",
        "\n",
        "Here, we aim to protect the privacy of individuals in the dataset, which is used by Bayesian inference as of the observed data $x$. Especially, we aim to guarantee differential privacy for Bayesian inference.  Differential privacy is a robust and mathematical definition of privacy protection which guarantees that each individual's data does not much influent on the soon-be-published information which is extracted from the dataset of these individuals. Let $z$ be the information which is extracted from the dataset $x$.  Differential privacy constructs a probability distribution  $P(z \\mid x)$ which is the distribution of $z$ given $x$. The bits of information will be published is a random sample of $P(z \\mid x)$:\n",
        "$$\n",
        "z_{priv} \\sim P(z \\mid x)\n",
        "$$\n",
        "\n",
        "Differential privacy guarantees that for any two neighbouring dataset $x$ and $x^\\prime$ which are different at only one data record, $P(z\\mid x)$ and $P(z \\mid x^\\prime)$ are close to each other. For any neighbouring dataset $x$ and $x^\\prime$, and for any $z$:\n",
        "$$\n",
        "P(z \\mid x) \\leq \\exp(\\epsilon) \\cdot P(z \\mid x^\\prime)\n",
        "$$\n",
        "\n",
        "Here, $\\epsilon$ is called the privacy budget. Low $\\epsilon$ guarantees strong privacy, otherwise high $\\epsilon$ guarantees weak privacy.\n",
        "\n",
        "In this work, $z$, which is the extracted information from dataset $x$, is actually the parameter vector of the mean field variational distribution $Q(\\theta \\mid z)$. In other words, we aim to guarantee that publishing parameters of the approximated posterior distribution will not compromise the privacy of individuals data record in $x$.\n",
        "\n",
        "There are previous works related to this problem. Wang et al. [1] are the first to prove that sampling a single random sample from the posterior distribution guarantees differential privacy under some conditions. The authors use stochastic gradient Monte-Carlo to sample the posterior distribution. Park et al. [2] proposed that for variational inference with conjugate exponential (CE) family, it is enough for guaranteeing differential privacy by perturbing the expected sufficient statistics of the complete-data likelihood. J{\\\"a}lk{\\\"o} et al. [3]  proposed to guarantee differential privacy for variational inference with non-conjugate models by a Gaussian mechanism which adds gaussian noise to the gradient vector at each step of the optimization procedure.   \n",
        "\n",
        "\n",
        "\n",
        "[1] Privacy for Free: Posterior Sampling and Stochastic Gradient Monte Carlo \n",
        "\n",
        "@inproceedings{wang2015privacy,\n",
        "  title={Privacy for free: Posterior sampling and stochastic gradient monte carlo},\n",
        "  author={Wang, Yu-Xiang and Fienberg, Stephen and Smola, Alex},\n",
        "  booktitle={International Conference on Machine Learning},\n",
        "  pages={2493--2502},\n",
        "  year={2015}\n",
        "}\n",
        "\n",
        "[2] Variational Bayes In Private Settings (VIPS)\n",
        "@article{park2016variational,\n",
        "  title={Variational Bayes in private settings (VIPS)},\n",
        "  author={Park, Mijung and Foulds, James and Chaudhuri, Kamalika and Welling, Max},\n",
        "  journal={arXiv preprint arXiv:1611.00340},\n",
        "  year={2016}\n",
        "}\n",
        "\n",
        "[3] Differentially Private Variational Inference for Non-conjugate Models\n",
        "@inproceedings{jalko2017differentially,\n",
        "  title={Differentially Private Variational Inference for Non-conjugate Models},\n",
        "  author={J{\\\"a}lk{\\\"o}, Joonas and Dikmen, Onur and Honkela, Antti and others},\n",
        "  booktitle={Uncertainty in Artificial Intelligence 2017 Proceedings of the 33rd Conference, UAI 2017},\n",
        "  year={2017},\n",
        "  organization={The Association for Uncertainty in Artificial Intelligence}\n",
        "}"
      ]
    },
    {
      "metadata": {
        "id": "9sbqVY6ePz9A",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Method"
      ]
    },
    {
      "metadata": {
        "id": "VWMbbTLjgl0d",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The main idea of our method is to use exponential mechanism to define a probability distribution of vector $z$ with the utility function $U(z; x)$ based on the Kullback–Leibler divergence score. The probability density function of $z$ is defined as follows:\n",
        "$$\n",
        "f_Z(z) \\propto \\exp\\left( \\frac{U(z; x)}{2\\Delta_U} \\cdot \\epsilon\\right) \n",
        "$$\n",
        "where $\\Delta_U$ is the sensitivity of the utility function $U$.  For any $z$ and any pair of neighbouring datasets $x$ and $x^\\prime$,\n",
        "$$\n",
        "\\Delta_U = \\max_{z, x, x^\\prime} \\left| U(z; x) - U(z; x^\\prime) \\right|\n",
        "$$\n",
        "It is proven that a random sample from above distribution guarantees $\\epsilon$-differential privacy. \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "Eg_7i4yDn7V7",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Here, we define the utility function equal to the variational lowerbound as follows: \n",
        "$$\n",
        "\\begin{align}\n",
        "U(z; x) &= \\log\\left( P(x) \\right) - D_{KL} \\left( Q(\\theta \\mid z) ~\\|~ P(\\theta \\mid x) \\right) \\\\\n",
        "&= \\mathrm{E}_Q \\left[   \\log\\left(P(x \\mid \\theta)\\right) + \\log\\left( P(\\theta)\\right)  - \\log\\left(Q(\\theta \\mid z)\\right) \\right]\n",
        "\\end{align}\n",
        "$$\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "5QX6nKRXqBtF",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Then, the sensitivity of $U$ is\n",
        "$$\n",
        "\\Delta_U = \\max_{z, x, x^\\prime}  \\left| \\mathrm{E}_Q \\left[  \\log\\left(P(x \\mid \\theta\\right) - \\log\\left(P(x^\\prime \\mid \\theta) \\right)\\right] \\right|\n",
        "$$\n",
        "\n",
        "Let $\\ell(\\theta; x_i)$ is the log-likelihood of function of $i^{th}$ data record, then $$ P(x \\mid \\theta) = \\sum_{i=1}^n \\ell(\\theta; x_i)$$ where $n$ is the size of dataset $x$. Now, assuming that two neightbouring dataset $x$ and $x^\\prime$ are differ at only $x_n$ and $x^\\prime_n$,\n",
        "$$\n",
        "\\Delta_U = \\max_{z, x, x^\\prime} \\left | \\mathrm{E}_Q \\left[ \\ell(\\theta; x_n) - \\ell(\\theta; x_n^\\prime)\\right] \\right|\n",
        "$$"
      ]
    },
    {
      "metadata": {
        "id": "Oc3Dupwq3q_J",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "So, the objective here is to bound $\\Delta_U$ by a finite number. We here achive that by approximate $\\ell(\\theta; x_i)$ by a finite log-likelihood function  $\\gamma(\\theta; x_i)$ as follows:\n",
        "$$\n",
        "\\gamma(\\theta; x_i) = \\tau \\cdot \\textrm{tanh}\\left( \\frac{\\ell(\\theta; x_i)}{\\tau} \\right)\n",
        "$$ where $[-\\tau; \\tau]$ is the range of $\\gamma(\\cdot)$. The below figure shows the effect of the approximation to an identity function with $\\tau = 2.0$:"
      ]
    },
    {
      "metadata": {
        "id": "lgzjDtL65ITg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "9217d363-5be2-4591-8134-9a6ae72658e8"
      },
      "cell_type": "code",
      "source": [
        "#@title Figure 1. Bounded log-likelihood function\n",
        "\n",
        "from pylab import rcParams\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch\n",
        "\n",
        "rcParams['figure.figsize'] = 4,3\n",
        "x = torch.linspace(-3, 3, 100)\n",
        "y1 = x.clone()\n",
        "tau = 2.0\n",
        "y2 = tau * torch.tanh(y1 / tau)\n",
        "plt.plot(x.numpy(), y1.numpy(), \"r-\")\n",
        "plt.plot(x.numpy(), y2.numpy(), \"b-\")\n",
        "plt.legend(['$\\ell(\\cdot)$', '$\\gamma(\\cdot)$' ])\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "xUTAHvAN6VVf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The idea here is to keep the shape of the log-likelihood function $\\ell(\\cdot)$ at *important values* near $0$ and deform the function at other values to keep it finite.\n",
        "\n",
        "It is then guaranteed that by using $\\gamma$ instead of $\\ell$ as the log-likelihood function,\n",
        "$$\n",
        "\\Delta_U \\leq 2\\tau\n",
        "$$"
      ]
    },
    {
      "metadata": {
        "id": "iCp6r1oG7ZTK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Next, we now aim to draw a random sample from $f_Z(z)$, we use stochastic gradient langevin dynamics (SGLD) to achieve this goal. The basic idea of SGLD is that a particle will follow the noisy gradient of its current location, which is adding a Gaussian noise to the gradient. After a long time, the probability distribution of the particle converges to the distribution we want. In our case, we have:\n",
        "$$\n",
        "z_{t+1} = z_t + \\frac{\\epsilon}{2\\Delta_U}\\cdot \\nabla U(z; x) \\cdot \\delta_t + r \\cdot \\sqrt{2 \\delta_t}\n",
        "$$\n",
        "where $r \\sim \\mathcal N(0, 1)$ and $\\delta_t$ is the step size at time $t$.\n",
        "\n",
        "We here assume that we can use the reparameterization trick for the probability $Q(\\theta \\mid z )$. In other words, we assume that we can represent $Q$ as follows:\n",
        "$$\n",
        "\\begin{align}\n",
        "r &\\sim  P(r) \\\\\n",
        "\\theta  &= g(z, r)\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "Therefore, $U(z; x)$ can be approximate by:\n",
        "$$\n",
        "U(z; x) \\approx  \\frac 1 L \\sum_{i=1}^L  \\left(\\log\\left(P(x \\mid \\theta_i)\\right) + \\log\\left( P(\\theta_i)\\right)  - \\log\\left(Q(\\theta_i \\mid z)\\right)  \\right)\n",
        "$$\n",
        "where $\\theta_i = g(z, r_i)$ and $r_i \\sim P(r)$. This approximate allows us to estimate the gradient of $U(z; x)$."
      ]
    },
    {
      "metadata": {
        "id": "R9miwhaS1c75",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Experiments"
      ]
    },
    {
      "metadata": {
        "id": "JuQEVlUPiY-i",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Data \n",
        "\n",
        "\n",
        "$$\n",
        "\\begin{align}\n",
        "Y &= a X_1 + b X_2 + intercept + r \\\\\n",
        "r &\\sim \\mathcal N(0, \\sigma^2)\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "We generate a dataset with \n",
        "$$\n",
        "\\begin{align}\n",
        "a  &= +2.0 \\\\\n",
        "b &= -3.5 \\\\\n",
        "intercept &= -5.0 \\\\\n",
        "\\sigma &= +0.1\n",
        "\\end{align}\n",
        "$$\n"
      ]
    },
    {
      "metadata": {
        "id": "XLvrRQUIyrwA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0cd672dd-c519-4d98-fea7-bc5801b46070"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "# http://pytorch.org/\n",
        "from os import path\n",
        "from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag\n",
        "platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())\n",
        "\n",
        "accelerator = 'cu80' if path.exists('/opt/bin/nvidia-smi') else 'cpu'\n",
        "\n",
        "!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.0-{platform}-linux_x86_64.whl torchvision\n",
        "import torch\n",
        "import tensorflow as tf\n",
        "\n",
        "#@title\n",
        "from pylab import rcParams\n",
        "import matplotlib.pyplot as plt\n",
        "rcParams['figure.figsize'] = 4,3\n",
        "rcParams['font.size'] = 14\n",
        "plt.style.use('ggplot')\n",
        "\n",
        "plt.rcParams['font.serif'] = 'dejavuserif'\n",
        "plt.rcParams['font.monospace'] = 'Ubuntu Mono'\n",
        "plt.rcParams['font.size'] = 16\n",
        "plt.rcParams['axes.labelsize'] = 14\n",
        "plt.rcParams['axes.labelweight'] = 'bold'\n",
        "plt.rcParams['axes.titlesize'] = 14\n",
        "plt.rcParams['xtick.labelsize'] = 12\n",
        "plt.rcParams['ytick.labelsize'] = 12\n",
        "plt.rcParams['legend.fontsize'] = 14\n",
        "plt.rcParams['figure.titlesize'] = 16"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[31mtorch-0.4.0-cp36-cp36m-linux_x86_64.whl is not a supported wheel on this platform.\u001b[0m\r\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "ziO0zpJcdRDy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "3a6acfdb-1efd-4f6a-ff65-c23841510504"
      },
      "cell_type": "code",
      "source": [
        "#@title Generate Data\n",
        "import torch\n",
        "N = 100\n",
        "\n",
        "isCuda = False\n",
        "if torch.cuda.device_count() > 0:\n",
        "    isCuda = True\n",
        "\n",
        "    \n",
        "isCuda = False\n",
        "\n",
        "a = 2.0\n",
        "b = -3.5\n",
        "intercept = -5.0\n",
        "noise = 0.1\n",
        "\n",
        "### \n",
        "\n",
        "#@title\n",
        "def generateData():\n",
        "    X = torch.rand(N, 2) - 0.5\n",
        "    theta = torch.zeros(2, 1)\n",
        "    theta[0, 0] = a\n",
        "    theta[1, 0] = b\n",
        "    Y = torch.mm(X, theta) + intercept + noise * torch.randn(N, 1)\n",
        "    data = torch.Tensor( N, 3 )\n",
        "    data[:, 0:2] = X\n",
        "    data[:, 2] = Y[:,0]\n",
        "    return data, X, Y\n",
        "\n",
        "#@title\n",
        "data, X, Y = generateData()\n",
        "if isCuda:\n",
        "    data = data.cuda()\n",
        "    X = X.cuda()\n",
        "    Y = Y.cuda()\n",
        "    \n",
        "import seaborn as sns\n",
        "_ = plt.scatter(X[:, 1], Y[:,0])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "6LSMDnTZiOPX",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#@title Posterior function\n",
        "\n",
        "def log_prior(theta):\n",
        "    coeff = theta[0:3]\n",
        "    sigma = theta[3]\n",
        "    hc = HalfCauchy(0.0, 10.0)\n",
        "\n",
        "    sigma1 = 10.0\n",
        "    \n",
        "    return torch.sum(  -torch.pow(coeff, 2) * 0.5 / (sigma1**2) \\\n",
        "                     -  math.log(sigma1) )  + hc.log_pdf_param(sigma)\n",
        "\n",
        "def log_likelihood(theta, data):\n",
        "    X = data[:, 0:2]\n",
        "    Y = data[:, 2:3]\n",
        "    slope = theta[0:2]\n",
        "    intercept = theta[2]\n",
        "    sigma = torch.exp(theta[3])\n",
        "    return torch.sum(- torch.pow(Y - (torch.mm(X, slope) + intercept), 2) * 0.5\\\n",
        "                          / torch.pow(sigma, 2) - theta[3]  )\n",
        "\n",
        "def log_posterior(theta, data):\n",
        "    return log_likelihood(theta, data) + log_prior(theta)\n",
        "\n",
        "\n",
        "import math\n",
        "class HalfCauchy:\n",
        "    def __init__(self, median, scale):\n",
        "        self.x0 = median\n",
        "        self.gamma = scale\n",
        "    def log_pdf(self, x):\n",
        "        inv =   math.log(math.pi) + math.log(self.gamma) + \\\n",
        "                    torch.log( 1.0 + torch.pow(x - self.x0, 2) / self.gamma)\n",
        "        \n",
        "        return math.log(2.0) - inv\n",
        "    \n",
        "        \n",
        "    def get(self, param):    \n",
        "        return torch.exp(param)\n",
        "    \n",
        "    def pdf(self, param):\n",
        "        return torch.exp(  self.log_pdf(self.get(param)) )\n",
        "    \n",
        "    def log_pdf_param(self, param):\n",
        "        x = torch.exp(param)\n",
        "        return self.log_pdf(x) + param\n",
        "        \n",
        "    def pdf_param(self, param):\n",
        "        #self.param.zero_()\n",
        "        #self.param[0] = param\n",
        "        x = torch.exp(param)\n",
        "        return self.pdf(x) * torch.exp(param)     \n",
        "    \n",
        "    \n",
        "theta = torch.zeros(4, 1, requires_grad=True)\n",
        "if isCuda:\n",
        "    theta = theta.data.cuda()\n",
        "theta.requires_grad= True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RXzKlg7Ix9Vl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "749392b1-6507-48d4-846c-c4dfbfb638dc"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "def computeK(p):\n",
        "    return torch.sum(torch.pow(p,2) / 2.0).data\n",
        "\n",
        "def computeU(theta, data):\n",
        "    return -log_posterior(theta, data)\n",
        "\n",
        "def computeH(theta, p, data):\n",
        "    return computeK(p) + computeU(theta, data)\n",
        "\n",
        "\n",
        "def gradientOfU(theta, data):\n",
        "    theta.requires_grad= True\n",
        "    if torch.is_tensor(theta.grad):\n",
        "        theta.grad.zero_()\n",
        "    out = computeU(theta, data)\n",
        "    out.backward()\n",
        "    theta.requires_grad= False\n",
        "    return theta.grad.data\n",
        "\n",
        "def gradientOfK(p):\n",
        "    return p\n",
        "\n",
        "data.requires_grad = False\n",
        "!pip install tqdm\n",
        "import tqdm"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tqdm in ./anaconda3/lib/python3.6/site-packages (4.11.2)\n",
            "\u001b[31mdistributed 1.22.0 requires msgpack, which is not installed.\u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "X_Ta_kGYh_-8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Maximum-a-posteriori (MAP) estimation"
      ]
    },
    {
      "metadata": {
        "id": "t99OYb3b1OaV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "239a1135-c43e-4c9e-b3b5-2195fa47717c"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "optimizer = torch.optim.SGD([ theta ], lr=1e-2)\n",
        "for t in tqdm.tqdm(range(100000)):\n",
        "    loss = -log_posterior(theta, data) / N\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "print(loss.item())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 100000/100000 [00:40<00:00, 2446.04it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "-1.7224104404449463\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "GbBa5UDt_ieL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "53b9b53c-6046-4c41-e3f8-f06ed3e52ba8"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "print( \"a = %f\\nb=%f\\nintercept=%f\\nsigma=%f\" % (theta[0,0].item(),\n",
        "                                                  theta[1,0].item(),\n",
        "                                                  theta[2,0].item(),\n",
        "                                                  math.exp(theta[3,0].item()) ))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a = 1.968788\n",
            "b=-3.456740\n",
            "intercept=-4.995243\n",
            "sigma=0.096378\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "6a5mfCFsKeOz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "fbfa93ad-10f3-4867-fe9c-9f08cd1ce253"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "!pip install pystan"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pystan in ./anaconda3/lib/python3.6/site-packages (2.17.1.0)\r\n",
            "Requirement already satisfied: Cython!=0.25.1,>=0.22 in ./anaconda3/lib/python3.6/site-packages (from pystan) (0.28.3)\r\n",
            "Requirement already satisfied: numpy>=1.7 in ./anaconda3/lib/python3.6/site-packages (from pystan) (1.14.5)\n",
            "\u001b[31mdistributed 1.22.0 requires msgpack, which is not installed.\u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Zc3S7N7FKf_M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "outputId": "6f1983f1-a4fe-474f-ca7d-b5f63db39d14"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "import pystan\n",
        "\n",
        "linreg_code = \"\"\"\n",
        "data {\n",
        "    int<lower=0> N;\n",
        "    matrix[N, 2] x; \n",
        "    real y[N]; \n",
        "}\n",
        "parameters {\n",
        "    real intercept;\n",
        "    vector[2] theta;\n",
        "    real<lower=0> sigma;\n",
        "}\n",
        "\n",
        "\n",
        "model {\n",
        "    vector[N] yhat;\n",
        "    theta ~ normal(0.0, 10.0);\n",
        "    intercept ~ normal(0.0, 10.0);\n",
        "    sigma ~ cauchy(0.0, 1.0);\n",
        "    \n",
        "    yhat = x * theta + intercept;    \n",
        "    \n",
        "    y ~ normal(yhat, sigma);\n",
        "}\n",
        "\"\"\"\n",
        "\n",
        "sm = pystan.StanModel(model_code=linreg_code)\n",
        "#@title\n",
        "X = data[:, 0:2]\n",
        "Y = data[:, 2:3]\n",
        "\n",
        "dat = {'N':N, \n",
        "       'x': X.cpu().numpy().reshape( (N, 2)),\n",
        "       'y': Y.cpu().numpy().reshape( (N) )  }\n",
        "\n",
        "fit = sm.sampling(data=dat, iter=10000, chains=1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_4daf455acfcec749c560df45af6f28b5 NOW.\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/pystan/misc.py:399: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
            "  elif np.issubdtype(np.asarray(v).dtype, float):\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "pNRjAKMQNAAQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 612
        },
        "outputId": "5698f775-c924-49af-9e71-1eaf5de7164a"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "rcParams['figure.figsize'] = 10,10\n",
        "fit.plot()\n",
        "rcParams['figure.figsize'] = 4,3\n",
        "samples = fit.extract()\n",
        "\n",
        "mytheta = torch.empty(len(samples['theta']), 4)\n",
        "mytheta[:, 0:2] = torch.from_numpy(samples['theta'])\n",
        "mytheta[:, 2]   = torch.from_numpy(samples['intercept'])\n",
        "mytheta[:, 3]   = torch.from_numpy(samples['sigma'])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "Xlke-fvC9BJf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Variational Inference\n",
        "\n",
        "\n",
        "Instead of drawing random samples from the posterior distribution $ P(z \\mid x)$, we could approximate the posterior distribution by a simpler distribution, e.g. Normal distributions. We here approximate the posterior distribution by a family of distributions whose coordinates  are independent Gaussian distributions $$ Q(z_i) = \\mathcal N(\\bar z_i, \\sigma_i^2)$$\n",
        "So $$Q(z) = \\prod_{i=1}^d Q(z_i)$$\n",
        "\n",
        "\n",
        "The objective is to choose $\\hat z_i, \\sigma_i$ such that the distance between $Q(z)$ and $P(z \\mid x)$ is minimized. Here, we use the Kullback–Leibler divergence (KLD) to measure the distance.\n",
        "$$\n",
        "\\begin{align}\n",
        "D_{KL}  \\left(Q(z) \\| P(z | x) \\right)  &= E_{Q}  \\left( \\log(Q(z)) - \\log(P(z \\mid x))  \\right)\\\\\n",
        "&=  E_{Q}  \\left( \\log(Q(z)) - \\log(P(x \\mid z)) - \\log(P(z) + \\log(P(x))  \\right) \\\\\n",
        "&\\geq E_Q \\left( \\log(Q(z)) - \\log(P(x \\mid z)) - \\log(P(z)  \\right)\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "\n",
        "We here use reparametriczation trick to represent the distribution $Q(z_i)$ as follows:\n",
        "$$\n",
        "\\begin{align}\n",
        "Q(z_i) &= r_i \\cdot \\sigma_i + \\bar z_i \\\\\n",
        "r_i &\\sim \\mathcal N(0, 1)\n",
        "\\end{align}\n",
        "$$\n",
        "\n",
        "By doing that, we seperate the stochastis noise $r_i$ from parameters $r_i$ and $\\bar z_i$. This allows us to compute the gradient of KLD with respect to these parameters.\n",
        "\n",
        "We first draw multiple random samples of $r_i$ and use these samples to estimate the expectation of the gradient.\n"
      ]
    },
    {
      "metadata": {
        "id": "OvOvrfUTKguO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "\n",
        "import torch \n",
        "def log_pdf_VI(theta, tau, sigma):\n",
        "     #return torch.sum(- torch.pow((theta - tau) / sigma, 2) * 0.5 - torch.log(sigma))\n",
        "     return torch.sum(- torch.log(sigma))\n",
        "\n",
        "def generate_noise(n):\n",
        "    return torch.randn(n, 4)\n",
        "\n",
        "\n",
        "noise = generate_noise(10)\n",
        "tau = torch.zeros(4, 1, requires_grad=True)\n",
        "logsigma = torch.zeros(4, 1, requires_grad=True)\n",
        "##noise * sigma.expand_as(noise) + tau.expand_as(noise)\n",
        "\n",
        "if isCuda:\n",
        "    tau = tau.cuda().data\n",
        "    logsigma = logsigma.cuda().data\n",
        "    tau.requires_grad=True\n",
        "    logsigma.requires_grad=True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vHrg6MolIsO7",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "X = data[:, 0:2]\n",
        "Y = data[:, 2:3]\n",
        "\n",
        "#Auto-Encoding Variational Inference\n",
        "def AEVI():\n",
        "    ###theta = torch.zeros(4, 1, requires_grad=False)\n",
        "    global tau, logsigma\n",
        "    #tau = torch.randn(4, 1, requires_grad=True)\n",
        "    #sigma = torch.ones(4, 1, requires_grad=True)\n",
        "    optimizer = torch.optim.Adam([ tau, logsigma ], lr=1e-3)\n",
        "    \n",
        "    n = 1\n",
        "    NN = 100000\n",
        "    for it in tqdm.tqdm(range(NN)):\n",
        "        if it == NN * 8 // 10:\n",
        "            optimizer = torch.optim.Adam([ tau, logsigma ], lr=1e-4)\n",
        "        loss = torch.zeros(1)\n",
        "        if isCuda:\n",
        "            loss = loss.cuda()\n",
        "        mysigma = torch.exp(logsigma)\n",
        "        ###sigma.data = torch.max(sigma, 1e-8*torch.ones_like(sigma))\n",
        "        ##if isCuda:\n",
        "        ##    sigma = sigma.cuda()\n",
        "            \n",
        "        for i in range(n):\n",
        "            noise = torch.randn(4,1).data\n",
        "            if isCuda:\n",
        "                noise = noise.cuda()\n",
        "            theta = noise * mysigma + tau\n",
        "            loss = loss + 1.0 / n *  ( log_pdf_VI(theta, tau, mysigma) - log_posterior(theta, data))\n",
        "        loss = loss / N\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        #if it % 1000 == 0:\n",
        "        #    print(loss.item())\n",
        "    print(N*loss.item())\n",
        "    return tau, logsigma"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qIIAcyRxUUT3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "ca0dde5e-aed9-4ebe-d63a-24c62cc4d911"
      },
      "cell_type": "code",
      "source": [
        "tau, logsigma = AEVI()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 100000/100000 [00:49<00:00, 2018.70it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "-153.43594551086426\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "xzvrFORxwxEC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 817
        },
        "outputId": "ac7db349-fbf5-4cb3-e1de-403aa8a739a7"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "import seaborn as sns\n",
        "name = [\"a\", \"b\", \"intercept\", \"sigma\"]\n",
        "\n",
        "\n",
        "sigma = torch.exp(logsigma.data)\n",
        "for id in range(4):\n",
        "    ##myt = [ s[id,0] for s in Xs[0:]]\n",
        "\n",
        "\n",
        "\n",
        "    ### myt = [ s[id,0] for s in Xs[0:]]\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    xx = torch.linspace(float(min(mytheta[:, id].numpy())), float(max(mytheta[:, id].numpy())), 100)\n",
        "    if id == 3:\n",
        "        xx = torch.linspace(math.log(float(min(mytheta[:, id].numpy()))), math.log(float(max(mytheta[:, id].numpy()))), 100)\n",
        "        \n",
        "    yy =  torch.exp( - 0.5 * torch.pow ( (xx - tau.cpu()[id,0])\\\n",
        "           / sigma.cpu()[id,0], 2)) / math.sqrt( 2. * math.pi ) \\\n",
        "    / sigma.cpu()[id,0]\n",
        "\n",
        "    \n",
        "    if id == 3:\n",
        "        ###myt = [math.exp(t) for t in myt]\n",
        "        xx = torch.exp(xx)\n",
        "        yy = yy / xx\n",
        "        \n",
        "    _ = sns.distplot(mytheta[:, id].numpy(), hist=False)\n",
        "\n",
        "   # _ = plt.legend(['Variational Inference'])        \n",
        "        \n",
        "    _ = plt.plot(xx.cpu().data.numpy(), yy.cpu().data.numpy(), \"b-\")\n",
        "\n",
        "    #_ = plt.legend(['Variational Inference', 'Hamiltonian Monte Carlo'])\n",
        "    plt.ylabel(name[id])\n",
        "    plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "wc54NsPEOaLt",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "logsigma_bak = logsigma.clone()\n",
        "tau_bak = tau.clone()\n",
        "logsigma = logsigma.data\n",
        "tau = tau.data"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "bM00khzh9nrY",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "### noise = generate_noise(10)\n",
        "tau = tau_bak.data # torch.zeros(4, 1, requires_grad=True)\n",
        "#sigma = sigma_bak.data # torch.ones(4, 1, requires_grad=True)\n",
        "logsigma =  logsigma_bak.data # torch.log(sigma_bak.data)\n",
        "##noise * sigma.expand_as(noise) + tau.expand_as(noise)\n",
        "\n",
        "if isCuda:\n",
        "    tau = tau.cuda().data\n",
        "    logsigma = logsigma.cuda().data\n",
        "    tau.requires_grad=True\n",
        "    logsigma.requires_grad=True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Mj7sotZC3YeZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "#Auto-Encoding Variational Inference - Stochastic Gradient Langevin Dynamics\n",
        "def AEVI_SGLD():\n",
        "    global tau, logsigma\n",
        "    #tau = torch.zeros(4, 1, requires_grad=True)\n",
        "    #sigma = torch.ones(4, 1, requires_grad=True)\n",
        "\n",
        "    if isCuda:\n",
        "        tau = tau.cuda().data\n",
        "        logsigma = logsigma.cuda().data\n",
        "        tau.requires_grad=True\n",
        "        logsigma.requires_grad=True\n",
        "    \n",
        "    et = 1e-5\n",
        "    \n",
        "    samples = []\n",
        "    \n",
        "    n = 1\n",
        "    var_tau = torch.zeros_like(tau)\n",
        "    var_sigma = torch.zeros_like(logsigma)\n",
        "    s_tau = torch.ones_like(tau)\n",
        "    s_sigma = et*torch.ones_like(logsigma)\n",
        "    s2_tau = et*math.sqrt(2.0*et)*torch.ones_like(tau)\n",
        "    s2_sigma = math.sqrt(2.0*et)*torch.ones_like(logsigma)\n",
        "    NN = 500000\n",
        "    lim = NN // 4\n",
        "    for it in tqdm.tqdm(range(NN)):\n",
        "        logsigma.requires_grad = True\n",
        "        tau.requires_grad = True\n",
        "        loss = torch.zeros(1)\n",
        "        if isCuda:\n",
        "            loss = loss.cuda()\n",
        "            \n",
        "        for i in range(n):\n",
        "            noise = torch.randn(4,1, requires_grad=False)\n",
        "            if isCuda:\n",
        "                noise = noise.cuda()\n",
        "                \n",
        "            mysigma = torch.exp(logsigma)\n",
        "            qtheta = noise * mysigma + tau\n",
        "            loss = loss + 1.0 / n *  ( log_pdf_VI(qtheta, tau, mysigma) - log_posterior(qtheta, data))\n",
        "        loss = loss \n",
        "        \n",
        "        \n",
        "        loss.backward()\n",
        "        \n",
        "        #if it % 100 == 0:\n",
        "        #    print(logsigma.grad.data, tau.grad.data)\n",
        "\n",
        "        if it < lim:\n",
        "            var_tau = var_tau +  torch.pow(tau.grad.data, 2)\n",
        "            var_sigma = var_sigma + torch.pow(logsigma.grad.data, 2)\n",
        "            tau_noise = torch.randn_like(tau) * math.sqrt(2*et) \n",
        "            sigma_noise = torch.randn_like(logsigma) * math.sqrt(2*et) \n",
        "\n",
        "            tau = tau.data - et * tau.grad.data + tau_noise\n",
        "            logsigma = logsigma.data - et * logsigma.grad.data + sigma_noise \n",
        "            \n",
        "        elif it == lim:\n",
        "            et = 2e-2\n",
        "            s_tau = et / torch.sqrt(var_tau/lim)\n",
        "            s_sigma = et / torch.sqrt(var_sigma/lim)\n",
        "            s2_tau = torch.sqrt(2*s_tau.data)\n",
        "            s2_sigma = torch.sqrt(2*s_sigma.data)\n",
        "        else:\n",
        "            tau_noise = torch.randn_like(tau) * s2_tau\n",
        "            sigma_noise = torch.randn_like(logsigma) * s2_sigma\n",
        "\n",
        "            tau = tau.data - s_tau * tau.grad.data + tau_noise\n",
        "            logsigma = logsigma.data - s_sigma * logsigma.grad.data + sigma_noise \n",
        "\n",
        "            samples.append(  ( tau.data.numpy(), logsigma.data.numpy() ) )\n",
        "        #if it % 1000 == 0:\n",
        "        #    print(loss.item())\n",
        "    return samples"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "BhrkF4ozHeVj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5ebcdb54-6c9b-4d16-cbcf-2f4671051974"
      },
      "cell_type": "code",
      "source": [
        "samples = AEVI_SGLD()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 500000/500000 [04:15<00:00, 1953.99it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "lPxWLzncAYoA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 870
        },
        "outputId": "587ce4fb-7bf4-4d10-e113-7a4e0511ed26"
      },
      "cell_type": "code",
      "source": [
        "rcParams['figure.figsize'] = 10,10\n",
        "\n",
        "for id in range(4):\n",
        "    for yy in range(2):\n",
        "        plt.subplot(4,2,id*2 + yy+1)\n",
        "        ss = [ sample[yy][id] for sample in samples if not math.isnan(sample[yy][id])]\n",
        "        sns.distplot(ss)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 8 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "_54nFFCGkDNw",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import math\n",
        "import numpy as np\n",
        "import tqdm\n",
        "sess = tf.Session()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "2qGP9Q_AlGFz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "3c81e8b0-58fe-4626-b040-d09c6703c8f1"
      },
      "cell_type": "code",
      "source": [
        "tf.reset_default_graph()\n",
        "\n",
        "with tf.device('/cpu:0'):\n",
        "    D = tf.constant(data.numpy())\n",
        "    X = D[:, 0:2]\n",
        "    Y = D[:, 2:3]\n",
        "\n",
        "    theta = tf.Variable(tf.zeros([4, 1]))\n",
        "\n",
        "    co = theta[0:3,0]\n",
        "    coeff = theta[0:2,:]\n",
        "    intercept = theta[2,0]\n",
        "    logsigma = theta[3,0]\n",
        "    sigma = tf.exp(logsigma)\n",
        "\n",
        "    gamma = tf.constant(1.0)\n",
        "    x0 = tf.constant(0.0)\n",
        "\n",
        "    log_cauchy_sigma = tf.constant(math.log(math.pi)) + tf.log(gamma) + \\\n",
        "                            tf.log(  1.0 + tf.pow( sigma - x0, 2)/gamma)\n",
        "\n",
        "    log_cauchy_logsigma = tf.constant(math.log(2.0)) - log_cauchy_sigma + logsigma\n",
        "\n",
        "    log_prior =   tf.reduce_sum( -tf.pow(co / 10 , 2) * 0.5 - math.log(10.0) ) + \\\n",
        "                            log_cauchy_logsigma\n",
        "\n",
        "    Yhat = tf.matmul(X, coeff) + intercept \n",
        "\n",
        "    log_likelihood = tf.reduce_sum(  -tf.pow( Y - Yhat, 2) * 0.5 /tf.pow(sigma, 2) - logsigma )\n",
        "\n",
        "    log_posterior = log_likelihood + log_prior\n",
        "    loss = -log_posterior / N\n",
        "\n",
        "    ## grad_theta = tf.gradients(loss, theta)\n",
        "\n",
        "    optimizer = tf.train.GradientDescentOptimizer(0.01)\n",
        "    train = optimizer.minimize(loss, var_list=[theta])\n",
        "\n",
        "init = tf.global_variables_initializer()\n",
        "\n",
        "sess = tf.Session()\n",
        "sess.run(init)\n",
        "for i in tqdm.tqdm(range(200000)):\n",
        "    sess.run(train)\n",
        "\n",
        "tttheta = sess.run(theta)\n",
        "print(tttheta)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 200000/200000 [00:49<00:00, 4025.34it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[ 1.968788 ]\n",
            " [-3.4567404]\n",
            " [-4.995243 ]\n",
            " [-2.3395596]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "9HoJmLHd4uzk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "e148bb8e-5960-4e75-ed71-9bf6ca592fc5"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "tf.reset_default_graph()\n",
        "\n",
        "with tf.device('/cpu:0'):\n",
        "    D = tf.constant(data.numpy())\n",
        "    X = D[:, 0:2]\n",
        "    Y = D[:, 2:3]\n",
        "    \n",
        "    vi_mean  = tf.Variable( tf.zeros([4,1]) )\n",
        "    vi_logsigma = tf.Variable( tf.zeros([4,1]))\n",
        "    vi_sigma = tf.exp(vi_logsigma)\n",
        "\n",
        "    noi = tf.random_normal( [4, 1])\n",
        "\n",
        "    sample = noi * vi_sigma + vi_mean\n",
        "\n",
        "    co = sample[0:3,:]\n",
        "    coeff = sample[0:2,:]\n",
        "    intercept = sample[2,0]\n",
        "    logsigma = sample[3,0]\n",
        "    sigma = tf.exp(logsigma)\n",
        "\n",
        "    gamma = 1.0\n",
        "    x0 = 0.0\n",
        "\n",
        "    log_cauchy_sigma = math.log(math.pi) + math.log(gamma) + tf.log(  1.0 + tf.pow( sigma - x0, 2)/gamma)\n",
        "\n",
        "    log_cauchy_logsigma = math.log(2.0) - log_cauchy_sigma + logsigma\n",
        "\n",
        "    log_prior =   -tf.reduce_sum( tf.pow(co / 10.0, 2)  * 0.5  ) +  log_cauchy_logsigma\n",
        "\n",
        "\n",
        "    Yhat =  tf.matmul(X, coeff) + intercept\n",
        "    log_likelihood = -tf.reduce_sum(  tf.pow((Y-Yhat)/sigma , 2) * 0.5 + logsigma )\n",
        "\n",
        "    log_posterior = log_likelihood + log_prior\n",
        "\n",
        "    vi_loss = -(log_posterior + tf.reduce_sum(vi_logsigma)) / N\n",
        "\n",
        "\n",
        "    optimizer = tf.train.AdamOptimizer(1e-3)\n",
        "    train = optimizer.minimize(vi_loss, var_list=[vi_mean, vi_logsigma])\n",
        "    \n",
        "    optimizer1 = tf.train.AdamOptimizer(1e-4)\n",
        "    train1 = optimizer1.minimize(vi_loss, var_list=[vi_mean, vi_logsigma])\n",
        "\n",
        "init = tf.global_variables_initializer()\n",
        "sess = tf.Session()\n",
        "sess.run(init)\n",
        "NN = 100000\n",
        "for i in tqdm.tqdm(range(NN)):\n",
        "    if i == (NN * 8) // 10:\n",
        "        train = train1\n",
        "    sess.run(train)\n",
        "\n",
        "mm, ms =  sess.run( (vi_mean, vi_logsigma) )\n",
        "print(mm)\n",
        "print(ms)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 100000/100000 [00:30<00:00, 3227.48it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[ 1.9687058]\n",
            " [-3.4554336]\n",
            " [-4.994718 ]\n",
            " [-2.3188744]]\n",
            "[[-3.3951802]\n",
            " [-3.3895028]\n",
            " [-4.6173453]\n",
            " [-2.6347327]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "Jcshx1ASnDyB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 817
        },
        "outputId": "de8057f0-914b-4c8a-d327-e1176c899b07"
      },
      "cell_type": "code",
      "source": [
        "#@title Plot hist\n",
        "import seaborn as sns\n",
        "\n",
        "rcParams['figure.figsize'] = 4,3\n",
        "\n",
        "logsigma = torch.from_numpy(ms.astype(np.float32))\n",
        "sigma = torch.exp(logsigma.data)\n",
        "\n",
        "tau =  torch.from_numpy(mm.astype(np.float32))\n",
        "for id in range(4):\n",
        "\n",
        "    xx = torch.linspace(float(min(mytheta[:, id].numpy())), float(max(mytheta[:, id].numpy())), 100)\n",
        "    if id == 3:\n",
        "        xx = torch.linspace(math.log(float(min(mytheta[:, id].numpy()))), math.log(float(max(mytheta[:, id].numpy()))), 100)\n",
        "        \n",
        "    yy =  torch.exp( - 0.5 * torch.pow ( (xx - tau.cpu()[id,0])\\\n",
        "           / sigma.cpu()[id,0], 2)) / math.sqrt( 2. * math.pi ) \\\n",
        "    / sigma.cpu()[id,0]\n",
        "\n",
        "    \n",
        "    if id == 3:\n",
        "        xx = torch.exp(xx)\n",
        "        yy = yy / xx\n",
        "        \n",
        "    _ = sns.distplot(mytheta[:, id].numpy(), hist=False)\n",
        "\n",
        "        \n",
        "    _ = plt.plot(xx.cpu().data.numpy(), yy.cpu().data.numpy(), \"b-\")\n",
        "\n",
        "    plt.ylabel(name[id])\n",
        "    plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "metadata": {
        "id": "lsvkeW7_-5Pk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "0c3cfa55-bf00-4af5-aa8b-d079b1c9fb59"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "tf.reset_default_graph()\n",
        "\n",
        "\n",
        "et = 1e-5\n",
        "\n",
        "with tf.device('/cpu:0'):\n",
        "    D = tf.constant(data.numpy())\n",
        "    X = D[:, 0:2]\n",
        "    Y = D[:, 2:3]\n",
        "    \n",
        "    vi_mean  = tf.Variable( mm )\n",
        "    vi_logsigma = tf.Variable( ms )\n",
        "\n",
        "    vi_mean_var  = tf.Variable( tf.zeros([4,1]) )\n",
        "    vi_logsigma_var = tf.Variable( tf.zeros([4,1]))\n",
        "\n",
        "    vi_sigma = tf.exp(vi_logsigma)\n",
        "\n",
        "    noi = tf.random_normal( [4, 1])\n",
        "\n",
        "    sample = noi * vi_sigma + vi_mean\n",
        "\n",
        "    co = sample[0:3,:]\n",
        "    coeff = sample[0:2,:]\n",
        "    intercept = sample[2,0]\n",
        "    logsigma = sample[3,0]\n",
        "    sigma = tf.exp(logsigma)\n",
        "\n",
        "    gamma = 1.0\n",
        "    x0 = 0.0\n",
        "\n",
        "    log_cauchy_sigma = math.log(math.pi) + math.log(gamma) + tf.log(  1.0 + tf.pow( sigma - x0, 2)/gamma)\n",
        "\n",
        "    log_cauchy_logsigma = math.log(2.0) - log_cauchy_sigma + logsigma\n",
        "\n",
        "    log_prior =   -tf.reduce_sum( tf.pow(co / 10.0, 2)  * 0.5  ) +  log_cauchy_logsigma\n",
        "\n",
        "\n",
        "    Yhat =  tf.matmul(X, coeff) + intercept\n",
        "    log_likelihood = -tf.reduce_sum(  tf.pow((Y-Yhat)/sigma , 2) * 0.5 + logsigma )\n",
        "\n",
        "    log_posterior = log_likelihood + log_prior\n",
        "\n",
        "    vi_loss = -(log_posterior + tf.reduce_sum(vi_logsigma)) \n",
        "    \n",
        "    vi_mean_grad, vi_logsigma_grad = tf.gradients(vi_loss, [vi_mean, vi_logsigma] )\n",
        "    vi_mean_noise = tf.random_normal( [4, 1]) * math.sqrt(2*et)\n",
        "    vi_logsigma_noise = tf.random_normal( [4, 1]) * math.sqrt(2*et)\n",
        "    \n",
        "    vi_mean_ops = tf.assign_sub(vi_mean, vi_mean_grad * et + vi_mean_noise )\n",
        "    vi_logsigma_ops = tf.assign_sub(vi_logsigma, vi_logsigma_grad * et + vi_logsigma_noise )\n",
        "    \n",
        "    vi_mean_var_ops = tf.assign_add(vi_mean_var,  tf.pow(vi_mean_grad, 2) )\n",
        "    vi_logsigma_var_ops = tf.assign_add(vi_logsigma_var,  tf.pow(vi_logsigma_grad, 2) )\n",
        "\n",
        "init = tf.global_variables_initializer()\n",
        "sess = tf.Session()\n",
        "sess.run(init)\n",
        "NN = 500000\n",
        "for i in tqdm.tqdm(range(NN//4)):\n",
        "    _,_,ll,_,_ = sess.run( (vi_mean_var_ops, vi_logsigma_var_ops, vi_loss, vi_mean_ops, vi_logsigma_ops) )\n",
        "    #if i % 1000 == 0:\n",
        "    #    print(ll)\n",
        "\n",
        "mmm, mms =  sess.run( (vi_mean_var, vi_logsigma_var) )\n",
        "mv = np.sqrt(mmm / (NN//4))\n",
        "mls = np.sqrt(mms / (NN//4))\n",
        "print(mv)\n",
        "print(mls)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 125000/125000 [01:00<00:00, 2072.36it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[ 38.23356096]\n",
            " [ 45.56322025]\n",
            " [129.28715624]\n",
            " [ 24.21933905]]\n",
            "[[2.02829269]\n",
            " [3.14925991]\n",
            " [1.43159033]\n",
            " [3.83896822]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "BA0_sJLebGGK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f248fca1-57da-4099-bd34-e6b63affd358"
      },
      "cell_type": "code",
      "source": [
        "#@title\n",
        "tf.reset_default_graph()\n",
        "\n",
        "\n",
        "et = 2e-2\n",
        "\n",
        "with tf.device('/cpu:0'):\n",
        "    D = tf.constant(data.numpy())\n",
        "    X = D[:, 0:2]\n",
        "    Y = D[:, 2:3]\n",
        "    tfmv = tf.constant(mv, dtype=tf.float32)\n",
        "    tflsv = tf.constant(mls, dtype=tf.float32)\n",
        "    \n",
        "    vi_mean  = tf.Variable( mm )\n",
        "    vi_logsigma = tf.Variable( ms )\n",
        "\n",
        "    vi_mean_var  = tf.Variable( tf.zeros([4,1]) )\n",
        "    vi_logsigma_var = tf.Variable( tf.zeros([4,1]))\n",
        "\n",
        "    vi_sigma = tf.exp(vi_logsigma)\n",
        "\n",
        "    noi = tf.random_normal( [4, 1])\n",
        "\n",
        "    sample = noi * vi_sigma + vi_mean\n",
        "\n",
        "    co = sample[0:3,:]\n",
        "    coeff = sample[0:2,:]\n",
        "    intercept = sample[2,0]\n",
        "    logsigma = sample[3,0]\n",
        "    sigma = tf.exp(logsigma)\n",
        "\n",
        "    gamma = 1.0\n",
        "    x0 = 0.0\n",
        "\n",
        "    log_cauchy_sigma = math.log(math.pi) + math.log(gamma) + tf.log(  1.0 + tf.pow( sigma - x0, 2)/gamma)\n",
        "\n",
        "    log_cauchy_logsigma = math.log(2.0) - log_cauchy_sigma + logsigma\n",
        "\n",
        "    log_prior =   -tf.reduce_sum( tf.pow(co / 10.0, 2)  * 0.5  ) +  log_cauchy_logsigma\n",
        "\n",
        "\n",
        "    Yhat =  tf.matmul(X, coeff) + intercept\n",
        "    log_likelihood = -tf.reduce_sum(  tf.pow((Y-Yhat)/sigma , 2) * 0.5 + logsigma )\n",
        "\n",
        "    log_posterior = log_likelihood + log_prior\n",
        "\n",
        "    vi_loss = -(log_posterior + tf.reduce_sum(vi_logsigma)) \n",
        "    \n",
        "    vi_mean_grad, vi_logsigma_grad = tf.gradients(vi_loss, [vi_mean, vi_logsigma] )\n",
        "    vi_mean_noise = tf.random_normal( [4, 1]) * tf.sqrt(2*et / tfmv)\n",
        "    vi_logsigma_noise = tf.random_normal( [4, 1]) * tf.sqrt(2*et / tflsv)\n",
        "    \n",
        "    vi_mean_ops = tf.assign_sub(vi_mean, vi_mean_grad * et / tfmv + vi_mean_noise )\n",
        "    vi_logsigma_ops = tf.assign_sub(vi_logsigma, vi_logsigma_grad * et / tflsv + vi_logsigma_noise )\n",
        "    \n",
        "\n",
        "init = tf.global_variables_initializer()\n",
        "sess = tf.Session()\n",
        "sess.run(init)\n",
        "\n",
        "NN = 500000\n",
        "\n",
        "LLS = []\n",
        "for i in tqdm.tqdm(range(NN)):\n",
        "    ll,_,_, vivimean, vivilogsigma = \\\n",
        "    sess.run( (vi_loss, vi_mean_ops, vi_logsigma_ops, vi_mean, vi_logsigma) )\n",
        "    LLS.append(  (vivimean, vivilogsigma) )\n",
        "    #if i % 1000 == 0:\n",
        "    #    print(ll)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 500000/500000 [03:52<00:00, 2154.11it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "id": "LVVjKsfPisSw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 870
        },
        "outputId": "d7c0016c-a07d-42fb-c8f1-6e88f9dedc25"
      },
      "cell_type": "code",
      "source": [
        "rcParams['figure.figsize'] = 10,10\n",
        "\n",
        "for id in range(4):\n",
        "    for yy in range(2):\n",
        "        plt.subplot(4,2,id*2 + yy+1)\n",
        "        ss = [ sample[yy][id] for sample in LLS if not math.isnan(sample[yy][id])]\n",
        "        sns.distplot(ss)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n",
            "/Users/xcode/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
            "  warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 8 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}