model_w_auto_grad_HMC.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "model_w_auto_grad_HMC.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOmBJDmvDJqu8Ro/cXe1b3W",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/svetaU/hmc/blob/main/model_w_auto_grad_HMC.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import scipy.stats as st\n",
        "import math\n",
        "from matplotlib import pyplot as plt\n",
        "from matplotlib.animation import FuncAnimation, writers"
      ],
      "metadata": {
        "id": "4YwUzIP922O1"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# HMC"
      ],
      "metadata": {
        "id": "WlWqL6nuQIql"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "R76KAy11z_VV"
      },
      "outputs": [],
      "source": [
        "def leapfrog(q, p, dUdq, num_steps, step_size, random_step=False,m=None):\n",
        "  if random_step:\n",
        "    step_size = np.random.uniform(step_size*0.8,step_size*1.2,1)\n",
        "  if m is None:\n",
        "    m = np.ones(len(p))\n",
        "  q, p = np.copy(q), np.copy(p)\n",
        "  p -= step_size * dUdq(q) / 2.0  \n",
        "  leap_path = [np.copy(q)]\n",
        "  for _ in range(num_steps - 1):\n",
        "      q += step_size * p/m  \n",
        "      p -= step_size * dUdq(q) \n",
        "      leap_path.append(np.copy(q))\n",
        "  q += step_size * p/m  \n",
        "  p -= step_size * dUdq(q) / 2.0\n",
        "  leap_path.append(np.copy(q)) \n",
        "  return (q,-p,leap_path)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def hamiltonian_monte_carlo(U, grad_U, current_position, steps=1, delta_t=0.5, change_step = False, masses = None):\n",
        "  q = np.copy(current_position)\n",
        "  p = np.random.normal(0.0,1.0,len(q)) \n",
        "  current_momentum = np.copy(p)\n",
        "  if masses is None:\n",
        "    masses = np.ones(len(p))\n",
        "  q, p, path = leapfrog(q,p,grad_U,steps,delta_t,change_step, masses)\n",
        "  current_U = U(current_position)\n",
        "  current_K = sum(current_momentum*current_momentum/masses) / 2\n",
        "  proposed_U = U(q)\n",
        "  proposed_K = sum(p*p/masses) / 2\n",
        "  if (np.log(np.random.rand()) < (current_U-proposed_U+current_K-proposed_K)):\n",
        "    return (q,proposed_U,1,path) # accept\n",
        "  else:\n",
        "    return (current_position, current_U,0,None) # reject"
      ],
      "metadata": {
        "id": "BYGtoap__aD0"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Test\n",
        "Fit parameters of bivariate gaussian ($\\mu_X$,$\\mu_Y$,$\\sigma_X$, $\\sigma_Y$, and $\\rho$) \n",
        "$$ \n",
        "p(x,y) =\n",
        "      \\frac{1}{2 \\pi  \\sigma_X \\sigma_Y \\sqrt{1-\\rho^2}}\n",
        "      \\exp\n",
        "        \\left( -\\frac{1}{2(1-\\rho^2)}\\left[\n",
        "          \\left(\\frac{x-\\mu_X}{\\sigma_X}\\right)^2 -\n",
        "          2\\rho\\left(\\frac{x-\\mu_X}{\\sigma_X}\\right)\\left(\\frac{y-\\mu_Y}{\\sigma_Y}\\right) +\n",
        "          \\left(\\frac{y-\\mu_Y}{\\sigma_Y}\\right)^2 \n",
        "        \\right]\n",
        "       \\right)\n",
        "$$\n",
        " via Bayesian approach with priors in the general form of\n",
        " $$\n",
        " \\pi_{ab}(\\mu_X,\\mu_Y,\\sigma_X,\\sigma_Y,\\rho)=\\frac{1}{\\sigma_X^{3-a}\\sigma_Y^{2-b}\\left(1-\\rho^2\\right )^{2-b/2}}\n",
        " $$\n",
        " ."
      ],
      "metadata": {
        "id": "uwCOu6nrQB5I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FitBivariatNormal():\n",
        "\n",
        "  def __init__(self, **kwargs):\n",
        "    self.data = []\n",
        "\n",
        "  def set_data(self,data):\n",
        "    self.data = np.copy(data)\n",
        "\n",
        "  def log_likelihood(self,params): # -log(p)\n",
        "    m1 = params[0]\n",
        "    m2 = params[1]\n",
        "    s1 = params[2]\n",
        "    s2 = params[3]\n",
        "    corr = params[4]\n",
        "    y = 0\n",
        "    for x in self.data:\n",
        "      y = y + ( (x[0] - m1)**2/s1/s1 + (x[1] - m2)**2/s2/s2 - 2.0*corr*(x[0] - m1)*(x[1] - m2)/s2/s2 )/2.0/(1-corr*corr) \\\n",
        "      + math.log(s1) + math.log(s2) + 0.5*math.log(1. - corr*corr)\n",
        "    return y   \n",
        "\n",
        "  def tf_log_likelihood(self,params): # -log(p)\n",
        "    y = 0\n",
        "    for x in self.data:\n",
        "      y = y + tf.math.divide(( tf.math.divide(tf.math.square(x[0] - params[0]),tf.math.square(params[2])) \\\n",
        "               + tf.math.divide(tf.math.square(x[1] - params[1]),tf.math.square(params[3])) \\\n",
        "               - tf.math.divide(2.0*params[4]*tf.math.multiply((x[0] - params[0]),(x[1] - params[1])),tf.math.multiply(params[2],params[3])) ) \\\n",
        "      ,tf.math.multiply(2.0,(1-tf.math.square(params[4])))) \\\n",
        "      + tf.math.log(params[2]) + tf.math.log(params[3]) + 0.5*tf.math.log(1. - tf.math.square(params[4]))\n",
        "    return y \n",
        "\n",
        "  def log_priors(self,params): # -log(\\pi)\n",
        "    a = 1\n",
        "    b = 0\n",
        "    m1 = params[0]\n",
        "    m2 = params[1]\n",
        "    s1 = params[2]\n",
        "    s2 = params[3]\n",
        "    corr = params[4]\n",
        "    p_params = (3. - a)*s1 + (2. - b)*s2 + (2. - 0.5*b)*(1. - corr*corr)\n",
        "    return p_params\n",
        "\n",
        "  def tf_log_priors(self,params): # -log(\\pi)\n",
        "    a = 1\n",
        "    b = 0\n",
        "    hyp_params = tf.constant([0.,0.,(3. - a),(2. - b),(2. - 0.5*b)])\n",
        "    p_params = tf.math.multiply(hyp_params,params)\n",
        "    y = tf.reduce_sum(p_params) - tf.math.multiply(hyp_params[4],params[4]) + tf.math.multiply(hyp_params[4],(1. - tf.math.square(params[4])))\n",
        "    return y\n",
        "\n",
        "  def log_likelihood_grad(self,params): \n",
        "    params = tf.convert_to_tensor(params, dtype=tf.float32)\n",
        "    with tf.GradientTape() as tape:\n",
        "      tape.watch(params)\n",
        "      y = self.tf_log_likelihood(params)\n",
        "    return tape.gradient(y,params).numpy()\n",
        "\n",
        "  def log_priors_grad(self, params):\n",
        "    params = tf.convert_to_tensor(params, dtype=tf.float32)\n",
        "    with tf.GradientTape() as tape:\n",
        "      tape.watch(params)\n",
        "      y = self.tf_log_priors(params)\n",
        "    return tape.gradient(y,params).numpy()\n",
        "\n",
        "  def log_prob(self, params):\n",
        "    return self.log_likelihood(params) + self.log_priors(params)\n",
        "\n",
        "  def log_prob_grad(self,params):\n",
        "    return self.log_likelihood_grad(params) + self.log_priors_grad(params)\n"
      ],
      "metadata": {
        "id": "RZt78QWMbTFH"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fit parameters"
      ],
      "metadata": {
        "id": "gK_lj5M2UPym"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fit_bivariate_w_hmc():\n",
        "  target_mean = [2.,3.]\n",
        "  target_cov = [[2.5,0.4],[0.4,1.6]] \n",
        "  sigma1 = round(math.sqrt(target_cov[0][0]),2)\n",
        "  sigma2 = round(math.sqrt(target_cov[1][1]),2)\n",
        "  rho = round(target_cov[0][1]/sigma1/sigma2,2)\n",
        "  sample_size = 100\n",
        "  data_sample = np.random.multivariate_normal(target_mean,target_cov,size=sample_size)\n",
        "  m = [2.,2.,10.,10., 100.]\n",
        "  x_limits = (target_mean[0] - target_cov[0][0]*1.,target_mean[0] + target_cov[0][0]*1.)\n",
        "  y_limits = (target_mean[1] - target_cov[1][1]*1.,target_mean[1] + target_cov[1][1]*1.)\n",
        "  model_fit = FitBivariatNormal()\n",
        "  model_fit.set_data(data_sample)\n",
        "  points_to_sim = 100\n",
        "  l_steps = 10\n",
        "  burn = 0\n",
        "  hmc_steps = np.asarray(range(points_to_sim+1-burn))\n",
        "  sim_dots = []\n",
        "  q = np.asarray([0.,0.,1.,1.,0.])\n",
        "  sim_dots.append(q)\n",
        "  paths = []\n",
        "  accept_rate = 0\n",
        "  for i in range(points_to_sim):\n",
        "    q, orbit,accept,l_path = hamiltonian_monte_carlo(model_fit.log_prob,model_fit.log_prob_grad,q,steps=l_steps, \\\n",
        "                                                     delta_t=0.01,masses = m)\n",
        "    sim_dots.append(q)\n",
        "    paths.append(l_path)\n",
        "    accept_rate = accept_rate + accept\n",
        "  fig = plt.figure(figsize = (5,5))\n",
        "  axes = fig.add_subplot(1,1,1)\n",
        "  #axes.set_xlim(x_limits[0],x_limits[1])\n",
        "  #axes.set_ylim(y_limits[0],y_limits[1])\n",
        "  for point in sim_dots[burn:points_to_sim]:\n",
        "    plt.scatter(point[0],point[1],c='red',s=30)\n",
        "  for path in paths[burn:points_to_sim]:\n",
        "    if path is not None:\n",
        "      plt.plot(np.asarray(path)[:,0],np.asarray(path)[:,1], c='black')\n",
        "  plt.title(\"Bivariate means\")\n",
        "  plt.xlabel(\"mu1\")\n",
        "  plt.ylabel(\"mu2\")  \n",
        "  plt.show()\n",
        "  print(\"Acceptance rate \" + str(accept_rate/points_to_sim))\n",
        "  print(\"First mean \" + str(np.mean(np.asarray(sim_dots)[burn:,0])) + \" (expected \" + str(target_mean[0]) + \")\")\n",
        "  print(\"Second mean \" + str(np.mean(np.asarray(sim_dots)[burn:,1])) + \" (expected \" + str(target_mean[1]) + \")\")\n",
        "  print(\"First sigma \" + str(np.mean(np.asarray(sim_dots)[burn:,2])) + \" (expected \" + str(sigma1) + \")\")\n",
        "  print(\"Second sigma \" + str(np.mean(np.asarray(sim_dots)[burn:,3])) + \" (expected \" + str(sigma2) + \")\")\n",
        "  print(\"Rho \" + str(np.mean(np.asarray(sim_dots)[burn:,4])) + \" (expected \" + str(rho) + \")\")\n",
        "  \n",
        "  plt.scatter(hmc_steps,np.asarray(sim_dots)[burn:,0])\n",
        "  plt.title(\"Trace plot mu1\")\n",
        "  plt.xlabel(\"iteration\")\n",
        "  plt.ylabel(\"mu1\")  \n",
        "  plt.show()\n",
        "  plt.scatter(hmc_steps,np.asarray(sim_dots)[burn:,1])\n",
        "  plt.title(\"Trace plot mu2\")\n",
        "  plt.xlabel(\"iteration\")\n",
        "  plt.ylabel(\"mu2\")  \n",
        "  plt.show()\n",
        "  plt.scatter(hmc_steps,np.asarray(sim_dots)[burn:,2])\n",
        "  plt.title(\"Trace plot sigma1\")\n",
        "  plt.xlabel(\"iteration\")\n",
        "  plt.ylabel(\"sigma1\")  \n",
        "  plt.show()\n",
        "  plt.scatter(hmc_steps,np.asarray(sim_dots)[burn:,3])\n",
        "  plt.title(\"Trace plot sigma2\")\n",
        "  plt.xlabel(\"iteration\")\n",
        "  plt.ylabel(\"sigma2\")  \n",
        "  plt.show()\n",
        "  plt.scatter(hmc_steps,np.asarray(sim_dots)[burn:,4])\n",
        "  plt.title(\"Trace plot rho\")\n",
        "  plt.xlabel(\"iteration\")\n",
        "  plt.ylabel(\"rho\")  \n",
        "  plt.show()\n",
        "  return sim_dots\n",
        "  "
      ],
      "metadata": {
        "id": "SlQoXwUFoPH9"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sim_dots = fit_bivariate_w_hmc()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "48ccAKj12zP4",
        "outputId": "57a2263b-1581-4920-c254-871778d6895a"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Acceptance rate 0.99\n",
            "First mean 1.7815858203813226 (expected 2.0)\n",
            "Second mean 2.693833860794356 (expected 3.0)\n",
            "First sigma 1.5372962034470015 (expected 1.58)\n",
            "Second sigma 1.3915539199703335 (expected 1.26)\n",
            "Rho 0.08330516748903308 (expected 0.2)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Infer data"
      ],
      "metadata": {
        "id": "WYdhqtXqlubz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "infer_burn = 10\n",
        "infer_params = sim_dots[infer_burn:]\n",
        "num_infer_per_param = 1\n",
        "infer_x = []\n",
        "infer_y = []\n",
        "for param in infer_params:\n",
        "  target_mean = [param[0],param[1]]\n",
        "  target_cov = [[param[2]*param[2],param[4]*param[2]*param[3]],[param[4]*param[2]*param[3],param[3]*param[3]]]\n",
        "  sample_x, sample_y = np.random.multivariate_normal(target_mean,target_cov,size=num_infer_per_param).T\n",
        "  infer_x.extend(sample_x)\n",
        "  infer_y.extend(sample_y)\n",
        "target_mean = [2.,3.]\n",
        "target_cov = [[2.5,0.4],[0.4,1.6]]\n",
        "m = [1.3,3.1]\n",
        "n_dots = 10000\n",
        "target_distribution_x, target_distribution_y = np.random.multivariate_normal(target_mean,target_cov,size=n_dots).T\n",
        "target_x_limits = (target_mean[0] - target_cov[0][0]*3,target_mean[0] + target_cov[0][0]*3)\n",
        "target_y_limits = (target_mean[1] - target_cov[1][1]*3,target_mean[1] + target_cov[1][1]*3)\n",
        "infer_x_limits = (min(infer_params[:][0]) - max(infer_params[:][2])*3,max(infer_params[:][0]) + max(infer_params[:][2])*3)\n",
        "infer_y_limits = (min(infer_params[:][1]) - max(infer_params[:][3])*3,max(infer_params[:][1]) + max(infer_params[:][3])*3)\n",
        "x_limits = (min(target_x_limits[0],infer_x_limits[0]),max(target_x_limits[1],infer_x_limits[1]))\n",
        "y_limits = (min(target_y_limits[0],infer_y_limits[0]),max(target_y_limits[1],infer_y_limits[1]))\n",
        "fig = plt.figure(figsize = (7,7))\n",
        "axes = fig.add_subplot(1,1,1)\n",
        "axes.set_xlim(x_limits[0],x_limits[1])\n",
        "axes.set_ylim(y_limits[0],y_limits[1])\n",
        "plt.scatter(target_distribution_x,target_distribution_y, c = 'blue', s=1, alpha = 0.3)\n",
        "plt.scatter(infer_x,infer_y, c = 'red', s=5)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "XYeWXp_EltLt",
        "outputId": "0b4dad58-fbd8-43ff-f7c3-d9275ecad405"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}