experiment3_ala2_RNVP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alanine dipeptide normalizing Flow\n",
    "------\n",
    "Normalizing Flow using RealNVP for sampling Alanine dipeptide structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "import mdtraj as md\n",
    "import matplotlib as mpl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import SVG\n",
    "from keras.utils.vis_utils import model_to_dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bgtorch.nn.flow.base import Flow\n",
    "from bgtorch.nn import DenseNet\n",
    "from bgtorch.nn.flow import (\n",
    "    SequentialFlow, \n",
    "    CouplingFlow, \n",
    "    AffineFlow, \n",
    "    SplitFlow,\n",
    "    MergeFlow,\n",
    "    InverseFlow, \n",
    "    SwapFlow\n",
    ")\n",
    "from bgtorch.nn.flow.transformer import AffineTransformer\n",
    "from bgtorch.distribution.energy import Energy\n",
    "from bgtorch.distribution.sampling import Sampler\n",
    "from bgtorch.distribution import NormalDistribution\n",
    "from bgtorch import BoltzmannGenerator\n",
    "from bgtorch.nn.training import KLTrainer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rcParams.update({'font.size': 16})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Switch AUTORELOAD ON. Disable this when in production mode!\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ala2\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_2ala_ramachandran(traj, ax=None, weights=None):\n",
    "    if ax==None:\n",
    "        ax = plt.gca()\n",
    "    \n",
    "\n",
    "    if isinstance(weights, np.ndarray):\n",
    "        ax.hist2d(md.compute_phi(traj)[1].reshape(-1), \n",
    "                  md.compute_psi(traj)[1].reshape(-1), \n",
    "                  bins=[np.linspace(-np.pi, np.pi, 64), np.linspace(-np.pi, np.pi, 64)],\n",
    "                  norm=mpl.colors.LogNorm(),\n",
    "                  weights=weights)\n",
    "    else:\n",
    "        ax.hist2d(md.compute_phi(traj)[1].reshape(-1), \n",
    "                  md.compute_psi(traj)[1].reshape(-1), \n",
    "                  bins=[np.linspace(-np.pi, np.pi, 64), np.linspace(-np.pi, np.pi, 64)],\n",
    "                  norm=mpl.colors.LogNorm())\n",
    "        \n",
    "    ax.set_xlim(-np.pi,np.pi)\n",
    "    ax.set_ylim(-np.pi,np.pi)\n",
    "    ax.set_xlabel(r'$\\phi$')\n",
    "    ax.set_ylabel(r'$\\psi$')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from openmmtools.testsystems import AlanineDipeptideVacuum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ala2 = AlanineDipeptideVacuum(constraints=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperature = 1000\n",
    "n_atoms = ala2.mdtraj_topology.n_atoms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from simtk import openmm, unit\n",
    "INTEGRATOR_ARGS = (temperature*unit.kelvin, \n",
    "                   1.0/unit.picoseconds, \n",
    "                   1.0*unit.femtoseconds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bgtorch.distribution.energy.openmm import OpenMMEnergy, OpenMMEnergyBridge\n",
    "ala2_omm_energy_bridge = OpenMMEnergyBridge(ala2.system, unit.nanometers, \n",
    "                                            openmm_integrator=openmm.LangevinIntegrator, \n",
    "                                            openmm_integrator_args=INTEGRATOR_ARGS)\n",
    "\n",
    "ala2_omm_energy = OpenMMEnergy(3 * n_atoms, ala2_omm_energy_bridge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bgtorch.utils.train import linlogcut\n",
    "\n",
    "class AugmentedEnergy(Energy):\n",
    "    def __init__(self, base_model, high_energy=None, max_energy=None):\n",
    "        super().__init__(2 * base_model.dim)\n",
    "        self.base_model = base_model\n",
    "        self.high_energy = high_energy\n",
    "        self.max_energy = max_energy\n",
    "    \n",
    "    def _energy(self, x, temperature=None):\n",
    "        U = self.base_model.energy(x[:, :self.base_model.dim])\n",
    "        if self.high_energy is not None or self.max_energy is not None:\n",
    "            U_mod = linlogcut(U, high_val=self.high_energy, max_val=self.max_energy, inplace=True)\n",
    "            #U_mod = _linlogcut(U, self.high_energy, self.max_energy)\n",
    "        else:\n",
    "            U_mod = U\n",
    "        \n",
    "        K = 0.5 * (x[:, self.base_model.dim:] ** 2).sum(axis=1, keepdim=True)            \n",
    "        return U_mod + K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load training data\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "ala2_pdb = md.load('./data/alanine-dipeptide.pdb').topology\n",
    "training_data_traj = md.load('./data/ala2_1000K_train.xtc', top=ala2_pdb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = md.compute_phi(training_data_traj)[1].reshape(-1)\n",
    "psi = md.compute_psi(training_data_traj)[1].reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1843b31b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5, 5))\n",
    "plot_2ala_ramachandran(training_data_traj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_data = training_data_traj.xyz.reshape((training_data_traj.xyz.shape[0], \n",
    "                                                3*training_data_traj.xyz.shape[1]))\n",
    "training_data = torch.tensor(training_data)\n",
    "training_data.requires_grad = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internal Coordinates\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACE1-H1\n",
      "ACE1-CH3\n",
      "ACE1-H2\n",
      "ACE1-H3\n",
      "ACE1-C\n",
      "ACE1-O\n",
      "ALA2-N\n",
      "ALA2-H\n",
      "ALA2-CA\n",
      "ALA2-HA\n",
      "ALA2-CB\n",
      "ALA2-HB1\n",
      "ALA2-HB2\n",
      "ALA2-HB3\n",
      "ALA2-C\n",
      "ALA2-O\n",
      "NME3-N\n",
      "NME3-H\n",
      "NME3-C\n",
      "NME3-H1\n",
      "NME3-H2\n",
      "NME3-H3\n"
     ]
    }
   ],
   "source": [
    "for atom in ala2_pdb.atoms:\n",
    "    print(atom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "rigid_block = np.array([6, 8, 9, 10, 14])\n",
    "Z = np.array([[0, 1, 4, 6],\n",
    "              [1, 4, 6, 8],\n",
    "              [2, 1, 4, 0],\n",
    "              [3, 1, 4, 0],\n",
    "              [4, 6, 8, 14],\n",
    "              [5, 4, 6, 8],\n",
    "              [7, 6, 8, 4],\n",
    "              [11, 10, 8, 6],\n",
    "              [12, 10, 8, 11],\n",
    "              [13, 10, 8, 11],\n",
    "              [15, 14, 8, 16],\n",
    "              [16, 14, 8, 6],\n",
    "              [17, 16, 14, 15],\n",
    "              [18, 16, 14, 8],\n",
    "              [19, 18, 16, 14],\n",
    "              [20, 18, 16, 19],\n",
    "              [21, 18, 16, 19]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bgtorch.nn.flow.crd_transform.ic import MixedCoordinateTransform\n",
    "mct = MixedCoordinateTransform(rigid_block, Z, X0=training_data, remove_dof=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boltzmann Generator\n",
    "-------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RNVP(shift_nhidden, scale_nhidden,\n",
    "         shift_activation=torch.nn.ReLU(), scale_activation=torch.nn.Tanh(), \n",
    "         shift_weight_scale=1.0, scale_weight_scale=1.0, \n",
    "         shift_bias_scale=0.0, scale_bias_scale=0.0, init_downscale=1.0):\n",
    "    \n",
    "    shift_transformation = None\n",
    "    if shift_nhidden is not None:\n",
    "        shift_transformation=DenseNet(shift_nhidden, activation=shift_activation, \n",
    "                                      weight_scale=shift_weight_scale, bias_scale=shift_bias_scale)            \n",
    "    scale_transformation = None\n",
    "    if scale_nhidden is not None:\n",
    "        scale_transformation=DenseNet(scale_nhidden, activation=scale_activation, \n",
    "                                      weight_scale=scale_weight_scale, bias_scale=scale_bias_scale)\n",
    "    transformer = AffineTransformer(shift_transformation=shift_transformation,\n",
    "                                    scale_transformation=scale_transformation,\n",
    "                                    init_downscale=init_downscale) \n",
    "    return CouplingFlow(transformer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WrapLeft(Flow):\n",
    "    def __init__(self, leftflow):\n",
    "        super().__init__()\n",
    "        self.leftflow = leftflow\n",
    "\n",
    "    def _forward(self, x1, x2, **kwargs):\n",
    "        y1, dlogp = self.leftflow(x1)\n",
    "        return y1, x2, dlogp\n",
    "    \n",
    "    def _inverse(self, x1, x2, **kwargs):\n",
    "        y1, dlogp = self.leftflow(x1, inverse=True)\n",
    "        return y1, x2, dlogp\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_XV_RNVP(hamiltonian_prior, hamiltonian_target, crd_transform, \n",
    "                  n_transform, shift_nhidden, scale_nhidden):\n",
    "    # here we aggregate all layers of the flow\n",
    "    layers = []\n",
    "\n",
    "    dim_x = hamiltonian_target.dim // 2\n",
    "    dim_v = dim_x\n",
    "    dim_ic = dim_x - 6\n",
    "    \n",
    "    # split\n",
    "    layers.append(SplitFlow(dim_ic))        \n",
    "        \n",
    "    # RealNVP block\n",
    "    for i in range(n_transform):\n",
    "        # ic(x) -> v\n",
    "        layers.append(RNVP([dim_ic] + shift_nhidden + [dim_v], [dim_ic] + scale_nhidden + [dim_v], \n",
    "                      shift_activation=torch.nn.ReLU(), scale_activation=torch.nn.ReLU()))\n",
    "        layers.append(SwapFlow())\n",
    "        # v -> ic(x)\n",
    "        layers.append(RNVP([dim_v] + shift_nhidden + [dim_ic], [dim_v] + scale_nhidden + [dim_ic], \n",
    "                      shift_activation=torch.nn.ReLU(), scale_activation=torch.nn.ReLU()))\n",
    "        layers.append(SwapFlow())\n",
    "\n",
    "    # add crd transform\n",
    "    layers.append(WrapLeft(crd_transform))\n",
    "            \n",
    "    # merge\n",
    "    layers.append(MergeFlow(dim_x))\n",
    "\n",
    "    # now define the flow as a sequence of all operations stored in layers\n",
    "    flexflow = SequentialFlow(layers)\n",
    "    \n",
    "    bg = BoltzmannGenerator(hamiltonian_prior, flexflow, hamiltonian_target)\n",
    "    \n",
    "    return bg    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CenteredNormalPrior(Energy, Sampler):\n",
    "    \"\"\" 2 particles in 1d \"\"\"\n",
    "    def __init__(self, nparticles, ndim=3, center_x=True, center_v=True):\n",
    "        super().__init__(2*nparticles*ndim)\n",
    "        self.nparticles = nparticles\n",
    "        self.ndim = ndim\n",
    "        self.center_x = center_x\n",
    "        self.center_v = center_v\n",
    "    \n",
    "    def _energy(self, x):\n",
    "        return 0.5 * (x ** 2).sum(dim=1, keepdim=True)\n",
    "\n",
    "    def sample(self, n_samples, temperature=1.):\n",
    "        # positions\n",
    "        x = torch.Tensor(n_samples, self.nparticles, self.ndim).normal_()\n",
    "        if self.center_x:\n",
    "            xc = (x - x.mean(dim=1, keepdim=True)).reshape(n_samples, self.nparticles * self.ndim)\n",
    "        else:\n",
    "            xc = x.reshape(n_samples, self.nparticles * self.ndim)\n",
    "        # velocities\n",
    "        v = torch.Tensor(n_samples, self.nparticles, self.ndim).normal_()\n",
    "        if self.center_v:\n",
    "            vc = (v - v.mean(dim=1, keepdim=True)).reshape(n_samples, self.nparticles * self.ndim)\n",
    "        else:\n",
    "            vc = v.reshape(n_samples, self.nparticles * self.ndim)\n",
    "        # merge\n",
    "        xvc = torch.cat([xc, vc], dim=1)\n",
    "        return xvc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim_x = 66\n",
    "dim_ic = 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "hamiltonian_prior = NormalDistribution(dim_ic + dim_x)\n",
    "hamiltonian_target = AugmentedEnergy(ala2_omm_energy, high_energy=500, max_energy=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "bg = build_XV_RNVP(hamiltonian_prior, hamiltonian_target, mct, \n",
    "                   5, [128, 128, 128], [128, 128, 128])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainer = KLTrainer(bg, train_likelihood=True, train_energy=True,\n",
    "                    optim = torch.optim.Adam(bg.parameters(), lr=1e-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "batchsize = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add velocities\n",
    "xv_aligned = torch.cat([training_data, torch.zeros_like(training_data).normal_()], dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\tNLL: -54.2732\tKLL: 228.3111\t\n",
      "21\tNLL: -56.7074\tKLL: 218.1371\t\n",
      "41\tNLL: -57.2294\tKLL: 231.5903\t\n",
      "61\tNLL: -56.5638\tKLL: 240.9319\t\n",
      "81\tNLL: -57.5110\tKLL: 221.1468\t\n",
      "101\tNLL: -57.8198\tKLL: 231.6376\t\n",
      "121\tNLL: -57.8288\tKLL: 227.4171\t\n",
      "141\tNLL: -56.7296\tKLL: 216.9637\t\n",
      "161\tNLL: -57.4042\tKLL: 221.5681\t\n",
      "181\tNLL: -59.1010\tKLL: 209.0111\t\n",
      "201\tNLL: -57.9445\tKLL: 218.1577\t\n",
      "221\tNLL: -57.3758\tKLL: 206.7437\t\n",
      "241\tNLL: -58.3927\tKLL: 204.3618\t\n",
      "261\tNLL: -59.5990\tKLL: 208.0047\t\n",
      "281\tNLL: -59.6057\tKLL: 219.5818\t\n",
      "301\tNLL: -58.8725\tKLL: 207.3417\t\n",
      "321\tNLL: -58.4459\tKLL: 216.3021\t\n",
      "341\tNLL: -59.0395\tKLL: 216.5821\t\n",
      "361\tNLL: -59.4179\tKLL: 202.6763\t\n",
      "381\tNLL: -59.0217\tKLL: 203.3714\t\n",
      "401\tNLL: -59.0475\tKLL: 204.4875\t\n",
      "421\tNLL: -58.9682\tKLL: 199.2023\t\n",
      "441\tNLL: -59.0115\tKLL: 209.4550\t\n",
      "461\tNLL: -59.8978\tKLL: 210.3892\t\n",
      "481\tNLL: -59.5831\tKLL: 202.5721\t\n",
      "501\tNLL: -59.4594\tKLL: 200.1960\t\n",
      "521\tNLL: -60.2990\tKLL: 195.7363\t\n",
      "541\tNLL: -59.6334\tKLL: 199.4119\t\n",
      "561\tNLL: -59.3505\tKLL: 201.3289\t\n",
      "581\tNLL: -60.4404\tKLL: 208.3080\t\n",
      "601\tNLL: -60.1512\tKLL: 197.4405\t\n",
      "621\tNLL: -60.5440\tKLL: 203.3889\t\n",
      "641\tNLL: -59.7839\tKLL: 197.3724\t\n",
      "661\tNLL: -60.0739\tKLL: 196.3294\t\n",
      "681\tNLL: -59.8904\tKLL: 191.9230\t\n",
      "701\tNLL: -61.2192\tKLL: 196.1466\t\n",
      "721\tNLL: -60.7955\tKLL: 202.1048\t\n",
      "741\tNLL: -59.5463\tKLL: 205.8044\t\n",
      "761\tNLL: -61.0785\tKLL: 204.4006\t\n",
      "781\tNLL: -59.1069\tKLL: 199.3847\t\n",
      "801\tNLL: -60.6395\tKLL: 199.5965\t\n",
      "821\tNLL: -61.5680\tKLL: 197.2731\t\n",
      "841\tNLL: -60.8359\tKLL: 187.3168\t\n",
      "861\tNLL: -60.8327\tKLL: 186.9758\t\n",
      "881\tNLL: -60.3593\tKLL: 195.9911\t\n",
      "901\tNLL: -61.7459\tKLL: 188.4561\t\n",
      "921\tNLL: -60.8913\tKLL: 185.2533\t\n",
      "941\tNLL: -61.3168\tKLL: 192.7509\t\n",
      "961\tNLL: -60.8424\tKLL: 199.1609\t\n",
      "981\tNLL: -60.7408\tKLL: 200.3898\t\n"
     ]
    }
   ],
   "source": [
    "trainer.train(1000, data=xv_aligned, batchsize=batchsize, w_likelihood=1, w_energy=0, n_print=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x417c5d198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(10, 5))\n",
    "loss_names, x, ys = trainer.losses()\n",
    "for (ax, loss_name, y) in zip(axes, loss_names, ys):\n",
    "    ax.plot(x, y)\n",
    "    ax.set_ylabel(loss_name)\n",
    "    ax.set_xlabel('Iterations')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sample\n",
    "n_samples = 20000\n",
    "z = hamiltonian_prior.sample(n_samples)\n",
    "xgen, dW = bg.flow(z, temperature=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mdtraj\n",
    "\n",
    "torsions_train = mdtraj.compute_dihedrals(training_data_traj, mct.Z_indices)\n",
    "\n",
    "gen_data_traj = mdtraj.Trajectory(xgen[:, :66].detach().reshape(-1, 22, 3).numpy(), ala2_pdb)\n",
    "torsions_gen = mdtraj.compute_dihedrals(gen_data_traj, mct.Z_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def periodic_convolution(x, kernel):\n",
    "    x_padded = np.concatenate([x, x, x])\n",
    "    y_padded = np.convolve(x_padded, kernel, mode='same')\n",
    "    return y_padded[x.size:-x.size]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "torsion_hists_train = []\n",
    "torsion_hists_gen = []\n",
    "xticks = None\n",
    "\n",
    "for i in range(torsions_train.shape[1]):\n",
    "    htrain, e = np.histogram(torsions_train[:, i], 50, range=(-np.pi, np.pi), density=True);\n",
    "    xticks = 0.5 * (e[1:] + e[:-1])\n",
    "    hgen, _ = np.histogram(torsions_gen[:, i], 50, range=(-np.pi, np.pi), density=True);\n",
    "\n",
    "    htrain = periodic_convolution(htrain, [0.25, 0.5, 1.0, 0.5, 0.25])\n",
    "    hgen = periodic_convolution(hgen, [0.25, 0.5, 1.0, 0.5, 0.25])\n",
    "\n",
    "    torsion_hists_train.append(htrain)\n",
    "    torsion_hists_gen.append(hgen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "torsions_simple = [4, 5, 6, 7, 8]\n",
    "torsions_complex = [0, 1, 2, 10, 12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(-2.84159,0.9,'RNVP')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x18c38e24a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#fig, axes = plt.subplots(nrows=2, ncols=5, sharex=True, figsize=(15, 5))\n",
    "fig, axes = plt.subplots(nrows=1, ncols=5, sharey=True, sharex=True, figsize=(15, 3))\n",
    "axes = axes.reshape((1, 5))\n",
    "fig.subplots_adjust(hspace=0.05, wspace=0.15)\n",
    "#for row, torsion_index in zip([0, 1], [torsions_simple, torsions_complex]):\n",
    "for row, torsion_index in zip([0], [torsions_complex]):\n",
    "    for i, ax in enumerate(axes[row]):\n",
    "        ax.plot(xticks, torsion_hists_train[torsion_index[i]], color='grey', linewidth=5)\n",
    "        ax.plot(xticks, torsion_hists_gen[torsion_index[i]], color='blue', linewidth=3)\n",
    "        ax.set_yticks([])\n",
    "        ax.set_xlim(-np.pi, np.pi)\n",
    "        if row == 0:\n",
    "            ax.set_ylim(0, 5)\n",
    "        if row == 1:\n",
    "            ax.set_ylim(0, 1.5)\n",
    "        if row == 1:\n",
    "            ax.set_xticks((-np.pi,0, np.pi))\n",
    "            ax.set_xticklabels(('$-\\pi$', 0,'$\\pi$'))\n",
    "    axes[-1,-1].set_yticks([])\n",
    "axes[0, 0].set_ylim(0, 1.5)\n",
    "axes[0, 0].text(0, 1.35, '$\\phi$')\n",
    "axes[0, 1].text(0, 1.35, '$\\gamma_1$')\n",
    "axes[0, 2].text(0, 1.35, '$\\psi$')\n",
    "axes[0, 3].text(0, 1.35, '$\\gamma_2$')\n",
    "axes[0, 4].text(0, 1.35, '$\\gamma_3$')\n",
    "axes[0, 0].set_ylabel('density')\n",
    "#axes[1, 0].set_ylabel('density')\n",
    "axes[0, -1].text(-np.pi+0.3, 1.1, 'Target', color='grey')\n",
    "axes[0, -1].text(-np.pi+0.3, 0.9, 'RNVP', color='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.71\n",
      "3.95\n",
      "0.81\n",
      "0.72\n",
      "0.87\n"
     ]
    }
   ],
   "source": [
    "eps = 1e-5\n",
    "for i in torsions_complex:\n",
    "    KL_NF = np.sum(torsion_hists_train[i] * np.log((torsion_hists_train[i]+eps) / (torsion_hists_gen[i]+eps)))\n",
    "    print(\"{:1.2f}\".format(KL_NF))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}