notebooks/kernel_ergodic_control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tutorial 3: Ergodic Search with Kernel Functions\n",
    "\n",
    "References:\n",
    "\n",
    "[1] *Sun, M., Gaggar, A., Trautman, P. and Murphey, T.*, 2024. **Fast Ergodic Search with Kernel Functions**. arXiv preprint arXiv:2403.01536. [[Link](https://arxiv.org/abs/2403.01536)]\n",
    "\n",
    "*(This tutorial will use JAX for auto-differentiation and accelerated computation.)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "np.set_printoptions(precision=4)\n",
    "rng_np = np.random.default_rng(1)\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp \n",
    "from jax import jit, vmap, grad\n",
    "from jax.scipy.stats import multivariate_normal as mvn\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['axes.linewidth'] = 3\n",
    "mpl.rcParams['axes.titlesize'] = 20\n",
    "mpl.rcParams['axes.labelsize'] = 20\n",
    "mpl.rcParams['axes.titlepad'] = 8.0\n",
    "mpl.rcParams['xtick.major.size'] = 6\n",
    "mpl.rcParams['xtick.major.width'] = 3\n",
    "mpl.rcParams['xtick.labelsize'] = 20\n",
    "mpl.rcParams['ytick.major.size'] = 6\n",
    "mpl.rcParams['ytick.major.width'] = 3\n",
    "mpl.rcParams['ytick.labelsize'] = 20\n",
    "mpl.rcParams['lines.markersize'] = 5\n",
    "mpl.rcParams['lines.linewidth'] = 5\n",
    "mpl.rcParams['legend.fontsize'] = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kernel ergodic metric\n",
    "\n",
    "Recall that the original ergodic metric is defined as:\n",
    "\n",
    "$$\n",
    "\\mathcal{E}(p(x), s(t)) = \\sum_{k} \\lambda_k \\cdot (c_k - \\phi_k)^2\n",
    "$$\n",
    "\n",
    "where\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "    \\phi_k = \\int_{\\mathcal{X}} f_k(x) p(x) dx, \\quad c_k = \\frac{1}{T} \\int_{0}^{T} f_k(s(t)) dt\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Here we introduce another formula for the ergodic metric, named the *kernel ergodic metric*:\n",
    "\n",
    "$$\n",
    "\\mathcal{E}_g(p(x), s(t)) = -\\frac{2}{T} \\int_{0}^{T} p(s(t)) dt + \\frac{1}{T^2} \\int_{0}^{T} \\int_{0}^{T} g(s(t), s(\\tau); \\theta) dt d\\tau + \\int_{\\mathcal{X}} p(x)^2 dx\n",
    "$$\n",
    "\n",
    "where $g(s, s^\\prime)$ is a kernel function that can asymptotically converge to a Dirac delta function. In practice, it is often modeled as a squared exponential (Gaussian) kernel:\n",
    "\n",
    "$$\n",
    "\\Lambda(s, s^\\prime; \\theta) = \\mathcal{N}(s \\vert s^\\prime, \\theta)\n",
    "$$\n",
    "\n",
    "where the parameter $theta$ serves as the covariance of the Gaussian.\n",
    "\n",
    "Note that, the last term of the kernel metric is functional norm of the spatial probabiilty distribution, which can be ignored during optimization. Compared to the original ergodic metric, one of the main benefits of the kernel ergodic metric is that it does involve any spatial integral, all the calculations are time integrals over the trajectory itself. This feature improves the numerical efficiency and scalability of the ergodic control methods that use the kernel ergodic metric.\n",
    "\n",
    "Lastly, for each spatial probability distribution $p(x)$, there exists a parameter $\\theta$ such that the kernel function $g(\\cdot, \\cdot ; \\theta)$ such that optimizing the original ergodic metric and optimizing the kernel ergodic metric converge to the same trajectory. Furthermore, such a parameter $\\theta$ can be solved through the following optimization problem:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "    \\theta^* & = {\\arg\\min}_{\\theta} \\left\\vert \\frac{d}{d\\mathbf{x}} \\left( \\frac{1}{N}\\sum_{i=1}^{N} p(x_i) - \\frac{2}{N^2} \\sum_{i=0}^{N} \\sum_{j=0}^{N} g(x_i, x_j; \\theta) \\right) \\right\\vert^2, \\quad \\mathbf{x}=[x_1,\\dots,x_N]^\\top\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where each entry of $\\mathbf{x} = [x_1,\\dots,x_N]$ is a sample from the spatial probability distribution $p(x)$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a Gaussian-mixture spatial distribution\n",
    "mean1 = jnp.array([0.35, 0.38])\n",
    "cov1 = jnp.array([\n",
    "    [0.01, 0.004],\n",
    "    [0.004, 0.01]\n",
    "])\n",
    "w1 = 0.5\n",
    "\n",
    "mean2 = jnp.array([0.68, 0.25])\n",
    "cov2 = jnp.array([\n",
    "    [0.005, -0.003],\n",
    "    [-0.003, 0.005]\n",
    "])\n",
    "w2 = 0.2\n",
    "\n",
    "mean3 = jnp.array([0.56, 0.64])\n",
    "cov3 = jnp.array([\n",
    "    [0.008, 0.0],\n",
    "    [0.0, 0.004]\n",
    "])\n",
    "w3 = 0.3\n",
    "\n",
    "\n",
    "@jit\n",
    "def pdf(x):\n",
    "    return w1 * mvn.pdf(x, mean1, cov1) + \\\n",
    "           w2 * mvn.pdf(x, mean2, cov2) + \\\n",
    "           w3 * mvn.pdf(x, mean3, cov3)\n",
    "\n",
    "d_pdf = jit(grad(pdf))\n",
    "\n",
    "\n",
    "# Sample from the spatial distribution\n",
    "rng = jax.random.PRNGKey(12)\n",
    "num_samples = 100\n",
    "target_samples = jnp.vstack([\n",
    "    jax.random.multivariate_normal(rng, mean=mean1, cov=cov1, shape=(int(num_samples*w1),)),\n",
    "    jax.random.multivariate_normal(rng, mean=mean2, cov=cov2, shape=(int(num_samples*w2),)),\n",
    "    jax.random.multivariate_normal(rng, mean=mean3, cov=cov3, shape=(int(num_samples*w3),))\n",
    "])\n",
    "\n",
    "\n",
    "# Define a 1-by-1 2D search space\n",
    "L_list = np.array([1.0, 1.0])  # boundaries for each dimension\n",
    "\n",
    "# Discretize the search space into 100-by-100 mesh grids\n",
    "grids_x, grids_y = np.meshgrid(\n",
    "    np.linspace(0, L_list[0], 100),\n",
    "    np.linspace(0, L_list[1], 100)\n",
    ")\n",
    "grids = np.array([grids_x.ravel(), grids_y.ravel()]).T\n",
    "dx = 1.0 / 99\n",
    "dy = 1.0 / 99 \n",
    "\n",
    "pdf_vals = pdf(grids)  # for visualizing the PDF\n",
    "pdf_norm = np.sum(pdf_vals * pdf_vals) * dx * dy  # PDF norm for the kernel ergodic metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the kernel function (we use the exponential formula for better numerical stability)\n",
    "@jit \n",
    "def kernel(x1, x2, theta):\n",
    "    return mvn.pdf(x=x1, mean=x2, cov=jnp.diag(jnp.power(10.0, theta)))\n",
    "\n",
    "d2_kernel = jit(grad(kernel, argnums=(1)))\n",
    "\n",
    "# Define the kernel ergdic metric over samples\n",
    "def samples_kernel_metric(theta, samples):\n",
    "    val1 = vmap(pdf, in_axes=(0,))(samples)\n",
    "    val2 = vmap(vmap(kernel, in_axes=(0,None,None)), in_axes=(None,0,None))(samples, samples, theta)\n",
    "    return -2.0 * jnp.mean(val1) + jnp.mean(val2)\n",
    "\n",
    "grad_samples_kernel_metric = grad(samples_kernel_metric, argnums=(1))\n",
    "\n",
    "\n",
    "# Define the objective for optimizing kernel parameters\n",
    "def parameter_opt_obj(theta, samples):\n",
    "    dvec = grad_samples_kernel_metric(theta, samples)\n",
    "    return jnp.sum(jnp.square(dvec))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal kernel parameter:  [-2.4577 -2.5869]\n"
     ]
    }
   ],
   "source": [
    "# Optimize the kernel parameter\n",
    "from jax.scipy.optimize import minimize \n",
    "\n",
    "sol = minimize(parameter_opt_obj, x0=jnp.array([-3.0, -3.0]), args=(target_samples,), method='bfgs')\n",
    "opt_theta = sol.x\n",
    "print('optimal kernel parameter: ', opt_theta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the same iLQR trajectory optimization method for the kernel ergodic metric. The difference from the original ergodic metric is:\n",
    "\n",
    "$$\n",
    "a(t) = -\\frac{2}{T} \\nabla p(x(t)) + \\frac{2}{T^2} \\int_{0}^{T} \\nabla g(x(t), x(\\tau)) d\\tau\n",
    "$$\n",
    "\n",
    "We now verify the trajectory optimization result on the kernel ergodic metric below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class iLQR_template:\n",
    "    def __init__(self, dt, tsteps, x_dim, u_dim, Q_z, R_v) -> None:\n",
    "        self.dt = dt \n",
    "        self.tsteps = tsteps \n",
    "\n",
    "        self.x_dim = x_dim \n",
    "        self.u_dim = u_dim\n",
    "\n",
    "        self.Q_z = Q_z \n",
    "        self.Q_z_inv = np.linalg.inv(Q_z)\n",
    "        self.R_v = R_v \n",
    "        self.R_v_inv = np.linalg.inv(R_v)\n",
    "\n",
    "        self.curr_x_traj = None \n",
    "        self.curr_y_traj = None\n",
    "\n",
    "    def dyn(self, xt, ut):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "\n",
    "    def step(self, xt, ut): \n",
    "        \"\"\"RK4 integration\"\"\"\n",
    "        k1 = self.dt * self.dyn(xt, ut)\n",
    "        k2 = self.dt * self.dyn(xt + k1/2.0, ut)\n",
    "        k3 = self.dt * self.dyn(xt + k2/2.0, ut)\n",
    "        k4 = self.dt * self.dyn(xt + k3, ut)\n",
    "\n",
    "        xt_new = xt + (k1 + 2.0*k2 + 2.0*k3 + k4) / 6.0 \n",
    "        return xt_new \n",
    "    \n",
    "    def traj_sim(self, x0, u_traj):\n",
    "        x_traj = np.zeros((self.tsteps, self.x_dim))\n",
    "        xt = x0.copy()\n",
    "        for t_idx in range(self.tsteps):\n",
    "            xt = self.step(xt, u_traj[t_idx])\n",
    "            x_traj[t_idx] = xt.copy()\n",
    "        return x_traj\n",
    "    \n",
    "    def loss(self):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "    \n",
    "    def get_At_mat(self, t_idx):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "    \n",
    "    def get_Bt_mat(self, t_idx):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "\n",
    "    def get_at_vec(self, t_idx):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "    \n",
    "    def get_bt_vec(self, t_idx):\n",
    "        raise NotImplementedError(\"Not implemented.\")\n",
    "\n",
    "    # the following functions are utilities for solving the Riccati equation\n",
    "    def P_dyn_rev(self, Pt, At, Bt, at, bt):\n",
    "        return Pt @ At + At.T @ Pt - Pt @ Bt @ self.R_v_inv @ Bt.T @ Pt + self.Q_z \n",
    "    \n",
    "    def P_dyn_step(self, Pt, At, Bt, at, bt):\n",
    "        k1 = self.dt * self.P_dyn_rev(Pt, At, Bt, at, bt)\n",
    "        k2 = self.dt * self.P_dyn_rev(Pt+k1/2, At, Bt, at, bt)\n",
    "        k3 = self.dt * self.P_dyn_rev(Pt+k2/2, At, Bt, at, bt)\n",
    "        k4 = self.dt * self.P_dyn_rev(Pt+k3, At, Bt, at, bt)\n",
    "\n",
    "        Pt_new = Pt + (k1 + 2.0*k2 + 2.0*k3 + k4) / 6.0 \n",
    "        return Pt_new \n",
    "    \n",
    "    def P_traj_revsim(self, PT, A_traj, B_traj, a_traj, b_traj):\n",
    "        P_traj_rev = np.zeros((self.tsteps, self.x_dim, self.x_dim))\n",
    "        P_curr = PT.copy()\n",
    "        for t in range(self.tsteps):\n",
    "            At = A_traj[-1-t]\n",
    "            Bt = B_traj[-1-t]\n",
    "            at = a_traj[-1-t]\n",
    "            bt = b_traj[-1-t]\n",
    "\n",
    "            P_new = self.P_dyn_step(P_curr, At, Bt, at, bt)\n",
    "            P_traj_rev[t] = P_new.copy()\n",
    "            P_curr = P_new \n",
    "        \n",
    "        return P_traj_rev\n",
    "\n",
    "    def r_dyn_rev(self, rt, Pt, At, Bt, at, bt):\n",
    "        return (At - Bt @ self.R_v_inv @ Bt.T @ Pt).T @ rt + at - Pt @ Bt @ self.R_v_inv @ bt\n",
    "\n",
    "    def r_dyn_step(self, rt, Pt, At, Bt, at, bt):\n",
    "        k1 = self.dt * self.r_dyn_rev(rt, Pt, At, Bt, at, bt)\n",
    "        k2 = self.dt * self.r_dyn_rev(rt+k1/2, Pt, At, Bt, at, bt)\n",
    "        k3 = self.dt * self.r_dyn_rev(rt+k2/2, Pt, At, Bt, at, bt)\n",
    "        k4 = self.dt * self.r_dyn_rev(rt+k3, Pt, At, Bt, at, bt)\n",
    "\n",
    "        rt_new = rt + (k1 + 2.0*k2 + 2.0*k3 + k4) / 6.0 \n",
    "        return rt_new\n",
    "    \n",
    "    def r_traj_revsim(self, rT, P_traj, A_traj, B_traj, a_traj, b_traj):\n",
    "        r_traj_rev = np.zeros((self.tsteps, self.x_dim))\n",
    "        r_curr = rT\n",
    "        for t in range(self.tsteps):\n",
    "            Pt = P_traj[-1-t]\n",
    "            At = A_traj[-1-t]\n",
    "            Bt = B_traj[-1-t]\n",
    "            at = a_traj[-1-t]\n",
    "            bt = b_traj[-1-t]\n",
    "\n",
    "            r_new = self.r_dyn_step(r_curr, Pt, At, Bt, at, bt)\n",
    "            r_traj_rev[t] = r_new.copy()\n",
    "            r_curr = r_new \n",
    "\n",
    "        return r_traj_rev\n",
    "\n",
    "    def z_dyn(self, zt, Pt, rt, At, Bt, bt):\n",
    "        return At @ zt + Bt @ self.z2v(zt, Pt, rt, Bt, bt)\n",
    "    \n",
    "    def z_dyn_step(self, zt, Pt, rt, At, Bt, bt):\n",
    "        k1 = self.dt * self.z_dyn(zt, Pt, rt, At, Bt, bt)\n",
    "        k2 = self.dt * self.z_dyn(zt+k1/2, Pt, rt, At, Bt, bt)\n",
    "        k3 = self.dt * self.z_dyn(zt+k2/2, Pt, rt, At, Bt, bt)\n",
    "        k4 = self.dt * self.z_dyn(zt+k3, Pt, rt, At, Bt, bt)\n",
    "\n",
    "        zt_new = zt + (k1 + 2.0*k2 + 2.0*k3 + k4) / 6.0 \n",
    "        return zt_new\n",
    "\n",
    "    def z_traj_sim(self, z0, P_traj, r_traj, A_traj, B_traj, b_traj):\n",
    "        z_traj = np.zeros((self.tsteps, self.x_dim))\n",
    "        z_curr = z0.copy()\n",
    "\n",
    "        for t in range(self.tsteps):\n",
    "            Pt = P_traj[t]\n",
    "            rt = r_traj[t]\n",
    "            At = A_traj[t]\n",
    "            Bt = B_traj[t]\n",
    "            bt = b_traj[t]\n",
    "\n",
    "            z_new = self.z_dyn_step(z_curr, Pt, rt, At, Bt, bt)\n",
    "            z_traj[t] = z_new.copy()\n",
    "            z_curr = z_new\n",
    "        \n",
    "        return z_traj\n",
    "    \n",
    "    def z2v(self, zt, Pt, rt, Bt, bt):\n",
    "        return -self.R_v_inv @ Bt.T @ Pt @ zt - self.R_v_inv @ Bt.T @ rt - self.R_v_inv @ bt\n",
    "\n",
    "    def get_descent(self, x0, u_traj):\n",
    "        # forward simulate the trajectory\n",
    "        x_traj = self.traj_sim(x0, u_traj)\n",
    "        self.curr_x_traj = x_traj.copy()\n",
    "        self.curr_u_traj = u_traj.copy()\n",
    "\n",
    "        # sovle the Riccati equation backward in time\n",
    "        A_traj = np.zeros((self.tsteps, self.x_dim, self.x_dim))\n",
    "        B_traj = np.zeros((self.tsteps, self.x_dim, self.u_dim))\n",
    "        a_traj = np.zeros((self.tsteps, self.x_dim))\n",
    "        b_traj = np.zeros((self.tsteps, self.u_dim))\n",
    "\n",
    "        for t_idx in range(self.tsteps):\n",
    "            A_traj[t_idx] = self.get_At_mat(t_idx)\n",
    "            B_traj[t_idx] = self.get_Bt_mat(t_idx)\n",
    "            a_traj[t_idx] = self.get_at_vec(t_idx)\n",
    "            b_traj[t_idx] = self.get_bt_vec(t_idx)\n",
    "\n",
    "        # print('a_traj:\\n', a_traj)\n",
    "        \n",
    "        PT = np.zeros((self.x_dim, self.x_dim))\n",
    "        P_traj_rev = self.P_traj_revsim(PT, A_traj, B_traj, a_traj, b_traj)\n",
    "        P_traj = np.flip(P_traj_rev, axis=0)\n",
    "\n",
    "        rT = np.zeros(self.x_dim)\n",
    "        r_traj_rev = self.r_traj_revsim(rT, P_traj, A_traj, B_traj, a_traj, b_traj)\n",
    "        r_traj = np.flip(r_traj_rev, axis=0)\n",
    "\n",
    "        z0 = np.zeros(self.x_dim)\n",
    "        z_traj = self.z_traj_sim(z0, P_traj, r_traj, A_traj, B_traj, b_traj)\n",
    "\n",
    "        # compute the descent direction\n",
    "        v_traj = np.zeros((self.tsteps, self.u_dim))\n",
    "        for t in range(self.tsteps):\n",
    "            zt = z_traj[t]\n",
    "            Pt = P_traj[t]\n",
    "            rt = r_traj[t]\n",
    "            Bt = B_traj[t]\n",
    "            bt = b_traj[t]\n",
    "            v_traj[t] = self.z2v(zt, Pt, rt, Bt, bt)\n",
    "        \n",
    "        return v_traj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class iLQR_kernel_ergodic_pointmass(iLQR_template):\n",
    "    def __init__(self, dt, tsteps, x_dim, u_dim, Q_z, R_v,\n",
    "                 R, kernel_theta) -> None:\n",
    "        super().__init__(dt, tsteps, x_dim, u_dim, Q_z, R_v)\n",
    "        \n",
    "        self.R = R \n",
    "        self.kernel_theta = jnp.array(kernel_theta)\n",
    "        \n",
    "\n",
    "    def dyn(self, xt, ut):\n",
    "        return ut\n",
    "        \n",
    "    def get_At_mat(self, t_idx):\n",
    "        A = np.zeros((self.x_dim, self.x_dim))\n",
    "        return A\n",
    "    \n",
    "    def get_Bt_mat(self, t_idx):\n",
    "        B = np.eye(self.u_dim)\n",
    "        return B\n",
    "\n",
    "    def get_at_vec(self, t_idx):\n",
    "        xt = jnp.array(self.curr_x_traj[t_idx][:2])\n",
    "        x_traj = jnp.array(self.curr_x_traj[:,:2])\n",
    "        \n",
    "        d_pdf_xt = np.array(d_pdf(xt))\n",
    "        d_kernel_traj = vmap(d2_kernel, in_axes=(0,None,None))(x_traj, xt, self.kernel_theta)\n",
    "        d_kernel_traj = np.array(d_kernel_traj)\n",
    "        # print('d_kernel_traj.shape: ', d_kernel_traj.shape)\n",
    "\n",
    "        T = self.tsteps * self.dt \n",
    "        at = -2.0 * d_pdf_xt / T + 2.0 * np.sum(d_kernel_traj, axis=0) * self.dt / (T*T)\n",
    "\n",
    "        # print(t_idx, at, -2.0 * d_pdf_xt / T, 2.0 * np.sum(d_kernel_traj, axis=0) * self.dt / (T*T))\n",
    "\n",
    "        return at\n",
    "\n",
    "    def get_bt_vec(self, t_idx):\n",
    "        ut = self.curr_u_traj[t_idx]\n",
    "        return self.R @ ut \n",
    "    \n",
    "    def loss(self, x_traj, u_traj):\n",
    "        x_traj_jax = jnp.array(x_traj)\n",
    "        T = self.dt * self.tsteps\n",
    "        pdf_cost = jnp.sum(vmap(pdf, in_axes=(0,))(x_traj_jax)) * self.dt / T\n",
    "        kernel_cost = vmap(vmap(kernel, in_axes=(0,None,None)), in_axes=(None,0,None))(x_traj_jax, x_traj_jax, self.kernel_theta)\n",
    "        kernel_cost = jnp.sum(kernel_cost) * (self.dt * self.dt) / (T * T)\n",
    "        erg_metric = -2.0 * pdf_cost + kernel_cost + pdf_norm + 2.0  # +2.0 to make sure it is non-negative (artifact of the kernel approximation)\n",
    "\n",
    "        ctrl_cost = np.sum(self.R @ u_traj.T * u_traj.T) * self.dt \n",
    "        return erg_metric + ctrl_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the optimal control problem \n",
    "dt = 0.1 \n",
    "tsteps = 100\n",
    "R = np.diag([1e-08, 1e-08])\n",
    "Q_z = np.diag([0.1, 0.1])  \n",
    "R_v = np.diag([0.1, 0.1]) \n",
    "x0 = rng_np.uniform(low=0.4, high=0.6, size=(2,))\n",
    "\n",
    "# generate a spiral trajectory as the initial control\n",
    "temp_x_traj = np.array([\n",
    "    np.linspace(0.0, 0.3, tsteps+1) * np.cos(np.linspace(0.0, 2*np.pi, tsteps+1)),\n",
    "    np.linspace(0.0, 0.3, tsteps+1) * np.sin(np.linspace(0.0, 2*np.pi, tsteps+1))\n",
    "]).T\n",
    "init_u_traj = (temp_x_traj[1:, :] - temp_x_traj[:-1, :]) / dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "trajopt_kernel_ergodic_pointmass = iLQR_kernel_ergodic_pointmass(\n",
    "    dt, tsteps, x_dim=2, u_dim=2, Q_z=Q_z, R_v=R_v,\n",
    "    R=R, kernel_theta=opt_theta\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1750x350 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Iterative trajectory optimization for ergodic control\n",
    "from IPython import display\n",
    "\n",
    "u_traj = init_u_traj.copy()\n",
    "step = 0.01\n",
    "loss_list = []\n",
    "\n",
    "fig, axes = plt.subplots(1, 3, dpi=70, figsize=(25,5), tight_layout=True)\n",
    "\n",
    "for iter in tqdm(range(100)):\n",
    "    x_traj = trajopt_kernel_ergodic_pointmass.traj_sim(x0, u_traj)\n",
    "    v_traj = trajopt_kernel_ergodic_pointmass.get_descent(x0, u_traj)\n",
    "\n",
    "    loss_val = trajopt_kernel_ergodic_pointmass.loss(x_traj, u_traj)\n",
    "    loss_list.append(loss_val)\n",
    "\n",
    "    step = 0.002\n",
    "    alpha = 0.5\n",
    "    for _i in range(3):\n",
    "        temp_u_traj = u_traj + step * v_traj\n",
    "        temp_x_traj = trajopt_kernel_ergodic_pointmass.traj_sim(x0, temp_u_traj)\n",
    "        temp_loss_val = trajopt_kernel_ergodic_pointmass.loss(temp_x_traj, temp_u_traj)\n",
    "        if temp_loss_val < loss_val:\n",
    "            break\n",
    "        else:\n",
    "            step *= alpha\n",
    "    u_traj += step * v_traj\n",
    "\n",
    "    # visualize every 10 iterations\n",
    "    if (iter+1) % 10 == 0:\n",
    "        ax1 = axes[0]\n",
    "        ax1.cla()\n",
    "        ax1.set_aspect('equal', adjustable='box')\n",
    "        ax1.set_xlim(0.0, L_list[0])\n",
    "        ax1.set_ylim(0.0, L_list[1])\n",
    "        ax1.set_title('Iteration: {:d}'.format(iter+1))\n",
    "        ax1.set_xlabel('X (m)')\n",
    "        ax1.set_ylabel('Y (m)')\n",
    "        ax1.contourf(grids_x, grids_y, pdf_vals.reshape(grids_x.shape), cmap='Reds')\n",
    "        ax1.plot([x0[0], x_traj[0,0]], [x0[1], x_traj[0,1]], linestyle='-', linewidth=2, color='k', alpha=1.0)\n",
    "        ax1.plot(x_traj[:,0], x_traj[:,1], linestyle='-', marker='o', color='k', linewidth=2, alpha=1.0, label='Optimized trajectory')\n",
    "        ax1.plot(x0[0], x0[1], linestyle='', marker='o', markersize=15, color='C0', alpha=1.0, label='Initial state')\n",
    "        ax1.legend(loc=1)\n",
    "\n",
    "        ax2 = axes[1]\n",
    "        ax2.cla()\n",
    "        ax2.set_title('Control vs. Time')\n",
    "        ax2.set_ylim(-1.1, 1.1)\n",
    "        ax2.plot(np.arange(tsteps)*dt, u_traj[:,0], color='C0', label=r'$u_1$')\n",
    "        ax2.plot(np.arange(tsteps)*dt, u_traj[:,1], color='C1', label=r'$u_2$')\n",
    "        ax2.set_xlabel('Time (s)')\n",
    "        ax2.set_ylabel('Control')\n",
    "        ax2.legend(loc=1)\n",
    "        height = ax1.get_position().height\n",
    "        ax2.set_position([ax2.get_position().x0, ax1.get_position().y0, ax2.get_position().width, height])\n",
    "\n",
    "        ax3 = axes[2]\n",
    "        ax3.cla()\n",
    "        ax3.set_title('Objective vs. Iteration')\n",
    "        ax3.set_xlim(-0.2, 100.2)\n",
    "        ax3.set_ylim(5e-01, 1e1)\n",
    "        ax3.set_xlabel('Iteration')\n",
    "        ax3.set_ylabel('Objective')\n",
    "        ax3.plot(np.arange(iter+1), loss_list, color='C3')\n",
    "        height = ax1.get_position().height\n",
    "        ax3.set_position([ax3.get_position().x0, ax1.get_position().y0, ax3.get_position().width, height])\n",
    "        ax3.set_yscale('log')\n",
    "\n",
    "        display.clear_output(wait=True)\n",
    "        display.display(fig)\n",
    "\n",
    "display.clear_output(wait=True)\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}