notebooks/experiment_bearing_only_param_estimation_run_time.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import jax\n",
    "import numpy as np\n",
    "import jax.numpy as jnp\n",
    "import scipy\n",
    "import time\n",
    "import pickle\n",
    "import pandas as pd\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "jax.config.update(\"jax_enable_x64\", True)\n",
    "\n",
    "from parsmooth._base import MVNStandard, FunctionalModel, MVNSqrt\n",
    "from parsmooth.linearization import extended, cubature, unscented, gauss_hermite\n",
    "from parsmooth.methods import iterated_smoothing\n",
    "from bearing_data_pe import get_data, make_parameters, inverse_bearings\n",
    "\n",
    "\n",
    "import os\n",
    "os.environ[\"XLA_PYTHON_CLIENT_PREALLOCATE\"] = \"false\"  # add this\n",
    "os.environ[\"XLA_PYTHON_CLIENT_ALLOCATOR\"] = \"platform\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "s1 = jnp.array([-1., 0.5])  # First sensor location\n",
    "s2 = jnp.array([1., 1.])  # Second sensor location\n",
    "x0 = jnp.array([0.1, 0.2, 1, 0])  # initial true location\n",
    "dt = 0.01  # discretization time step\n",
    "qc = 0.1  # discretization noise\n",
    "qw = 0.1  # discretization noise\n",
    "\n",
    "n_run = 10\n",
    "Ts = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
    "r_true = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "# Data = []\n",
    "# for t, T in enumerate(Ts):\n",
    "#     data = []\n",
    "#     for i in range(n_run):\n",
    "#         _, _, ys = get_data(x0, dt, r_true, T, s1, s2)\n",
    "#         positions = inverse_bearings(ys, s1, s2)\n",
    "#         states = jnp.concatenate([jnp.concatenate([jnp.zeros((1,2)), positions], axis = 0),\n",
    "#                               jnp.zeros((T+1,3))], axis = 1)\n",
    "#\n",
    "#         initial_states =  MVNStandard(states,0.1*jnp.repeat(jnp.eye(5).reshape(1, 5, 5), T + 1, axis=0))\n",
    "#         initial_states_sqrt = MVNSqrt(states,jnp.sqrt(0.1)*jnp.repeat(jnp.eye(5).reshape(1, 5, 5), T + 1, axis=0))\n",
    "#         data.append({'ys': ys, 'initial_states': initial_states, 'initial_states_sqrt': initial_states_sqrt})\n",
    "#     Data.append(data)\n",
    "#\n",
    "#\n",
    "# with  open(\"outputs/ell-runtime-output/data.pkl\", \"wb\") as open_file:\n",
    "#     pickle.dump(Data, open_file)\n",
    "\n",
    "\n",
    "with open(\"outputs/ell-runtime-output/data.pkl\", \"rb\") as open_file:\n",
    "    Data = pickle.load(open_file)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "Q, _, observation_function, transition_function = make_parameters(qc, qw, r_true, dt, s1, s2)\n",
    "\n",
    "chol_Q = jnp.linalg.cholesky(Q)\n",
    "\n",
    "m0 = jnp.array([2., 0, 0, 0, 0])\n",
    "P0 = jnp.diag(jnp.array([0.5**2, 0.5**2, 0.5**2, 0.5**2, 1.]))\n",
    "chol_P0 = scipy.linalg.cholesky(P0)\n",
    "\n",
    "init = MVNStandard(m0, P0)\n",
    "chol_init = MVNSqrt(m0, chol_P0)\n",
    "\n",
    "\n",
    "sqrt_transition_model = FunctionalModel(transition_function, MVNSqrt(jnp.zeros((5,)), chol_Q))\n",
    "transition_model = FunctionalModel(transition_function, MVNStandard(jnp.zeros((5,)), Q))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "@jax.jit\n",
    "def runtime_get_ell_std_extended_par(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               extended, initial_points, True,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_cubature_par(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               cubature, initial_points, True,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_unscented_par(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               unscented, initial_points, True,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_gh_par(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               gauss_hermite, initial_points, True,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_extended_seq(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               extended, initial_points, False,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_cubature_seq(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               cubature, initial_points, False,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_unscented_seq(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               unscented, initial_points, False,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell\n",
    "\n",
    "@jax.jit\n",
    "def runtime_get_ell_std_gh_seq(observations, initial_points, iteration, prec_r):\n",
    "    r = 1 / prec_r[0]\n",
    "    R = jnp.diag(jnp.array([r ** 2, 0.1 ** 2]))\n",
    "    observation_model = FunctionalModel(observation_function, MVNStandard(jnp.zeros((2,)), R))\n",
    "\n",
    "    _, ell = iterated_smoothing(observations, init, transition_model, observation_model,\n",
    "                                               gauss_hermite, initial_points, False,\n",
    "                                               criterion=lambda i, *_: i < iteration,\n",
    "                                               return_loglikelihood = True)\n",
    "    return -ell"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "#parallel\n",
    "def func(method, lengths, data, n_runs=5, n_iter=15, sqrt=False, mth='extended-std-par'):\n",
    "    SdR11s = []\n",
    "    Times = []\n",
    "    for t, _ in enumerate(lengths):\n",
    "        print(f\"Length {t+1} out of {len(lengths)}\")\n",
    "        sdR11_res = []\n",
    "        run_times = []\n",
    "        for i in range(n_runs):\n",
    "            observations_slice = data[t][i]['ys']\n",
    "            if sqrt:\n",
    "                init_linearizations_states = data[t][i]['initial_states_sqrt']\n",
    "                args = observations_slice, init_linearizations_states, n_iter\n",
    "            else:\n",
    "                init_linearizations_states = data[t][i]['initial_states']\n",
    "                args = observations_slice, init_linearizations_states, n_iter\n",
    "            r0 = np.array([10.])\n",
    "            method_res = lambda r: method(*args,r)\n",
    "            grad_func= jax.jit(jax.value_and_grad(method_res))\n",
    "            gpu_grad_func = jax.jit(grad_func, backend=\"gpu\")\n",
    "            def wrap_func(r):\n",
    "                loss, grad_val = gpu_grad_func(r)\n",
    "                return np.array(loss, dtype=np.float64), np.array(grad_val, dtype=np.float64)\n",
    "            tic = time.time()\n",
    "            sdR11 = minimize(wrap_func, r0, jac=True, method=\"L-BFGS-B\", bounds=[(0, 100)]).x\n",
    "            toc = time.time()\n",
    "            run_times.append(toc - tic)\n",
    "            sdR11_res.append(sdR11)\n",
    "            print(f\"run {i+1} out of {n_runs}\", end=\"\\r\")\n",
    "        SdR11s.append(sdR11_res)\n",
    "        Times.append(run_times)\n",
    "        np.savez(\"outputs/ell-runtime-output/TIME-GPU-\"+mth+\"-\"+str(t), time = np.array(run_times) )\n",
    "        np.savez(\"outputs/ell-runtime-output/sdR11-GPU-\"+mth+\"-\"+str(t), sdR11 = np.array(sdR11_res) )\n",
    "    print()\n",
    "\n",
    "    return np.array(Times), np.array(SdR11s)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 11 out of 3\n",
      "Length 12 out of 3\n",
      "Length 13 out of 3\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_extended_std_par, sd_gpu_extended_std_par= func(runtime_get_ell_std_extended_par, Ts, Data, n_run,sqrt=False, mth='extended-std-par')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-extended-std-par\",\n",
    "#           time_gpu_extended_std_par = time_gpu_extended_std_par)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-extended-std-par\",\n",
    "#           sd_gpu_extended_std_par = sd_gpu_extended_std_par)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Parallel other Methods"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_cubature_std_par, sd_gpu_cubature_std_par= func(runtime_get_ell_std_cubature_par, Ts, Data, n_run,sqrt=False, mth='cubature-std-par')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-cubature-std-par\",\n",
    "#           time_gpu_cubature_std_par = time_gpu_cubature_std_par)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-cubature-std-par\",\n",
    "#           sd_gpu_cubature_std_par = sd_gpu_cubature_std_par)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_unscented_std_par, sd_gpu_unscented_std_par= func(runtime_get_ell_std_unscented_par, Ts, Data, n_run,sqrt=False, mth='unscented-std-par')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-unscented-std-par\",\n",
    "#           time_gpu_unscented_std_par = time_gpu_unscented_std_par)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-unscented-std-par\",\n",
    "#           sd_gpu_unscented_std_par = sd_gpu_unscented_std_par)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_gh_std_par, sd_gpu_gh_std_par= func(runtime_get_ell_std_gh_par, Ts, Data, n_run,sqrt=False, mth='gh-std-par')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-gh-std-par\",\n",
    "#           time_gpu_gh_std_par = time_gpu_gh_std_par)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-gh-std-par\",\n",
    "#           sd_gpu_gh_std_par = sd_gpu_gh_std_par)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Sequential"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_cubature_std_seq, sd_gpu_cubature_std_seq= func(runtime_get_ell_std_cubature_seq, Ts, Data, n_run, sqrt=False, mth='cubature-std-seq')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-cubature-std-seq\",\n",
    "#           time_gpu_cubature_std_seq = time_gpu_cubature_std_seq)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-cubature-std-seq\",\n",
    "#           sd_gpu_cubature_std_seq = sd_gpu_cubature_std_seq)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_unscented_std_seq, sd_gpu_unscented_std_seq= func(runtime_get_ell_std_unscented_seq, Ts, Data, n_run, sqrt=False, mth='unscented-std-seq')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-unscented-std-seq\",\n",
    "#           time_gpu_unscented_std_seq = time_gpu_unscented_std_seq)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-unscented-std-seq\",\n",
    "#           sd_gpu_unscented_std_seq = sd_gpu_unscented_std_seq)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 1 out of 13\n",
      "Length 2 out of 13\n",
      "Length 3 out of 13\n",
      "Length 4 out of 13\n",
      "Length 5 out of 13\n",
      "Length 6 out of 13\n",
      "Length 7 out of 13\n",
      "Length 8 out of 13\n",
      "Length 9 out of 13\n",
      "Length 10 out of 13\n",
      "Length 11 out of 13\n",
      "Length 12 out of 13\n",
      "Length 13 out of 13\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_gh_std_seq, sd_gpu_gh_std_seq= func(runtime_get_ell_std_gh_seq, Ts, Data, n_run, sqrt=False, mth='gh-std-seq')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-gh-std-seq\",\n",
    "#           time_gpu_gh_std_seq = time_gpu_gh_std_seq)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-gh-std-seq\",\n",
    "#           sd_gpu_gh_std_seq = sd_gpu_gh_std_seq)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 12 out of 2\n",
      "Length 13 out of 2\n",
      "run 10 out of 10\r\n"
     ]
    }
   ],
   "source": [
    "# time_gpu_extended_std_seq, sd_gpu_extended_std_seq= func(runtime_get_ell_std_extended_seq, Ts, Data, n_run, sqrt=False, mth='extended-std-seq')\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-extended-std-seq\",\n",
    "#           time_gpu_extended_std_seq = time_gpu_extended_std_seq)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-extended-std-seq\",\n",
    "#           sd_gpu_extended_std_seq = sd_gpu_extended_std_seq)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "outputs": [],
   "source": [
    "mth='extended-std-seq'\n",
    "time_gpu_extended_std_seq = []\n",
    "sd_gpu_extended_std_seq = []\n",
    "for t in range(len(Ts)):\n",
    "    with np.load(\"outputs/ell-runtime-output/TIME-GPU-\"+mth+\"-\"+str(t)+\".npz\") as loaded:\n",
    "        time_gpu_extended_std_seq.append(loaded[\"time\"])\n",
    "    with np.load(\"outputs/ell-runtime-output/sdR11-GPU-\"+mth+\"-\"+str(t)+\".npz\") as loaded:\n",
    "        sd_gpu_extended_std_seq.append(loaded[\"sdR11\"])\n",
    "\n",
    "# np.savez(\"outputs/ell-runtime-output/TIME-GPU-extended-std-seq\",\n",
    "#           time_gpu_extended_std_seq = time_gpu_extended_std_seq)\n",
    "# np.savez(\"outputs/ell-runtime-output/sdR11-GPU-extended-std-seq\",\n",
    "#           sd_gpu_extended_std_seq = sd_gpu_extended_std_seq)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-extended-std-par.npz\") as loaded:\n",
    "    time_extended_par=np.mean(loaded[\"time_gpu_extended_std_par\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-extended-std-seq.npz\") as loaded:\n",
    "    time_extended_seq=np.mean(loaded[\"time_gpu_extended_std_seq\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-cubature-std-par.npz\") as loaded:\n",
    "    time_cubature_par=np.mean(loaded[\"time_gpu_cubature_std_par\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-cubature-std-seq.npz\") as loaded:\n",
    "    time_cubature_seq=np.mean(loaded[\"time_gpu_cubature_std_seq\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-unscented-std-par.npz\") as loaded:\n",
    "    time_unscented_par=np.mean(loaded[\"time_gpu_unscented_std_par\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-unscented-std-seq.npz\") as loaded:\n",
    "    time_unscented_seq=np.mean(loaded[\"time_gpu_unscented_std_seq\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-gh-std-par.npz\") as loaded:\n",
    "    time_gh_par=np.mean(loaded[\"time_gpu_gh_std_par\"],axis=1)\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/TIME-GPU-gh-std-seq.npz\") as loaded:\n",
    "    time_gh_seq=np.mean(loaded[\"time_gpu_gh_std_seq\"],axis=1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1440x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,8))\n",
    "plt.plot(np.array(Ts), time_extended_par, \"*--\", label = \"par-extended\")\n",
    "plt.plot(np.array(Ts), time_extended_seq, \"o--\", label = \"seq-extended\")\n",
    "plt.plot(np.array(Ts), time_cubature_par, \"*--\", label = \"par-cubature\")\n",
    "plt.plot(np.array(Ts), time_cubature_seq, \"o--\", label = \"seq-cubature\")\n",
    "plt.plot(np.array(Ts), time_unscented_par, \"*--\", label = \"par-unscented\")\n",
    "plt.plot(np.array(Ts), time_unscented_seq, \"o--\", label = \"seq-unscented\")\n",
    "plt.plot(np.array(Ts), time_gh_par, \"*--\", label = \"par-GaussHermite\")\n",
    "plt.plot(np.array(Ts), time_gh_seq, \"o--\", label = \"seq-GaussHermite\")\n",
    "plt.title(\"GPU runtime of estimating the standard deviation of the first sensor\")\n",
    "plt.xlabel(\"number of data points\")\n",
    "plt.ylabel(\"GPU runtime (seconds)\")\n",
    "plt.grid()\n",
    "plt.legend();"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [],
   "source": [
    "# plt.figure(figsize=(20,8))\n",
    "# plt.plot(np.array(Ts)[[0,1,8,10,11]], time1[[0,1,8,10,11]], \"*--\", label = \"par\")\n",
    "# plt.plot(np.array(Ts)[[0,1,8,10,11]], time2[[0,1,8,10,11]], \"o--\", label = \"seq\")\n",
    "# plt.grid()\n",
    "# plt.legend();"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "outputs": [],
   "source": [
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-extended-std-par.npz\") as loaded:\n",
    "    sdR11_1=loaded[\"sd_gpu_extended_std_par\"]\n",
    "\n",
    "rmse_extended_par = np.mean(np.abs(1/np.array(sdR11_1).squeeze()-r_true)**2,axis=1)**0.5\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-extended-std-seq.npz\") as loaded:\n",
    "    sdR11_2=loaded[\"sd_gpu_extended_std_seq\"]\n",
    "\n",
    "rmse_extended_seq = np.mean(np.abs(1/np.array(sdR11_2).squeeze()-r_true)**2,axis=1)**0.5\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-cubature-std-seq.npz\") as loaded:\n",
    "    sdR11_6=loaded[\"sd_gpu_cubature_std_seq\"]\n",
    "\n",
    "rmse_cubature_seq = np.mean(np.abs(1/np.array(sdR11_6).squeeze()-r_true)**2,axis=1)**0.5\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-cubature-std-par.npz\") as loaded:\n",
    "    sdR11_3=loaded[\"sd_gpu_cubature_std_par\"]\n",
    "\n",
    "rmse_cubature_par = np.mean(np.abs(1/np.array(sdR11_3).squeeze()-r_true)**2,axis=1)**0.5\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-unscented-std-par.npz\") as loaded:\n",
    "    sdR11_4=loaded[\"sd_gpu_unscented_std_par\"]\n",
    "\n",
    "rmse_unscented_par = np.mean(np.abs(1/np.array(sdR11_4).squeeze()-r_true)**2,axis=1)**0.5\n",
    "\n",
    "with np.load(\"outputs/ell-runtime-output/sdR11-GPU-gh-std-par.npz\") as loaded:\n",
    "    sdR11_5=loaded[\"sd_gpu_gh_std_par\"]\n",
    "\n",
    "rmse_gh_par = np.mean(np.abs(1/np.array(sdR11_5).squeeze()-r_true)**2,axis=1)**0.5"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1440x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,8))\n",
    "plt.plot(np.array(Ts), rmse_extended_par, \"*--\", label = \"par-extended\")\n",
    "plt.plot(np.array(Ts), rmse_cubature_par, \"o--\", label = \"par-cubature\")\n",
    "plt.plot(np.array(Ts), rmse_unscented_par, \"o--\", label = \"par-unscented\")\n",
    "plt.plot(np.array(Ts), rmse_gh_par, \"o--\", label = \"par-Gauss-Hermite\")\n",
    "plt.title(\"RMSE of the standard deviation of the first sensor\")\n",
    "plt.xlabel(\"number of data points\")\n",
    "plt.ylabel(\"RMSE\")\n",
    "plt.grid()\n",
    "plt.legend();"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "data_csv_time = np.stack([Ts,\n",
    "                 time_extended_par,\n",
    "                 time_extended_seq,\n",
    "                 time_cubature_par,\n",
    "                 time_cubature_seq,\n",
    "                 time_gh_par,\n",
    "                 time_gh_seq],\n",
    "                axis=1)\n",
    "\n",
    "columns = [\"time_steps\",\n",
    "           \"time_extended_par\",\n",
    "           \"time_extended_seq\",\n",
    "           \"time_cubature_par\",\n",
    "           \"time_cubature_seq\",\n",
    "           \"time_gh_par\",\n",
    "           \"time_gh_seq\"]\n",
    "\n",
    "df = pd.DataFrame(data=data_csv_time, columns=columns)\n",
    "df.to_csv(\"outputs/ell-runtime-output/GPU_sdR11_runtime.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "outputs": [],
   "source": [
    "data_csv_sdR11 = np.stack([Ts,\n",
    "                 rmse_extended_par,\n",
    "                 rmse_cubature_par,\n",
    "                 rmse_unscented_par,\n",
    "                 rmse_gh_par],\n",
    "                axis=1)\n",
    "\n",
    "columns_sdR11 = [\"time_steps\",\n",
    "           \"rmse_extended_par\",\n",
    "           \"rmse_cubature_par\",\n",
    "           \"rmse_unscented_par\",\n",
    "           \"rmse_gh_par\"]\n",
    "\n",
    "df_rmse = pd.DataFrame(data=data_csv_sdR11, columns=columns_sdR11)\n",
    "# df_rmse.to_csv(\"outputs/ell-runtime-output/GPU_sdR11_rmse.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}