Hydrogen Atom Excited State.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NOTE: This is not a functioning notebook!\n",
    "\n",
    "The hydrogren atom's first excited state has a node: a location where the value of the wavefunction goes to zero.  Therefore, we can not represent it as a log as the ground state. ($ log 0 = -\\inf $ ...)\n",
    "\n",
    "So, please, you are welcome to look around here (the first half is familiar from the main notebook) but don't expect to solve the first excited state.  We'll come back to this to change the algorithms to try to solve this after the AI4NP school is all finished!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydrogen Atom\n",
    "\n",
    "In the previous notebook, we solved the harmonic oscillator for 1 dimension using artifical neural networks.  In this notebook, we'll go a step further and solve a more complicated system (Hydrogen) in more dimensions (3 of course).  We will use more sophisticated sampling of the wavefunction and compute the proper $\\nabla^2$ operator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy\n",
    "\n",
    "# What numerical precision?\n",
    "# Note: float32 == single precision is OK for this notebook.  Higher order methods need float64 for a matrix inversion step.\n",
    "DEFAULT_TENSOR_TYPE = tf.float32\n",
    "\n",
    "# How many walkers should we use?\n",
    "N_WALKERS = 500\n",
    "# How many times should we make an observation of the observables each iteration?\n",
    "N_OBSERVATIONS = 30\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from mpl_toolkits import mplot3d\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "from IPython.display import display, clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Surrogate Wavefunction\n",
    "\n",
    "For the hydrogen atom, we'll use a simple surrogate wavefunction.\n",
    "\n",
    "NOTE that the wavefunction is a surrogate for $log \\psi$, so the multiplicative initial boundary condition is a sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "class NeuralWavefunction(tf.keras.models.Model):\n",
    "    \"\"\"Create a neural network eave function in N dimensions\n",
    "\n",
    "    Boundary condition, if not supplied, is gaussian in every dimension\n",
    "\n",
    "    Extends:\n",
    "        tf.keras.models.Model\n",
    "    \"\"\"\n",
    "    def __init__(self, ndim : int, initial_containment : float = -0.1):\n",
    "        tf.keras.models.Model.__init__(self)\n",
    "\n",
    "        self.ndim = ndim\n",
    "\n",
    "\n",
    "        self.layer1 = tf.keras.layers.Dense(16, use_bias=False)\n",
    "        self.layer2 = tf.keras.layers.Dense(24, use_bias=False)\n",
    "        self.layer3 = tf.keras.layers.Dense(1, use_bias=False)\n",
    "\n",
    "        self.containment = tf.Variable(initial_containment, trainable = True)\n",
    "        \n",
    "    @tf.function\n",
    "    def call(self, inputs):\n",
    "        # \n",
    "        # shape is [nwalkers, dim]\n",
    "        \n",
    "        x = self.layer1(inputs)\n",
    "        x = tf.keras.activations.softplus(x)\n",
    "        # WHat is softplus?  It's like ReLU at large absolute value, but is smooth through 0.0\n",
    "        \n",
    "        x = self.layer2(x)\n",
    "        x = tf.keras.activations.softplus(x)\n",
    "\n",
    "        # Just one output:\n",
    "        x = self.layer3(x)\n",
    "        # x = tf.keras.activations.tanh(x)\n",
    "\n",
    "        # Compute the initial boundary condition, which the network will slowly overcome\n",
    "        # This is important because it keeps the walkers bounded, otherwise they will not converge to a bound state.\n",
    "        r = tf.sqrt(tf.reduce_sum(inputs**2, axis=1))\n",
    "        # We use the exponential to map the countainment to positive-only values while having a smooth gradient\n",
    "        boundary_condition = -tf.exp(self.containment) * r\n",
    "        boundary_condition = tf.reshape(boundary_condition, [-1,1])\n",
    "\n",
    "    \n",
    "        return x + boundary_condition\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ground_state = NeuralWavefunction(3, initial_containment = -0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metropolis Sampling\n",
    "\n",
    "To sample the wave function, we'll use the metropolis algorithm.  We can implement this algorithm in tensorflow as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class MetropolisSampler(object):\n",
    "    \"\"\"Metropolis Sampler in N dimension\n",
    "\n",
    "    Sample from N-D coordinates, using some initial probability distribution\n",
    "\n",
    "    Relies on functional calls to sample on the fly with flexible distributions\n",
    "    \"\"\"\n",
    "    def __init__(self,\n",
    "        n           : int,\n",
    "        nwalkers    : int,\n",
    "        initializer : callable,\n",
    "        init_params : iter ,\n",
    "        dtype       = tf.float64):\n",
    "        '''Initialize a metropolis sampler\n",
    "\n",
    "        Create a metropolis walker with `n` walkers.  Can use normal, uniform\n",
    "\n",
    "        Arguments:\n",
    "            n {int} -- Dimension\n",
    "            nwalkers {int} -- Number of unique walkers\n",
    "            initializer {callable} -- Function to call to initialize each walker\n",
    "            init_params {iter} -- Parameters to pass to the initializer, unrolled automatically\n",
    "        '''\n",
    "\n",
    "        # Set the dimension:\n",
    "        self.n = n\n",
    "\n",
    "        # Set the number of walkers:\n",
    "        self.nwalkers = nwalkers\n",
    "\n",
    "        self.size = (self.nwalkers, self.n)\n",
    "\n",
    "        self.dtype = dtype\n",
    "\n",
    "        #  Run the initalize to get the first locations:\n",
    "        self.walkers = initializer(shape=self.size, **init_params, dtype=dtype)\n",
    "\n",
    "    def sample(self):\n",
    "        '''Just return the current locations\n",
    "\n",
    "        '''\n",
    "        # Make sure to wrap in tf.Variable for back prop calculations\n",
    "        return  self.walkers\n",
    "\n",
    "    def kick(self,\n",
    "        wavefunction : tf.keras.models.Model,\n",
    "        kicker : callable,\n",
    "        kicker_params : iter,\n",
    "        nkicks : int ):\n",
    "        '''Wrapper for a compiled kick function via tensorflow.\n",
    "\n",
    "        This fills in the compiled function with the size and the walkers.\n",
    "\n",
    "        Arguments:\n",
    "            wavefunction {tf.keras.models.Model} -- The wavefunction used for the metropolis walk\n",
    "            kicker {callable} -- A callable function for generating kicks\n",
    "            kicker_params {iter} -- Arguments to the kicker function.\n",
    "        '''\n",
    "        # for i in range(nkicks):\n",
    "        walkers, acceptance = self.internal_kicker(\n",
    "            self.size, self.walkers, wavefunction, kicker, kicker_params, tf.constant(nkicks), dtype=self.dtype)\n",
    "\n",
    "        # Update the walkers:\n",
    "        self.walkers = walkers\n",
    "\n",
    "        # Send back the acceptance:\n",
    "        return acceptance\n",
    "\n",
    "    @tf.function\n",
    "    def internal_kicker(self,\n",
    "        _shape,\n",
    "        _walkers,\n",
    "        _wavefunction : tf.keras.models.Model,\n",
    "        _kicker : callable,\n",
    "        _kicker_params : iter,\n",
    "        _nkicks : tf.constant,\n",
    "        dtype):\n",
    "        \"\"\"Sample points in N-d Space\n",
    "\n",
    "        By default, samples points uniformly across all dimensions.\n",
    "        Returns a torch tensor on the chosen device with gradients enabled.\n",
    "\n",
    "        Keyword Arguments:\n",
    "            kicker {callable} -- Function to call to create a kick for each walker\n",
    "            kicker_params {iter} -- Parameters to pass to the kicker, unrolled automatically\n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "        # We need to compute the wave function twice:\n",
    "        # Once for the original coordiate, and again for the kicked coordinates\n",
    "        acceptance = tf.convert_to_tensor(0.0, dtype=dtype)\n",
    "        # Calculate the current wavefunction value:\n",
    "        current_wavefunction = _wavefunction(_walkers)\n",
    "\n",
    "        # Generate a long set of random number from which we will pull:\n",
    "        random_numbers = tf.math.log(tf.random.uniform(shape = [_nkicks,_shape[0],1], dtype=dtype))\n",
    "\n",
    "        # Generate a long list of kicks:\n",
    "        # print(shape)\n",
    "        kicks = _kicker(shape=[_nkicks, *_shape], **_kicker_params, dtype=dtype)\n",
    "        # print(kicks.shape)\n",
    "\n",
    "        for i_kick in tf.range(_nkicks):\n",
    "            # Create a kick:\n",
    "            kick = kicks[i_kick]\n",
    "            # kick = kicker(shape=shape, **kicker_params, dtype=dtype)\n",
    "            kicked = _walkers + kick\n",
    "\n",
    "            # Compute the values of the wave function, which should be of shape\n",
    "            # [nwalkers, 1]\n",
    "            kicked_wavefunction   = _wavefunction(kicked)\n",
    "\n",
    "\n",
    "            # Probability is the ratio of kicked **2 to original\n",
    "            probability = 2 * (kicked_wavefunction - current_wavefunction)\n",
    "            # Acceptance is whether the probability for that walker is greater than\n",
    "            # a random number between [0, 1).\n",
    "            # Pull the random numbers and create a boolean array\n",
    "            # accept      = probability >  tf.random.uniform(shape=[shape[0],1])\n",
    "            accept      = probability >  random_numbers[i_kick]\n",
    "            # accept      = probability >  tf.math.log(tf.random.uniform(shape=[shape[0],1]))\n",
    "\n",
    "            # Grab the kicked wavefunction in the places it is new, to speed up metropolis:\n",
    "            current_wavefunction = tf.where(accept, kicked_wavefunction, current_wavefunction)\n",
    "\n",
    "            # We need to broadcast accept to match the right shape\n",
    "            # Needs to come out to the shape [nwalkers, nparticles, ndim]\n",
    "            accept = tf.tile(accept, [1,tf.reduce_prod(_shape[1:])])\n",
    "            accept = tf.reshape(accept, _shape)\n",
    "            _walkers = tf.where(accept, kicked, _walkers)\n",
    "\n",
    "            acceptance = tf.reduce_mean(tf.cast(accept, dtype))\n",
    "\n",
    "        return _walkers, acceptance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a surrogate model and a sampling tool, we can test things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampler = MetropolisSampler(\n",
    "            n           = 3, # 3 dimensions\n",
    "            nwalkers    = N_WALKERS,\n",
    "            initializer = tf.random.normal,\n",
    "            init_params = {\"mean\": 0.0, \"stddev\" : 0.2},\n",
    "            dtype       = DEFAULT_TENSOR_TYPE\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ground_x = sampler.sample()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at X, we should see a 100 x 3 tensor.  Elements from the tensor should roughly follow a gaussian distribution since that's what we used to initialize it (mean 0, STD 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(500, 3)\n",
      "tf.Tensor(-0.0007899834, shape=(), dtype=float32)\n",
      "tf.Tensor(0.20141804, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(ground_x.shape)\n",
    "print(tf.reduce_mean(ground_x))\n",
    "print(tf.math.reduce_std(ground_x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can print a summary of the network, too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"neural_wavefunction\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                multiple                  48        \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              multiple                  384       \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              multiple                  24        \n",
      "=================================================================\n",
      "Total params: 457\n",
      "Trainable params: 457\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "(500, 1)\n"
     ]
    }
   ],
   "source": [
    "values = ground_state(ground_x)\n",
    "ground_state.summary()\n",
    "print(values.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the sum of all printed parameters is one short than the total number of trainable parameters.  That's because the confinement is also a trainable parameter!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thermalize the walkers\n",
    "\n",
    "To thermalize the walkers, we can \"kick\" them a number of times according to the metropolis algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acceptance:  tf.Tensor(0.894, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "r_before_thermalization = tf.sqrt(tf.reduce_sum(sampler.sample()**2, axis=1)).numpy()\n",
    "acceptance = sampler.kick(\n",
    "    wavefunction  = ground_state ,\n",
    "    kicker        = tf.random.normal,\n",
    "    kicker_params = {\"mean\": 0.0, \"stddev\" : 0.3},\n",
    "    nkicks        = 5000 )\n",
    "# This gets the latest walkers\n",
    "ground_x = sampler.sample()\n",
    "print(\"Acceptance: \", acceptance)\n",
    "r_after_thermalization = tf.sqrt(tf.reduce_sum(sampler.sample()**2, axis=1)).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(-2.8959866, shape=(), dtype=float32)\n",
      "tf.Tensor(5.0337768, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(tf.reduce_mean(ground_x))\n",
    "print(tf.math.reduce_std(ground_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean r before thermalization: 0.3224\n",
      "Mean r after thermalization: 7.1834\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = numpy.arange(0,10,0.5)\n",
    "\n",
    "print(f\"Mean r before thermalization: {tf.reduce_mean(r_before_thermalization):.4f}\")\n",
    "print(f\"Mean r after thermalization: {tf.reduce_mean(r_after_thermalization):.4f}\")\n",
    "\n",
    "before_hist, edges = numpy.histogram(r_before_thermalization, bins=bins)\n",
    "after_hist,  edges = numpy.histogram(r_after_thermalization, bins=bins)\n",
    "\n",
    "bin_centers = 0.5*(edges[1:] + edges[:-1])\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(16,9))\n",
    "plt.plot(bin_centers, before_hist, marker=\"+\", label=\"Before Therm.\")\n",
    "plt.plot(bin_centers, after_hist, marker=\"o\", label=\"After Therm.\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0.894, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(acceptance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hydrogen Atom Hamiltonian\n",
    "\n",
    "Here's an implementation of the hydrogen atom that computes observables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy\n",
    "\n",
    "import logging\n",
    "logger = logging.getLogger()\n",
    "\n",
    "\n",
    "class HydrogenAtom(object):\n",
    "    \"\"\"Harmonic Oscillator Potential\n",
    "\n",
    "    Implementation of the quantum harmonic oscillator hamiltonian\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        ''' Initialize the Hamiltonian\n",
    "\n",
    "        The derived class will check parameters, but this converts all of them to floats\n",
    "        and scores as TF Constants.\n",
    "\n",
    "        '''\n",
    "        object.__init__(self)\n",
    "        self.parameters = {\"mass\" : 1.0}\n",
    "        # Cast them all to tf constants:\n",
    "        for key in self.parameters:\n",
    "            self.parameters[key] = tf.constant(float(self.parameters[key]),dtype=DEFAULT_TENSOR_TYPE)\n",
    "\n",
    "        self.HBAR = tf.constant(1.0, dtype = DEFAULT_TENSOR_TYPE)\n",
    "        self.ELECTRON_CHARGE = tf.constant(1.0, dtype = DEFAULT_TENSOR_TYPE)\n",
    "\n",
    "\n",
    "    @tf.function\n",
    "    def energy(self, wavefunction : tf.keras.models.Model, inputs : tf.Tensor):\n",
    "        \"\"\"Compute the expectation value of energy of the supplied wavefunction.\n",
    "\n",
    "        Computes the integral of the wavefunction in this potential\n",
    "\n",
    "        Arguments:\n",
    "            wavefunction {Wavefunction model} -- Callable wavefunction object\n",
    "            inputs {tf.Tensor} -- Tensor of shape [nwalkers, nparticles, dimension]\n",
    "\n",
    "        Returns:\n",
    "            tf.tensor - energy of shape [n_walkers]\n",
    "            tf.tensor - energy_jf of shape [n_walkers]\n",
    "            tf.tensor - ke_jf of shape [n_walkers]\n",
    "            tf.tensor - ke_direct of shape [n_walkers]\n",
    "            tf.tensor - pe of shape [n_walkers]\n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "        # This function takes the inputs\n",
    "        # And computes the expectation value of the energy at each input point\n",
    "\n",
    "        logw_of_x, dlogw_dx, d2logw_dx2 = self.compute_derivatives(wavefunction, inputs)\n",
    "\n",
    "        pe, ke_jf, ke_direct = self.compute_energies(inputs, logw_of_x, dlogw_dx, d2logw_dx2)\n",
    "\n",
    "        # Total energy computations:\n",
    "        energy = tf.squeeze(pe+ke_direct)\n",
    "        energy_jf = tf.squeeze(pe+ke_jf)\n",
    "\n",
    "        return energy, energy_jf, ke_jf, ke_direct, pe\n",
    "\n",
    "    \n",
    "    @tf.function\n",
    "    def compute_derivatives(self, wavefunction : tf.keras.models.Model, inputs : tf.Tensor):\n",
    "\n",
    "\n",
    "        # Turning off all tape watching except for the inputs:\n",
    "        # Using the outer-most tape to watch the computation of the first derivative:\n",
    "        with tf.GradientTape(persistent=True) as tape:\n",
    "            # Use the inner tape to watch the computation of the wavefunction:\n",
    "            tape.watch(inputs)\n",
    "            with tf.GradientTape() as second_tape:\n",
    "                second_tape.watch(inputs)\n",
    "                logw_of_x = wavefunction(inputs, training=True)\n",
    "            # Get the derivative of logw_of_x with respect to inputs\n",
    "            dlogw_dx = second_tape.gradient(logw_of_x, inputs)\n",
    "\n",
    "        # Get the derivative of dlogw_dx with respect to inputs (aka second derivative)\n",
    "\n",
    "        # We have to extract the diagonal of the jacobian, which comes out with shape\n",
    "        # [nwalkers, dimension, dimension]\n",
    "\n",
    "        # This is the full hessian computation:\n",
    "        d2logw_dx2 = tape.batch_jacobian(dlogw_dx, inputs)\n",
    "\n",
    "        \n",
    "        # And this contracts:\n",
    "        d2logw_dx2 = tf.einsum(\"wdd->wd\",d2logw_dx2)\n",
    "\n",
    "        return logw_of_x, dlogw_dx, d2logw_dx2\n",
    "    \n",
    "    @tf.function\n",
    "    def potential_energy(self, *, inputs, Z):\n",
    "        \"\"\"Return potential energy\n",
    "\n",
    "        If the potential energy is already computed, and no arguments are supplied,\n",
    "        return the cached value\n",
    "\n",
    "        If all arguments are supplied, calculate and return the PE.\n",
    "\n",
    "        Otherwise, exception\n",
    "\n",
    "        Arguments:\n",
    "            inputs {tf.tensor} -- Tensor of shape [N, nparticles, dimension]\n",
    "            Z {tf.tensor} -- Atomic number\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor - potential energy of shape [1]\n",
    "        \"\"\"\n",
    "\n",
    "        # Potential energy is, for n particles, two pieces:\n",
    "        # Compute r_i, where r_i = sqrt(sum(x_i^2, y_i^2, z_i^2)) (in 3D)\n",
    "        # PE_1 = -(Z e^2)/(4 pi eps_0) * sum_i (1/r_i)\n",
    "        # Compute r\n",
    "        # Square the coordinates and sum for each walker\n",
    "        r = tf.math.sqrt(tf.reduce_sum(inputs**2, axis=1))\n",
    "        # This is the sum of 1/r for all particles with the nucleus:\n",
    "        pe_1 = - (Z * self.ELECTRON_CHARGE**2 ) *  1. / (r + 1e-8)\n",
    "\n",
    "        return pe_1\n",
    "    \n",
    "    @tf.function\n",
    "    def kinetic_energy_jf(self, *, dlogw_dx, M):\n",
    "        \"\"\"Return Kinetic energy\n",
    "\n",
    "        Calculate and return the KE directly\n",
    "\n",
    "        Otherwise, exception\n",
    "\n",
    "        Arguments:\n",
    "            dlogw_of_x/dx {tf.Tensor} -- Computed derivative of the wavefunction\n",
    "\n",
    "        Returns:\n",
    "            tf.Tensor - kinetic energy (JF) of shape [1]\n",
    "        \"\"\"\n",
    "        # < x | KE | psi > / < x | psi > =  1 / 2m [ < x | p | psi > / < x | psi >\n",
    "\n",
    "        # Contract d2_w_dx over spatial dimensions and particles:\n",
    "        ke_jf = (self.HBAR**2 / (2 * M)) * tf.reduce_sum(dlogw_dx**2, axis=(1))\n",
    "\n",
    "        return ke_jf\n",
    "\n",
    "    @tf.function\n",
    "    def kinetic_energy(self, *, KE_JF : tf.Tensor, d2logw_dx2 : tf.Tensor, M):\n",
    "        \"\"\"Return Kinetic energy\n",
    "\n",
    "\n",
    "        If all arguments are supplied, calculate and return the KE.\n",
    "\n",
    "        Arguments:\n",
    "            d2logw_dx2 {tf.Tensor} -- Computed second derivative of the wavefunction\n",
    "            KE_JF {tf.Tensor} -- JF computation of the kinetic energy\n",
    "\n",
    "        Returns:\n",
    "            tf.Tensor - potential energy of shape [1]\n",
    "        \"\"\"\n",
    "\n",
    "        ke = -(self.HBAR**2 / (2 * M)) * tf.reduce_sum(d2logw_dx2, axis=(1))\n",
    "        ke = ke  - KE_JF\n",
    "\n",
    "        return ke\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    @tf.function\n",
    "    def compute_energies(self, inputs, logw_of_x, dlogw_dx, d2logw_dx2):\n",
    "        '''Compute PE, KE_JF, and KE_direct\n",
    "\n",
    "        Harmonic Oscillator Energy Calculations\n",
    "\n",
    "        Arguments:\n",
    "            inputs {[type]} -- walker coordinates (shape is [nwalkers, nparticles, dimension])\n",
    "            logw_of_x {[type]} -- computed wave function at each walker\n",
    "            dlogw_dx {[type]} -- first derivative of wavefunction at each walker\n",
    "            d2logw_dx2 {[type]} -- second derivative of wavefunction at each walker\n",
    "\n",
    "        Raises:\n",
    "            NotImplementedError -- [description]\n",
    "\n",
    "        Returns:\n",
    "            pe -- potential energy\n",
    "            ke_jf -- JF Kinetic energy\n",
    "            ke_direct -- 2nd deriv computation of potential energy\n",
    "        '''\n",
    "\n",
    "        # Potential energy depends only on the wavefunction\n",
    "        pe = self.potential_energy(inputs=inputs, Z=1)\n",
    "\n",
    "        # KE by parts needs only one derivative\n",
    "        ke_jf = self.kinetic_energy_jf(dlogw_dx=dlogw_dx, M=self.parameters[\"mass\"])\n",
    "\n",
    "        # True, directly, uses the second derivative\n",
    "        ke_direct = self.kinetic_energy(KE_JF = ke_jf, d2logw_dx2 = d2logw_dx2, M=self.parameters[\"mass\"])\n",
    "\n",
    "\n",
    "        return pe, ke_jf, ke_direct\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "hamiltonian = HydrogenAtom()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "energy, energy_jf, ke_jf, ke_direct, pe = hamiltonian.energy(ground_state, ground_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(-0.24749391, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(tf.reduce_mean(energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the units we're using (atomic units) the value of the hydrogen ground state comes out to -0.5.  So, this is good: the energy is above the ground state for our random wavefunction which is good!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizing the wavefunction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To optimize the wavefunction, we'll need to compute several observables based on the jacobian.  Here are some functions to help contained within a `compute_gradients` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gradients(N_OBSERVATIONS, _sampler, _wavefunction, _hamiltonian):\n",
    "\n",
    "    # Helper function to compute jacobians:\n",
    "    @tf.function\n",
    "    def jacobian(j_x_current, j_wavefunction):\n",
    "        tape = tf.GradientTape()\n",
    "\n",
    "        with tape:\n",
    "            tape.watch(j_wavefunction.trainable_variables)\n",
    "            log_wpsi = j_wavefunction(j_x_current)\n",
    "\n",
    "    #     print(log_wpsi)\n",
    "\n",
    "\n",
    "        jac = tape.jacobian(log_wpsi, j_wavefunction.trainable_variables)\n",
    "\n",
    "    #     print(wavefunction.trainable_variables)\n",
    "    #     print(jac)\n",
    "\n",
    "        # Grab the original shapes ([1:] means everything except first dim):\n",
    "        jac_shape = [j.shape[1:] for j in jac]\n",
    "        # get the flattened shapes:\n",
    "        flat_shape = [[-1, tf.reduce_prod(js)] for js in jac_shape]\n",
    "        # Reshape the\n",
    "\n",
    "        # We have the flat shapes and now we need to make the jacobian into a single matrix\n",
    "\n",
    "        flattened_jacobian = [tf.reshape(j, f) for j, f in zip(jac, flat_shape)]\n",
    "\n",
    "        flattened_jacobian = tf.concat(flattened_jacobian, axis=-1)\n",
    "\n",
    "        return flattened_jacobian, flat_shape\n",
    "\n",
    "\n",
    "    # Helper function to compute observables:\n",
    "    @tf.function\n",
    "    def compute_O_observables(flattened_jacobian, energy):\n",
    "\n",
    "        # dspi_i is the reduction of the jacobian over all walkers.\n",
    "        # In other words, it's the mean gradient of the parameters with respect to inputs.\n",
    "        # This is effectively the measurement of O^i in the paper.\n",
    "        dpsi_i = tf.reduce_mean(flattened_jacobian, axis=0)\n",
    "        dpsi_i = tf.reshape(dpsi_i, [-1,1])\n",
    "\n",
    "        # To compute <O^m O^n>\n",
    "        dpsi_ij = tf.linalg.matmul(flattened_jacobian, flattened_jacobian, transpose_a = True) / N_WALKERS\n",
    "        \n",
    "        # Computing <O^m H>:\n",
    "        dpsi_i_EL = tf.linalg.matmul(tf.reshape(energy, [1,N_WALKERS]), flattened_jacobian)\n",
    "        # This makes this the same shape as the other tensors\n",
    "        dpsi_i_EL = tf.reshape(dpsi_i_EL, [-1, 1])\n",
    "\n",
    "        return dpsi_i, dpsi_i_EL, dpsi_ij\n",
    "\n",
    "    \n",
    "#     @tf.function(experimental_relax_shapes=True)\n",
    "    def compute_SR_gradients(crs_energy, csr_dpsi_i, csr_dpsi_i_EL, csr_dpsi_ij):\n",
    "        \n",
    "        eps = 0.001\n",
    "        npt = csr_dpsi_i.shape[0]\n",
    "    \n",
    "        # These are the first order gradients:\n",
    "        gradients = tf.cast(( csr_dpsi_i * crs_energy - csr_dpsi_i_EL ), tf.float64)\n",
    "\n",
    "        # For the matrix inversion, we want to use higher precision:\n",
    "        S_ij = tf.cast(csr_dpsi_ij - csr_dpsi_i * tf.transpose(csr_dpsi_i), tf.float64)\n",
    "        \n",
    "        # We loop until the inversion comes out positive definite:\n",
    "        i = 0\n",
    "        while True:\n",
    "            S_ij_d = S_ij + 2**i * eps * tf.eye(npt, dtype=tf.float64)\n",
    "            i += 1\n",
    "            try:\n",
    "                U_ij = tf.linalg.cholesky(S_ij_d)\n",
    "                positive_definite = True\n",
    "            except:\n",
    "                positive_definite = False\n",
    "                print(f\"Cholesky solve did not find a positive definite matrix on attempt {i}!\")\n",
    "            \n",
    "            if positive_definite:\n",
    "                gradients = tf.linalg.cholesky_solve(U_ij, gradients)\n",
    "                \n",
    "                break\n",
    "                \n",
    "        return tf.cast(gradients, tf.float32)\n",
    "    \n",
    "    # Places to accumulate observables:\n",
    "    dpsi_i    = None\n",
    "    dpsi_i_EL = None\n",
    "    dpsi_ij   = None\n",
    "    obs_energy = 0\n",
    "    \n",
    "    for i_obs in range(N_OBSERVATIONS):\n",
    "    \n",
    "        # First, we kick the sampler to re-thermalize to the new wavefunction:\n",
    "        kicker = tf.random.normal\n",
    "        kicker_params = {\"mean\": 0.0, \"stddev\" : 0.4}\n",
    "\n",
    "        acceptance = _sampler.kick(_wavefunction, kicker, kicker_params, nkicks=100)\n",
    "\n",
    "\n",
    "        # Get the current walker locations:\n",
    "        x_current  = _sampler.sample()\n",
    "\n",
    "        # Compute the observables:\n",
    "        energy, energy_jf, ke_jf, ke_direct, pe = hamiltonian.energy(_wavefunction, x_current)\n",
    "\n",
    "        energy /= N_WALKERS\n",
    "\n",
    "\n",
    "        # For each observation, we compute the jacobian.\n",
    "        # flattened_jacobian is a list, flat_shape is just one instance\n",
    "        flattened_jacobian, flat_shape = jacobian(x_current, _wavefunction)\n",
    "\n",
    "        _dpsi_i, _dpsi_i_EL, _dpsi_ij = compute_O_observables(flattened_jacobian, energy)\n",
    "        if dpsi_i is None:\n",
    "            dpsi_i = _dpsi_i\n",
    "        else:\n",
    "            dpsi_i += _dpsi_i\n",
    "            \n",
    "        if dpsi_i_EL is None:\n",
    "            dpsi_i_EL = _dpsi_i_EL\n",
    "        else:\n",
    "            dpsi_i_EL += _dpsi_i_EL\n",
    "\n",
    "        if dpsi_ij is None:\n",
    "            dpsi_ij = _dpsi_ij\n",
    "        else:\n",
    "            dpsi_ij += _dpsi_ij\n",
    "\n",
    "        obs_energy += tf.reduce_sum(energy)\n",
    "        \n",
    "    obs_energy /= N_OBSERVATIONS\n",
    "    dpsi_i     /= N_OBSERVATIONS\n",
    "    dpsi_i_EL  /= N_OBSERVATIONS\n",
    "    dpsi_ij    /= N_OBSERVATIONS\n",
    "    \n",
    "    \n",
    "    gradients = compute_SR_gradients(obs_energy, dpsi_i, dpsi_i_EL, dpsi_ij)\n",
    "    \n",
    "\n",
    "    # Lastly, reshape the gradients to match the weights:\n",
    "    running_index = 0\n",
    "    gradient = []\n",
    "    for length in flat_shape:\n",
    "        l = length[-1]\n",
    "        end_index = running_index + l\n",
    "        gradient.append(gradients[running_index:end_index])\n",
    "        running_index += l\n",
    "    \n",
    "    shapes = [ p.shape for p in _wavefunction.trainable_variables ]\n",
    "    gradients = [ tf.reshape(g, s) for g, s in zip(gradient, shapes)]\n",
    "    return gradients, obs_energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimizer = tf.keras.optimizers.Adam()\n",
    "energy_history = []\n",
    "steps_history  = []\n",
    "LEARNING_RATE  = 0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "# Define a figure here which we can update along the way:\n",
    "fig       = plt.figure(figsize=(16,9))\n",
    "# Create 2x2 sub plots\n",
    "gs = gridspec.GridSpec(2, 2)\n",
    "ax_loss   = plt.subplot(gs[:,0])\n",
    "ax_denst  = plt.subplot(gs[:,1], projection=\"3d\")\n",
    "\n",
    "\n",
    "\n",
    "for i in range(5):\n",
    "    \n",
    "    gradients, energy = compute_gradients(N_OBSERVATIONS, sampler, ground_state, hamiltonian)\n",
    "    \n",
    "    # Scale by the learning rate\n",
    "    gradients = [LEARNING_RATE * g for g in gradients ]\n",
    "        \n",
    "    for i_param in range(len(ground_state.trainable_variables)):\n",
    "        ground_state.trainable_variables[i_param].assign_add(gradients[i_param])\n",
    "\n",
    "    \n",
    "    energy_history.append(energy)\n",
    "    steps_history.append(i)\n",
    "\n",
    "    # Here we update the plots.  Show the energy function:\n",
    "    ax_loss.set_xlim(0, 1.1*i)\n",
    "    ax_loss.cla()\n",
    "    ax_loss.plot(steps_history, energy_history, label=\"Energy\")\n",
    "    ax_loss.grid(True)\n",
    "    ax_loss.legend(fontsize=25)\n",
    "\n",
    "    # Show the location of the walkers:\n",
    "    x, y, z = tf.split(sampler.sample(), 3, axis=1)\n",
    "    ax_denst.clear()\n",
    "    ax_denst.set_xlim(-4,4); ax_denst.set_ylim(-4,4); ax_denst.set_zlim(-4,4);\n",
    "    ax_denst.set_xlabel(\"X\"); ax_denst.set_ylabel(\"Y\"); ax_denst.set_zlabel(\"Z\");\n",
    "    ax_denst.scatter(x, y, z, linewidth=0.5);\n",
    "\n",
    "    display(fig)\n",
    "    clear_output(wait = True)\n",
    "#     plt.pause(0.25)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf.keras.models.save_model(ground_state, \"HydrogenGroundState\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can take a while to converge.  If you are running on, say, a CPU or just don't want to wait, you can access my pretrained model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.\n",
      "tf.Tensor(-0.49790815, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "ground_state = tf.keras.models.load_model(\"saved_models/HydrogenGroundState\")\n",
    "kicker = tf.random.normal\n",
    "kicker_params = {\"mean\": 0.0, \"stddev\" : 0.4}\n",
    "\n",
    "acceptance = sampler.kick(ground_state, kicker, kicker_params, nkicks=2000)\n",
    "x = sampler.sample()\n",
    "energy, energy_jf, ke_jf, ke_direct, pe = hamiltonian.energy(ground_state, x)\n",
    "print(tf.reduce_mean(energy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.011789099>\n"
     ]
    }
   ],
   "source": [
    "print(ground_state.containment) # (If you load my model, this should be 0.011789099)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excited states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to compute the first excited state of hydrogen?  We can do that if we have the ground state and we're happy with that!  We'll follow a procedure outlined in this paper: [https://arxiv.org/pdf/1807.03325.pdf](https://arxiv.org/pdf/1807.03325.pdf) (starting with eq. 10).  First, define the ground state which we've solved:\n",
    "\n",
    "$|\\phi_0> $== Ground state solution\n",
    "\n",
    "And, we will define the excited state as:\n",
    "\n",
    "$|\\psi> = |\\phi_1> - \\lambda |\\phi_0>$, where $|\\phi_1>$ is a similar variational function as our ground state function.  If we set $\\lambda$ to:\n",
    "\n",
    "$\\lambda = \\frac{<\\phi_0| \\phi_1>}{<\\phi_0 | \\phi_0 >}$ then you can quickly check that, by definition, $<\\psi | \\phi_0> $ is exactly 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi_1 = NeuralWavefunction(3, initial_containment = 0.2)\n",
    "x = sampler.sample()\n",
    "# Do a forward pass to initialize it, inputs don't really matter:\n",
    "_ = phi_1(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each iteration, we compute lambda, and then perform normal stochastic reconfiguration on this state.  We _freeze_ the ground state (see below) so that it and it's parameters don't enter into the optimization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this, we are able to compute psi as well.  Let's see what the initial energy is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "class ExcitedNeuralWavefunction(tf.keras.models.Model):\n",
    "    \"\"\"Create a neural network eave function in N dimensions\n",
    "\n",
    "    Boundary condition, if not supplied, is gaussian in every dimension\n",
    "\n",
    "    Extends:\n",
    "        tf.keras.models.Model\n",
    "    \"\"\"\n",
    "    def __init__(self, \n",
    "                 ndim : int, \n",
    "                 gs   : tf.keras.models.Model, \n",
    "                 phi1 : tf.keras.models.Model):\n",
    "        tf.keras.models.Model.__init__(self)\n",
    "\n",
    "        self.ndim = ndim\n",
    "        \n",
    "#         self.ground_state = ground_state\n",
    "        \n",
    "        self.gs = copy.copy(gs)\n",
    "        self.gs.trainable = False\n",
    "        \n",
    "        self.phi1 = phi1\n",
    "    \n",
    "        self.LAMBDA = 0.0\n",
    "\n",
    "    def compute_lambda(self, inputs):\n",
    "        phi1_values = self.phi1(inputs)\n",
    "        \n",
    "        gs_values = self.gs(inputs)\n",
    "\n",
    "        # Remember that we parametrize the LOG of the wavefunction!\n",
    "        # (I made this error making the notebook and it took forever to debug!!)\n",
    "        \n",
    "        self.LAMBDA = tf.reduce_mean(tf.exp(phi1_values -  gs_values))\n",
    "        \n",
    "#     @tf.function\n",
    "    def call(self, inputs):\n",
    "        # shape is [nwalkers, dim]\n",
    "        \n",
    "        phi1_values = self.phi1(inputs)\n",
    "        \n",
    "        gs_values = self.gs(inputs)\n",
    "\n",
    "\n",
    "        return tf.math.log(tf.exp(phi1_values) -  self.LAMBDA* tf.exp(gs_values) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "excited_state = ExcitedNeuralWavefunction(3, ground_state , phi_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x = sampler.sample()\n",
    "\n",
    "# Run the forward pass\n",
    "_ = excited_state(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"excited_neural_wavefunction\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "neural_wavefunction (NeuralW multiple                  457       \n",
      "_________________________________________________________________\n",
      "neural_wavefunction_1 (Neura multiple                  457       \n",
      "=================================================================\n",
      "Total params: 914\n",
      "Trainable params: 457\n",
      "Non-trainable params: 457\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "excited_state.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice here that we have two networks, but one is not trainable.  Excellent!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ground acceptance: 0.8420\n",
      "Excited acceptance: 0.7220\n"
     ]
    }
   ],
   "source": [
    "# We compute lambda based on the psi_0 walkers:\n",
    "g_acceptance = sampler.kick(\n",
    "    wavefunction  = ground_state,\n",
    "    kicker        = tf.random.normal,\n",
    "    kicker_params = {\"mean\": 0.0, \"stddev\" : 0.2},\n",
    "    nkicks        = 5000 )\n",
    "ground_x = sampler.sample()\n",
    "excited_state.compute_lambda(ground_x)\n",
    "\n",
    "# We should compute the energy based on the excited state's walkers:\n",
    "excited_sampler = MetropolisSampler(\n",
    "            n           = 3, # 3 dimensions\n",
    "            nwalkers    = N_WALKERS,\n",
    "            initializer = tf.random.normal,\n",
    "            init_params = {\"mean\": 0.0, \"stddev\" : 0.2},\n",
    "            dtype       = DEFAULT_TENSOR_TYPE\n",
    "    )\n",
    "\n",
    "e_acceptance = acceptance = excited_sampler.kick(\n",
    "    wavefunction  = excited_state,\n",
    "    kicker        = tf.random.normal,\n",
    "    kicker_params = {\"mean\": 0.0, \"stddev\" : 0.2},\n",
    "    nkicks        = 5000 )\n",
    "# This gets the latest walkers\n",
    "excited_x = excited_sampler.sample()\n",
    "\n",
    "print(f\"Ground acceptance: {g_acceptance:.4f}\")\n",
    "print(f\"Excited acceptance: {e_acceptance:.4f}\")\n",
    "\n",
    "energy, energy_jf, ke_jf, ke_direct, pe = hamiltonian.energy(excited_state, excited_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(0.59665126, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(tf.reduce_mean(energy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(3.069304, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print(excited_state.LAMBDA)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are the states orthogonal?  An easy check we can do is to compute the average ratio between the excited state and the ground state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratio is: nan\n"
     ]
    }
   ],
   "source": [
    "ratio = tf.reduce_mean(tf.exp(excited_state(ground_x) - ground_state(ground_x) ))\n",
    "print(f\"Ratio is: {ratio:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Where are the walkers?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worthwile to make sure that our excited state walkers are still in roughtly the right spot.  If the walkers diverge too much, that's a bad sign..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean r for the ground state: 1.5488\n",
      "Mean r for the excited state: 1.1282\n",
      "[ 40 119 112  99  64  28  22   7   2   5   2   0   0   0   0   0   0   0\n",
      "   0   0   0   0   0   0   0   0   0   0   0]\n",
      "[149 201  60  18  14  15   9   5   8   6   7   4   2   1   1   0   0   0\n",
      "   0   0   0   0   0   0   0   0   0   0   0]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAIICAYAAACW1EjCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dfbSdVXk36t8UECJJ+e4+1FAS30F9ISGA2VI4Vkik+NEKqKMSaesA8TRoUVte66mWMxBp6Uupldb6BVULb0tJIigora0U2aXaQElSSPkQRbCaQiEkNhAhQGCeP/ZOSMgOyf6cybOva4w91l5zPWvNe+UWyM/7Wc8qtdYAAABACy9pXQAAAAATl1AKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDO7ti4gSfbff/86bdq0cd3zJz/5Sfbcc89x3ZOxo5/doZfdoZfdoZfdoZfdoZfdMVF6uXTp0kdrrQcM9tgOEUqnTZuWJUuWjOuefX19mTNnzrjuydjRz+7Qy+7Qy+7Qy+7Qy+7Qy+6YKL0spfzH1h5z+i4AAADNCKUAAAA0I5QCAADQzA7xmVIAAICheuaZZ7JixYqsW7eudSnDttdee+Wee+5pXcao2WOPPTJ16tTstttu2/0coRQAANgprVixIlOmTMm0adNSSmldzrA8/vjjmTJlSusyRkWtNatWrcqKFSsyffr07X6e03cBAICd0rp167LffvvttIG0a0op2W+//YY8uRZKAQCAnZZAumMZTj+EUgAAgGF6+OGH86u/+qt5xStekdmzZ+fYY4/NV77ylXGvY9q0aXn00Ue3WP/iF7+Yww8/PLNmzcrMmTNz3XXXJUkuv/zyPPjgg9t83e09biSEUgAAgGGoteYtb3lLjjvuuNx///1ZunRpFixYkBUrVmxx7Pr168e9vhUrVuTCCy/Mt771rSxfvjy33HJLZs2alUQoBQAAaGLepYsz79LFo/Ja3/zmN/PSl74073nPezauHXzwwXn/+9+fpD/Qvf3tb89JJ52U17/+9am15kMf+lBmzpyZww8/PAsXLkyS9PX15c1vfvPG13jf+96Xyy+/PEn/BPSjH/1oXvWqV+Xwww/Pd77znSTJqlWr8vrXvz5HHXVUzjrrrNRat6jvkUceyZQpUzJ58uQkyeTJkzN9+vRcffXVWbJkSX7t134tRx55ZJ588slccMEFefWrX52ZM2dm/vz5qbUOetzSpUtz/PHHZ/bs2XnDG96Qhx56aMR/jkIpAADAMNx111151ate9aLHLF68OFdccUW++c1v5stf/nJuv/323HHHHfnHf/zHfOhDH8p//dd/bXOf/fffP8uWLct73/vefPzjH0+SfOxjH8sv/MIv5N/+7d9y8skn54c//OEWzzviiCPS09OT6dOn513vele+9rWvJUl+5Vd+Jb29vbnyyitz++23Z9KkSXnf+96X2267LXfeeWeefPLJXH/99Vsct+uuu+b9739/rr766ixdujRnnnlmzj333GH8yW3OV8IAAACdt2E6eusDqze7v/CsY0dtj7PPPjvf+ta38tKXvjS33XZbkuTEE0/MvvvumyT51re+ldNOOy277LJLenp6cvzxx2fZsmXp6el50dd929veliSZPXt2vvzlLydJbr755o2///Iv/3L22WefLZ63yy675O///u9z22235cYbb8w555yTpUuX5vzzz9/i2JtuuikXX3xxnnjiiaxevTozZszISSedtNkx9957b+68886ceOKJSZJnn302Bx544BD+hAYnlAIAAAzDjBkzcs0112y8/+lPfzqPPvpoent7N67tueeeG38f7BTbJNl1113z3HPPbbz/wq9U2X333ZP0h8xNP5u6PVe6LaXk6KOPztFHH50TTzwx73rXu7YIpevWrctv/uZvZsmSJTnooINy/vnnD/q1LrXWzJgxI4sXj87pzxs4fRcAAOi8hWcdm4VnHZufn75vfn76vhvvj8TrXve6rFu3Lp/97Gc3rj3xxBNbPf64447LwoUL8+yzz2blypW5+eabM3v27Bx88MG5++6789RTT2XNmjW58cYbt7n3cccdlyuvvDJJ8vWvfz0//vGPtzjmwQcfzLJlyzbev/3223PwwQcnSaZMmZLHH388yfMheP/998/atWtz9dVXb3zOpse98pWvzMqVKzeG0meeeSZ33XXXNmvdFpNSAACAYSil5Nprr80555yTiy++OAcccED23HPP/NEf/dGgx7/1rW/N4sWLc8QRR6SUkosvvjg9PT2ZMmVKTj311MyaNSuHHHJIjjrqqG3u/dGPfjSnnXZaXvWqV+X444/Pz/7sz25xzDPPPJPf+Z3fyYMPPpg99tgjBxxwQD73uc8lSc4444y85z3vyaRJk7J48eL8xm/8Rg4//PBMmzYtr371qze+xguPu/rqq/OBD3wga9asyfr16/Pbv/3bmTFjxjD/BPuVrY2Qx1Nvb29dsmTJuO7Z19eXOXPmjOuejB397A697A697A697A697A697HfPPffk0EMPbV3GiDz++OOZMmVK6zJG1WB9KaUsrbX2Dna803cBAABoRigFAACgGaEUAACAZoTSHd3yRcklM5Pz9+6/Xb6odUUAAACjZpuhtJRyUCnlplLKPaWUu0opvzWwvm8p5YZSyvcGbvfZ5DkfKaXcV0q5t5TyhrF8A522fFHytQ8ka36UpPbffu0DgikAANAZ2zMpXZ/kg7XWQ5Mck+TsUsphST6c5MZa6yFJbhy4n4HH3pFkRpI3JvlMKWWXsSi+8268IHnmyc3Xnnmyfx0AAKADthlKa60P1VqXDfz+eJJ7krw8ySlJrhg47Iokbxn4/ZQkC2qtT9VaH0hyX5KjR7vwCWHNiqGtAwAA42qXXXbJkUceufHnoosuGvJrfPWrX934vGuvvTZ33333kF9j8uTJg65feOGFmTFjRmbNmpUjjzwyt956a5LkT//0T/PEE09s83W397iR2HUoB5dSpiU5KsmtSXpqrQ8l/cG1lPLTA4e9PMktmzxtxcAaQ7XX1IFTdwdZBwAAmps0aVJuv/32Eb3GySefnJNPPjlJfyh985vfnMMOO2zEtS1evDjXX399li1blt133z2PPvponn766ST9YfPXf/3X87KXvexFX2N7jxuJ7Q6lpZTJSa5J8tu11sdKKVs9dJC1OsjrzU8yP0l6enrS19e3vaWMirVr1477nkP2P3+/P5TW555fKy9J9joo2dFrH2c7RT/ZLnrZHXrZHXrZHXrZHXrZb6+99srjjz++3cfves9Xsvs/X5Ty+IOpU34mT732w1l/6FtHXMcLa1izZk3mzp2bhQsX5pBDDsm73vWuHH/88TnjjDNyww035IILLsizzz6b/fbbL9dee20+97nPZdmyZTn11FNz3XXXpa+vLxdccEH+6q/+KknywQ9+MKtWrcqkSZPy53/+5/m5n/u5/OAHP8i73/3urF+/Pr/4i784aB33339/9t577zz99NN5+umns/vuu2f33XfPxRdfnAcffDDHH3989ttvv/zt3/5tzjnnnCxbtixPPvlkTjnllJx77rn57Gc/u8VxN954Y/7wD/8wTz/9dKZPn57PfOYzW0xp161bN7T/fdZat/mTZLck/5Dkf22ydm+SAwd+PzDJvQO/fyTJRzY57h+SHPtirz979uw63m666aZx33NY7lhY6ydm1PrRvfpv71jYuqId0k7TT7ZJL7tDL7tDL7tDL7tDL/vdfffd23/wHQtr/YOeWj/6U8///EHPiP9+/ZKXvKQeccQRG38WLFhQa631G9/4Rj3mmGPqVVddVd/whjfUWmt95JFH6tSpU+v9999fa6111apV9bHHHqt/+Zd/Wc8+++xaa62nn356/dKXvrTx9V/3utfV7373u7XWWm+55ZY6d+7cWmutJ510Ur3iiitqrbV+6lOfqnvuuecWtT3++OP1iCOOqIccckh973vfW/v6+jY+dvDBB9eVK1duvL9q1apaa63r16+vxx9/fL3jjju2OG7lypX1ta99bV27dm2ttdaLLrqofuxjH9ti38H6kmRJ3Uoe3OaktPSPRL+Q5J5a6yc2eeirSU5PctHA7XWbrP9NKeUTSX4mySFJ/nX7YzKbmXVq/w8AADB8L3YR0RH8fXtrp++eeOKJ+dKXvpSzzz47d9xxR5LklltuyXHHHZfp06cnSfbdd98XnfSuXbs2//Iv/5K3v/3tG9eeeuqpJMm3v/3tXHPNNUmSd77znfnd3/3dLZ4/efLkLF26NP/8z/+cm266KfPmzctFF12UM844Y4tjFy1alMsuuyzr16/PQw89lLvvvjuzZs3a7Jhbbrkld999d17zmtckSZ5++ukce+yxL/bHs1225/Td1yR5Z5J/L6Vs+NP+vfSH0UWllHcn+WGStydJrfWuUsqiJHen/8q9Z9danx1xpQAAAMM1zhcRfe6553LPPfdk0qRJWb16daZOnZpaa17kY5CDvsbee++91c+sbs9r7bLLLpkzZ07mzJmTww8/PFdcccUWofSBBx7Ixz/+8dx2223ZZ599csYZZ2TdunVbvFatNSeeeGKuuuqq7X4P22N7rr77rVprqbXOqrUeOfDzd7XWVbXWE2qthwzcrt7kORfWWv9HrfWVtdavj2rFAAAAQ7W1i4WO0UVEL7nkkhx66KG56qqrcuaZZ+aZZ57Jsccem3/6p3/KAw88kCRZvXr1Fs+bMmXKxunpT/3UT2X69On50pe+lKQ/FG6Yur7mNa/JggULkiRXXnnloDXce++9+d73vrfx/u23356DDz54i30ee+yx7Lnnntlrr73y8MMP5+tffz7CbXrcMccck29/+9u57777kiRPPPFEvvvd7w7zT+h52/M9pQAAADu3E85Ldpu0+dpuk/rXR+DJJ5/c7CthPvzhD+e73/1uPv/5z+dP/uRP8trXvjbHHXdc/uAP/iAHHHBALrvssrztbW/LEUcckXnz5m3xeu94xzvyx3/8xznqqKPy/e9/P1deeWW+8IUv5IgjjsiMGTNy3XX9n5r8sz/7s3z605/Oq1/96qxZs2bQ2tauXZvTTz89hx12WGbNmpW77747559/fpJk/vz5edOb3pS5c+fmiCOOyFFHHZUZM2bkzDPP3Hh67guPO+CAA3L55ZfntNNOy6xZs3LMMcfkO9/5zoj+/JKk9H/mtK3e3t66ZMmScd2zr68vc+bMGdc9GTv62R162R162R162R162R162e+ee+7JoYceuv1PWL6o/zOka1b0T0hPOK/59Vsef/zxTJkypWkNo22wvpRSltZaewc7fkjfUwoAALDTchHRHZLTdwEAAGhGKAUAAKAZoRQAANhp7QjXyOF5w+mHUAoAAOyU9thjj6xatUow3UHUWrNq1arsscceQ3qeCx0BAAA7palTp2bFihVZuXJl61KGbd26dUMOcTuyPfbYI1OnDu27X4VSAABgp7Tbbrtl+vTprcsYkb6+vhx11FGty2jK6bsAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0s81QWkr5YinlkVLKnZusLSyl3D7w84NSyu0D69NKKU9u8tjnxrJ4AAAAdm67bscxlyf5VJL/s2Gh1jpvw++llD9JsmaT479faz1ytAoEAACgu7YZSmutN5dSpg32WCmlJDk1yetGtywAAAAmgpF+pvS1SR6utX5vk7XppZR/K6X8UynltSN8fQAAADqs1Fq3fVD/pPT6WuvMF6x/Nsl9tdY/Gbi/e5LJtdZVpZTZSa5NMqPW+tggrzk/yfwk6enpmb1gwYIRvpWhWbt2bSZPnjyuezJ29LM79LI79LI79LI79LI79LI7Jkov586du7TW2jvYY9vzmdJBlVJ2TfK2JLM3rNVan0ry1MDvS0sp30/yc0mWvPD5tdbLklyWJL29vXXOnDnDLWVY+vr6Mt57Mnb0szv0sjv0sjv0sjv0sjv0sjv0cmSn7/5iku/UWldsWCilHFBK2WXg91ckOSTJ/SMrEQAAgK7anq+EuSrJ4iSvLKWsKKW8e+ChdyS56gWHH5dkeSnljiRXJ3lPrXX1aBYMAABAd2zP1XdP28r6GYOsXZPkmpGXBQAAwEQw0qvvAgAAwLAJpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANLPNUFpK+WIp5ZFSyp2brJ1fSvnPUsrtAz+/tMljHyml3FdKubeU8oaxKhwAAICd3/ZMSi9P8sZB1i+ptR458PN3SVJKOSzJO5LMGHjOZ0opu4xWsQAAAHTLNkNprfXmJKu38/VOSbKg1vpUrfWBJPclOXoE9QEAANBhI/lM6ftKKcsHTu/dZ2Dt5Ul+tMkxKwbWumH5ouSSmcn5e/ffLl/UuiIAAICdWqm1bvugUqYlub7WOnPgfk+SR5PUJL+f5MBa65mllE8nWVxr/euB476Q5O9qrdcM8przk8xPkp6entkLFiwYlTe0vdauXZvJkydv/xOe/HGy5kdJfe75tfKSZK+Dkkn7bP15jIsh95Mdll52h152h152h152h152x0Tp5dy5c5fWWnsHe2zX4bxgrfXhDb+XUv4iyfUDd1ckOWiTQ6cmeXArr3FZksuSpLe3t86ZM2c4pQxbX19fhrTnJTP7Q+kL7XVQcs6dW64zrobcT3ZYetkdetkdetkdetkdetkdejnM03dLKQducvetSTaksq8meUcpZfdSyvQkhyT515GVuINYs2Jo6wAAAGzTNielpZSrksxJsn8pZUWSjyaZU0o5Mv2n7/4gyVlJUmu9q5SyKMndSdYnObvW+uzYlD7O9pq6lUnp1PGvBQAAoCO2GUprracNsvyFFzn+wiQXjqSoHdIJ5yVf+0DyzJPPr+02qX8dAACAYRnJ1XcnllmnJid9sv8zpCn9tyd9sn8dAACAYRnWhY4mrFmnCqEAAACjyKQUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKCZbYbSUsoXSymPlFLu3GTtj0sp3ymlLC+lfKWUsvfA+rRSypOllNsHfj43lsUDAACwc9ueSenlSd74grUbksystc5K8t0kH9nkse/XWo8c+HnP6JQJAABAF20zlNZab06y+gVr36i1rh+4e0uSqWNQGwAAAB1Xaq3bPqiUaUmur7XOHOSxryVZWGv964Hj7kr/9PSxJP9frfWft/Ka85PMT5Kenp7ZCxYsGN47GKa1a9dm8uTJ47onY0c/u0Mvu0Mvu0Mvu0Mvu0Mvu2Oi9HLu3LlLa629gz2260heuJRybpL1Sa4cWHooyc/WWleVUmYnubaUMqPW+tgLn1trvSzJZUnS29tb58yZM5JShqyvry/jvSdjRz+7Qy+7Qy+7Qy+7Qy+7Qy+7Qy9HcPXdUsrpSd6c5NfqwLi11vpUrXXVwO9Lk3w/yc+NRqEAAAB0z7BCaSnljUl+N8nJtdYnNlk/oJSyy8Dvr0hySJL7R6NQAAAAumebp++WUq5KMifJ/qWUFUk+mv6r7e6e5IZSSpLcMnCl3eOSXFBKWZ/k2STvqbWuHvSFAQAAmPC2GUprracNsvyFrRx7TZJrRloUAAAAE8OwP1MKAAAAIyWUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlO4E5l26OPMuXdy6DAAAgFEnlAIAANDMNr+nlHY2TEdvfWD1ZvcXnnVss5oAAABGk0kpAAAAzZiU7sA2TERNSAEAgK4yKQUAAKAZk9KdgAkpAADQVSalAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKVsYd6lizPv0sWtywAAACYAoRQAAIBmdm1dADuODdPRWx9Yvdn9hWcd26wmAACg20xKAQAAaMaklI02TERNSAEAgPFiUgoAAEAzJqVswYQUAAAYLyalAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAz2wylpZQvllIeKaXcucnavqWUG0op3xu43WeTxz5SSrmvlHJvKeUNY1U4AAAAO7/tmZRenuSNL1j7cJIba62HJLlx4H5KKYcleUeSGQPP+UwpZZdRqxYAAIBO2WYorbXenGT1C5ZPSXLFwO9XJHnLJusLaq1P1VofSHJfkqNHqVY6bN6lizPv0sWtywAAAMZZqbVu+6BSpiW5vtY6c+D+f9da997k8R/XWvcppXwqyS211r8eWP9Ckq/XWq8e5DXnJ5mfJD09PbMXLFgwCm9n+61duzaTJ08e1z3Zuvsf/UmS5BX77zms5+tnd+hld+hld+hld+hld+hld0yUXs6dO3dprbV3sMd2HeW9yiBrg6beWutlSS5Lkt7e3jpnzpxRLuXF9fX1Zbz3ZEsbpqO3PtAfSn9++u5JkoVnHTuk19HP7tDL7tDL7tDL7tDL7tDL7tDL4V999+FSyoFJMnD7yMD6iiQHbXLc1CQPDr88AAAAumy4k9KvJjk9yUUDt9dtsv43pZRPJPmZJIck+deRFkl3bZiIbpiYDnVCCgAA7Ny2GUpLKVclmZNk/1LKiiQfTX8YXVRKeXeSHyZ5e5LUWu8qpSxKcneS9UnOrrU+O0a1AwAAsJPbZiittZ62lYdO2MrxFya5cCRFMfGYkAIAwMQ03M+UAgAAwIgJpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANLPrcJ9YSnllkoWbLL0iyXlJ9k7yG0lWDqz/Xq3174ZdIQAAAJ017FBaa703yZFJUkrZJcl/JvlKkncluaTW+vFRqRAAAIDOGq3Td09I8v1a63+M0usBAAAwAZRa68hfpJQvJllWa/1UKeX8JGckeSzJkiQfrLX+eJDnzE8yP0l6enpmL1iwYMR1DMXatWszefLkcd2TsaOf3aGX3aGX3aGX3aGX3aGX3TFRejl37tyltdbewR4bcSgtpbw0yYNJZtRaHy6l9CR5NElN8vtJDqy1nvlir9Hb21uXLFkyojqGqq+vL3PmzBnXPRk7+tkdetkdetkdetkdetkdetkdE6WXpZSthtLROH33Temfkj6cJLXWh2utz9Zan0vyF0mOHoU9AAAA6KDRCKWnJblqw51SyoGbPPbWJHeOwh4AAAB00LCvvpskpZSXJTkxyVmbLF9cSjky/afv/uAFjwEAAMBGIwqltdYnkuz3grV3jqgiAAAAJozR+koYAAAAGDKhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSpmw5l26OPMuXdy6DAAAmNCEUgAAAJrZtXUBMN42TEdvfWD1ZvcXnnVss5oAAGCiMikFAACgGZNSJpwNE1ETUgAAaM+kFAAAgGZMSpmwTEgBAKA9k1IAAACaEUoBAABoRihlc8sXJZfMTM7fu/92+aLWFQEAAB3mM6U8b/mi5GsfSJ55sv/+mh/130+SWae2qwsAAOgsk1Ked+MFzwfSDZ55sn8dAABgDAilPG/NiqGtAwAAjJBQyvP2mjq0dQAAgBESSnneCeclu03afG23Sf3rAAAAY0Ao5XmzTk1O+mSy10FJSv/tSZ90kSMAAGDMuPoum5t1qhAKAACMG5NSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhI/DynQAABCpSURBVFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaGbXkTy5lPKDJI8neTbJ+lprbyll3yQLk0xL8oMkp9ZafzyyMgEAAOii0ZiUzq21Hllr7R24/+EkN9ZaD0ly48B9AAAA2MJYnL57SpIrBn6/IslbxmAPAAAAOqDUWof/5FIeSPLjJDXJpbXWy0op/11r3XuTY35ca91nkOfOTzI/SXp6emYvWLBg2HUMx9q1azN58uRx3ZOxo5/doZfdoZfdoZfdoZfdoZfdMVF6OXfu3KWbnF27mRF9pjTJa2qtD5ZSfjrJDaWU72zvE2utlyW5LEl6e3vrnDlzRljK0PT19WW892Ts6Gd36GV36GV36GV36GV36GV36OUIT9+ttT44cPtIkq8kOTrJw6WUA5Nk4PaRkRYJAABANw07lJZS9iylTNnwe5LXJ7kzyVeTnD5w2OlJrhtpkQAAAHTTSE7f7UnylVLKhtf5m1rr35dSbkuyqJTy7iQ/TPL2kZcJAABAFw07lNZa709yxCDrq5KcMJKiAAAAmBjG4ithAAAAYLsIpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpUM079LFmXfp4tZlAAAAdIJQCgAAQDO7ti5gZ7FhOnrrA6s3u7/wrGOb1QQAALCzMykFAACgGZPS7bRhImpCCgAAMHpMSgEAAGjGpHSITEgBAABGj0kpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUArjaN6lizPv0sWtywAAgB2GUAoAAEAzu7YuACaCDdPRWx9Yvdn9hWcd26wmAADYEZiUAgAA0IxJKYyDDRNRE1IAANicSSkAAADNmJTCODIhBQCAzQ17UlpKOaiUclMp5Z5Syl2llN8aWD+/lPKfpZTbB35+afTKBQAAoEtGMildn+SDtdZlpZQpSZaWUm4YeOySWuvHR14eAAAAXTbsUFprfSjJQwO/P15KuSfJy0erMAAAALqv1FpH/iKlTEtyc5KZSf5XkjOSPJZkSfqnqT8e5Dnzk8xPkp6entkLFiwYcR1DsXbt2kyePHlc92Ts6Gd36GV36GV36GV36GV36GV3TJRezp07d2mttXewx0YcSkspk5P8U5ILa61fLqX0JHk0SU3y+0kOrLWe+WKv0dvbW5csWTKiOoaqr68vc+bMGdc9GTv62R162R162R162R162R162R0TpZellK2G0hF9JUwpZbck1yS5stb65SSptT5ca3221vpckr9IcvRI9gAAAKC7RnL13ZLkC0nuqbV+YpP1Azc57K1J7hx+eQAAAHTZSK6++5ok70zy76WU2wfWfi/JaaWUI9N/+u4Pkpw1ogqBEZl36eIkviMVAIAd00iuvvutJGWQh/5u+OUAAAAwkYxkUgrswDZMSG99YPVm901MAQDYkYzoQkcAAAAwEial0FEbJqImpAAA7MhMSgEAAGjGpBQ6zoQUAIAdmUkpAAAAzQiltLd8UXLJzOT8vftvly9qXREAADBOnL5LW8sXJV/7QPLMk/331/yo/36SzDq1XV0AAMC4MCmlrRsveD6QbvDMk/3rAABA5wmltLVmxdDWAQCAThFKaWuvqUNbBwAAOkUopa0Tzkt2m7T52m6T+tcBAIDOE0ppa9apyUmfTPY6KEnpvz3pky5yBAAAE4Sr79LerFMnRghdvqj/Ak5rVvSfnnzCeRPjfQMAwIsQSmE8+OobAAAYlNN3mZiWL0oumZmcv3f/7fJFY7ufr74BAIBBmZQy8bSYWvrqGwAAGJRJKRNPi6mlr74BAIBBCaVMPC2mlr76BgAABiWUMvG0mFr66hsAABiUz5Qy8Zxw3uafKU3GZ2o5Ub76BgAAhsCklInH1BIAAHYYJqVMTKaWAACwQzApBQAAoBmhFAAAgGaEUgAAAJoRSqHLli9KLpmZnL93/+3yRa0rAgCAzbjQEXTV8kWbf/XNmh/1309c5AkAgB2GSSl01Y0XbP5drEn//RsvaFPPWDENBgDYqZmUQletWTG09Z2RaTAAwE7PpBS6aq+pQ1sfJfMuXZx5ly4e0z02mijT4MREGADoLKEUuuqE85LdJm2+ttuk/vWumAjT4OT5ifCaHyWpz0+EBVMAoAOcvgtdteH01Rsv6A9pe03tD6RjdFrrhunorQ+s3uz+wrOOHZP9kvS/pzU/Gny9S15sIuw0ZQBgJyeUQpfNOrXboeWE8zb/TGkyPtPg5YvGLewnmTgTYQBgQhJKgVGxYSI6LhPSDcZ5GpykzcWVJspEGACYkIRSYPQsX5RPPXxu9ntuZXLJOATEZPynwS1OpW01EQYAGAdCKTA6BiaIBzzX8a9naXEqbYuJMADAOBFKgdExQS7Gs/IlB+SA5x7Z8oGxPpV2vCfC4/25WQBgwvKVMMDomCAX47lqyhlZl903W1uX3bt1Kq2voAEAxpFQCoyOrU0KO3Yxng+cc272eNunsvIlP53nUpK9Dsoeb/tUt6aILzb1BgAYZU7fBUbHRLoYz6xT877FByUZp6sMj7cJMvUGAHYMQikwOhpejGdcv4ZmQIswOm7vs9VX0PgcKwBMSEIpMHrG+2I8jI0WU+8W3/8KAOwQhFJgp7VhcnjrA6s3u9+1U2rH/X22mHpPkKs3AwBbEkoB2NJ4T71bfY61xSnDTlMGgM2MWSgtpbwxyZ8l2SXJ52utF43VXsDEtGFS2NUJ6QYT4n22+Bxri1OGnaYMAFsYk6+EKaXskuTTSd6U5LAkp5VSDhuLvQAYG/MuXbwxCI+5E87r/9zqpsb6c6wtvvqmxZ7LF2XlBYfkufP3Ti6ZOT7fN2vP7uw5Ed7jRNlzIrxHe+60xmpSenSS+2qt9ydJKWVBklOS3D1G+wETWCcnh4Po9PscmBKuvPbc7PfcyrxkPE5rbXHK8HjvOTCZPeC58Z8G27MDe06E9zhR9pwI79GeY7vnGBuTSWmSlyfZ9DysFQNrAOzgNkxIb31gdW59YPW4TEznXbo48xYflFc/8ad5xborM+9lf5F5A98FO1ZWvuSAwR8Yw1OGx3vPldeeO+6TWXt2Z8+J8B4nyp4T4T3ac4zPuhljpdY6+i9aytuTvKHW+v8M3H9nkqNrre/f5Jj5SeYnSU9Pz+wFCxaMeh0vZu3atZk8efK47snY0c/u0Mv27n/0J0mSnzy1Pkmy5+79J9W8Yv89h/Q6Q+nlaO05FI888l854NmHU/L8fwdrSsreP5tM2qcbez50+9YfO/DI7X6ZIf1zOUp7Dok9t3tPvezOnnrZnT2H/HefFu9zFMydO3dprbV3sMfGKpQem+T8WusbBu5/JElqrf97sON7e3vrkiVLRr2OF9PX15c5c+aM656MHf3sDr3ccYz0wkrD6eW4X8xp+aLxPWV4vPe8ZOZWLiB1UHLOndv9MkPq5SjtOST23O499bI7e+pld/Yc8n8vW7zPUVBK2WooHavTd29LckgpZXop5aVJ3pHkq2O0FwAMz6xT876e/5PTDvx6/3/Ix+OzOOO5Z4sLSNmzO3tOhPc4UfacCO/RnmO75xgbkwsd1VrXl1Lel+Qf0v+VMF+std41FnsBMDZaXFjJnqNsQ+Adz+9FtWd39pwI73Gi7DkR3qM9d9qLHCVjdPruUDl9l5HSz+7Qy+7Qy+7Qy+7Qy+7Qy+6YKL1scfouAAAAbJNQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNlFpr6xpSSlmZ5D/Gedv9kzw6znsydvSzO/SyO/SyO/SyO/SyO/SyOyZKLw+utR4w2AM7RChtoZSypNba27oORod+dodedodedodedodedodedodeOn0XAACAhoRSAAAAmpnIofSy1gUwqvSzO/SyO/SyO/SyO/SyO/SyOyZ8LyfsZ0oBAABobyJPSgEAAGhsQobSUsobSyn3llLuK6V8uHU9DE8p5aBSyk2llHtKKXeVUn6rdU2MTClll1LKv5VSrm9dC8NXStm7lHJ1KeU7A/98Htu6JoanlHLOwL9f7yylXFVK2aN1TWy/UsoXSymPlFLu3GRt31LKDaWU7w3c7tOyRrbPVnr5xwP/nl1eSvlKKWXvljWyfQbr5SaP/U4ppZZS9m9RW0sTLpSWUnZJ8ukkb0pyWJLTSimHta2KYVqf5IO11kOTHJPkbL3c6f1WkntaF8GI/VmSv6+1/s8kR0RPd0qllJcn+UCS3lrrzCS7JHlH26oYosuTvPEFax9OcmOt9ZAkNw7cZ8d3ebbs5Q1JZtZaZyX5bpKPjHdRDMvl2bKXKaUclOTEJD8c74J2BBMulCY5Osl9tdb7a61PJ1mQ5JTGNTEMtdaHaq3LBn5/PP1/8X1526oYrlLK1CS/nOTzrWth+EopP5XkuCRfSJJa69O11v9uWxUjsGuSSaWUXZO8LMmDjethCGqtNydZ/YLlU5JcMfD7FUneMq5FMSyD9bLW+o1a6/qBu7ckmTruhTFkW/nnMkkuSfL/JpmQF/yZiKH05Ul+tMn9FRFkdnqllGlJjkpya9tKGIE/Tf+/jJ9rXQgj8ookK5P85cCp2J8vpezZuiiGrtb6n0k+nv7/1/6hJGtqrd9oWxWjoKfW+lDS/3/uJvnpxvUwOs5M8vXWRTA8pZSTk/xnrfWO1rW0MhFDaRlkbUL+PxJdUUqZnOSaJL9da32sdT0MXSnlzUkeqbUubV0LI7Zrklcl+Wyt9agkP4nTA3dKA581PCXJ9CQ/k2TPUsqvt60KeKFSyrnp/0jTla1rYehKKS9Lcm6S81rX0tJEDKUrkhy0yf2pcTrSTquUslv6A+mVtdYvt66HYXtNkpNLKT9I/yn1ryul/HXbkhimFUlW1Fo3nLVwdfpDKjufX0zyQK11Za31mSRfTvJ/N66JkXu4lHJgkgzcPtK4HkaglHJ6kjcn+bXqex53Vv8j/f/n3x0Dfw+ammRZKeX/alrVOJuIofS2JIeUUqaXUl6a/os2fLVxTQxDKaWk/3Nr99RaP9G6Hoav1vqRWuvUWuu09P8z+c1aq4nMTqjW+l9JflRKeeXA0glJ7m5YEsP3wyTHlFJeNvDv2xPiolVd8NUkpw/8fnqS6xrWwgiUUt6Y5HeTnFxrfaJ1PQxPrfXfa60/XWudNvD3oBVJXjXw39MJY8KF0oEPhL8vyT+k/z+ui2qtd7WtimF6TZJ3pn+qdvvAzy+1LgrI+5NcWUpZnuTIJH/YuB6GYWDafXWSZUn+Pf1/Z7isaVEMSSnlqiSLk7yylLKilPLuJBclObGU8r30X+nzopY1sn220stPJZmS5IaBvwN9rmmRbJet9HLCKyb9AAAAtDLhJqUAAADsOIRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKCZ/x+B2NlCE1QBoAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "r_excited = tf.sqrt(tf.reduce_sum(excited_x**2, axis=1))\n",
    "r_ground  = tf.sqrt(tf.reduce_sum(ground_x**2, axis=1))\n",
    "\n",
    "print(f\"Mean r for the ground state: {tf.reduce_mean(r_ground):.4f}\")\n",
    "print(f\"Mean r for the excited state: {tf.reduce_mean(r_excited):.4f}\")\n",
    "\n",
    "bins = numpy.arange(0,15,0.5)\n",
    "\n",
    "ground_hist,  edges = numpy.histogram(r_ground, bins=bins)\n",
    "excited_hist, edges = numpy.histogram(r_excited, bins=bins)\n",
    "\n",
    "bin_centers = 0.5*(edges[1:] + edges[:-1])\n",
    "\n",
    "print(ground_hist)\n",
    "print(excited_hist)\n",
    "\n",
    "fig = plt.figure(figsize=(16,9))\n",
    "plt.scatter(bin_centers, ground_hist, marker=\"+\", label=\"Ground State\")\n",
    "plt.scatter(bin_centers, excited_hist, label=\"Excited State\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizing the excited state.\n",
    "\n",
    "Optimizing the excited state can proceed exactly as the ground state, now, except we recompute lambda every time we update the weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "excited_energy_history = []\n",
    "excited_steps_history  = []\n",
    "LEARNING_RATE  = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "# Define a figure here which we can update along the way:\n",
    "fig       = plt.figure(figsize=(16,9))\n",
    "# Create 2x2 sub plots\n",
    "gs = gridspec.GridSpec(2, 2)\n",
    "ax_loss   = plt.subplot(gs[:,0])\n",
    "ax_denst  = plt.subplot(gs[:,1], projection=\"3d\")\n",
    "\n",
    "\n",
    "\n",
    "for i in range(25):\n",
    "\n",
    "    # First: make sure lambda is correct:\n",
    "    sampler.kick( wavefunction  = ground_state,\n",
    "        kicker        = tf.random.normal,\n",
    "        kicker_params = {\"mean\": 0.0, \"stddev\" : 0.2},\n",
    "        nkicks        = 100)\n",
    "    x = sampler.sample()\n",
    "    # We compute lambda based on the psi_0 walkers:\n",
    "    excited_state.compute_lambda(x)\n",
    "    \n",
    "    excited_gradients, energy = compute_gradients(N_OBSERVATIONS, excited_sampler, excited_state, hamiltonian)\n",
    "    \n",
    "    \n",
    "    # Scale by the learning rate\n",
    "    excited_gradients = [LEARNING_RATE * g for g in excited_gradients ]\n",
    "        \n",
    "    for i_param in range(len(excited_state.trainable_variables)):\n",
    "        excited_state.trainable_variables[i_param].assign_add(excited_gradients[i_param])\n",
    "\n",
    "    \n",
    "    excited_energy_history.append(energy)\n",
    "    excited_steps_history.append(i)\n",
    "\n",
    "    # Here we update the plots.  Show the energy function:\n",
    "    ax_loss.set_xlim(0, 1.1*i)\n",
    "    ax_loss.cla()\n",
    "    ax_loss.plot(excited_steps_history, excited_energy_history, label=\"Energy\")\n",
    "    ax_loss.grid(True)\n",
    "    ax_loss.legend(fontsize=25)\n",
    "\n",
    "    # Show the location of the walkers:\n",
    "    x, y, z = tf.split(excited_sampler.sample(), 3, axis=1)\n",
    "    ax_denst.clear()\n",
    "    ax_denst.set_xlim(-8,8); ax_denst.set_ylim(-8,8); ax_denst.set_zlim(-8,8);\n",
    "    ax_denst.set_xlabel(\"X\"); ax_denst.set_ylabel(\"Y\"); ax_denst.set_zlabel(\"Z\");\n",
    "    ax_denst.scatter(x, y, z, linewidth=0.5);\n",
    "\n",
    "    display(fig)\n",
    "    clear_output(wait = True)\n",
    "#     plt.pause(0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}