Examples/Burgers-now-20230218-without-RPCA-DCTKSVD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PDE-FIND for Burger's Equation\n",
    "\n",
    "This notebook demonstrates PDE-FIND on Burger's equation with an added diffusive term.\n",
    "$$\n",
    "u_t + uu_x = 0.1u_{xx}\n",
    "$$\n",
    "The solution given is a single travelling wave, starting out as a Gaussian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sklearn's version: 1.2.2\n",
      "mrmr is not installed in the env you are using. This may cause an error in future if you try to use the (missing) lib.\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings; warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import numpy as np\n",
    "from numpy.random import default_rng\n",
    "import pandas as pd\n",
    "# from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "import sys; sys.path.append('../')\n",
    "from PDE_FIND import *\n",
    "\n",
    "import sys; sys.path.append('../../parametric-discovery/')\n",
    "from best_subset import *\n",
    "from frols import frols\n",
    "from p_linear_regression import PLinearRegression\n",
    "from r_pca import R_pca\n",
    "from pde_diff_new import RPCA\n",
    "from RobustPCA.rpca import RobustPCA\n",
    "\n",
    "import scipy.io as sio\n",
    "from scipy.signal import savgol_filter\n",
    "import itertools\n",
    "\n",
    "from sklearn.preprocessing import normalize\n",
    "from sklearn.linear_model import Ridge, BayesianRidge, LinearRegression as SkLinearRegression\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from abess.linear import LinearRegression\n",
    "# from bess import PdasLm\n",
    "import pysindy as ps\n",
    "\n",
    "from os.path import join as join_path\n",
    "FIGURE_EXPORT_PATH = \"/Users/pongpisit/Documents/figure_export/\"\n",
    "\n",
    "# from rad import AnomalyDetection_RPCA\n",
    "\n",
    "def evaluate_coefficients(prediected_coeffs):\n",
    "    GROUND = np.array([0.1, -1])\n",
    "    errs = 100*np.abs(GROUND-np.array(prediected_coeffs).flatten())/np.abs(GROUND)\n",
    "    return errs.mean(), errs.std()\n",
    "\n",
    "import torch, sympytorch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from sympy import symbols, simplify, lambdify\n",
    "from mathparser import math_eval\n",
    "from varname import nameof\n",
    "from misc import h5file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = sio.loadmat('../Datasets/burgers.mat')\n",
    "u = (data['usol']).real\n",
    "x = (data['x'][0]).real\n",
    "t = (data['t'][:,0]).real\n",
    "dt = t[1]-t[0]\n",
    "dx = x[2]-x[1]\n",
    "X, T = np.meshgrid(x, t)\n",
    "XT = np.asarray([X, T]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STLSQ model: \n",
      "(x0)' = 0.100 x0_11 + -1.001 x0x0_1\n"
     ]
    }
   ],
   "source": [
    "library_functions = [lambda x: x, lambda x: x * x]\n",
    "library_function_names = [lambda x: x, lambda x: x + x]\n",
    "pde_lib = ps.PDELibrary(\n",
    "    library_functions=library_functions,\n",
    "    function_names=library_function_names,\n",
    "    derivative_order=2,\n",
    "    spatial_grid=x,\n",
    "    is_uniform=True,\n",
    ")\n",
    "\n",
    "print('STLSQ model: ')\n",
    "optimizer = ps.STLSQ(threshold=0.1, alpha=1e-5, normalize_columns=False)\n",
    "model = ps.SINDy(feature_library=pde_lib, optimizer=optimizer)\n",
    "model.fit(np.expand_dims(u, -1), t=dt)\n",
    "model.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construct $\\Theta (U)$ and compute $U_t$\n",
    "\n",
    "The function build_linear_system does this for us.  We specify <br>\n",
    "D = highest derivative to appear in $\\Theta$  <br>\n",
    "P = highest degree polynomial of $u$ to appear in $\\Theta$ (not including multiplication by a derivative.  <br>\n",
    "time_diff and space_diff taken via finite differences\n",
    "\n",
    "Printed out is a list of candidate functions for the PDE.  Each is a column of $\\Theta (U)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ut, R, rhs_des = build_linear_system(u, dt, dx, D=3, P=3, time_diff = 'FD', space_diff = 'FD')\n",
    "rhs_des = rhs_des[1:]\n",
    "R = R[:, 1:].real; Ut = Ut.real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solve for $\\xi$\n",
    "\n",
    "TrainSTRidge splits the data up into 80% for training and 20% for validation.  It searches over various tolerances in the STRidge algorithm and finds the one with the best performance on the validation set, including an $\\ell^0$ penalty for $\\xi$ in the loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l0_penalty: 1.6123253173828125\n",
      "PDE derived using STRidge\n",
      "u_t = (-1.000403 +0.000000i)uu_{x}\n",
      "    + (0.100145 +0.000000i)u_{xx}\n",
      "   \n"
     ]
    }
   ],
   "source": [
    "# Solve with STRidge\n",
    "w = TrainSTRidge(R,Ut,10**-5,0.1)\n",
    "print(\"PDE derived using STRidge\")\n",
    "print_pde(w, rhs_des)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now identify the same dynamics but with added noise.\n",
    "\n",
    "The only difference from above is that finite differences work poorly for noisy data so here we use polynomial interpolation.  With deg_x or deg_t and width_x or width_t we specify the degree number of points used to fit the polynomials used for differentiating x or t.  Unfortunately, the result can be sensitive to these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(-0.00013077012953346547,\n",
       " 0.05394066850914703,\n",
       " 0.2085282972955366,\n",
       " -0.24198836854079248)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# K = 2000 experiments\n",
    "# weak lib only can tolerate up to 75 (maybe more?)\n",
    "# weak lib + KalmanDiff: 90 (maybe more?)\n",
    "# weak lib + KalmanDiff + Robust PCA: 110\n",
    "# set np.random.seed(0) to reproduce...\n",
    "np.random.seed(0)\n",
    "noise_lv = float(30)\n",
    "print(noise_lv)\n",
    "noise = 0.01*np.abs(noise_lv)*(u.std())*np.random.randn(u.shape[0],u.shape[1])\n",
    "un = u + noise\n",
    "np.mean(noise), np.std(noise), np.max(noise), np.min(noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "Utn, Rn, rhs_des = build_linear_system(un, dt, dx, D=3, P=3, time_diff = 'poly',\n",
    "                                       deg_x = 4, deg_t = 4, \n",
    "                                       width_x = 10, width_t = 10)\n",
    "rhs_des = rhs_des[1:]\n",
    "Rn = Rn[:, 1:].real; Utn = Utn.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l0_penalty: 1.93969921875\n",
      "PDE derived using STRidge\n",
      "u_t = (-0.775461 +0.000000i)uu_{x}\n",
      "   \n"
     ]
    }
   ],
   "source": [
    "# Solve with STRidge\n",
    "w = TrainSTRidge(Rn,Utn,10**-5,1)\n",
    "print(\"PDE derived using STRidge\")\n",
    "print_pde(w, rhs_des)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting started"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Goals: implement my own optimizer and differentiation_method class!\n",
    "from functools import partial\n",
    "import derivative\n",
    "from tvregdiff import TVRegDiff, tvregdiff, numdiff, pysindydiff, savgol_denoise\n",
    "\n",
    "class KalmanDiff(ps.BaseDifferentiation):\n",
    "    def __init__(self, alpha, poly_deg=None, rpca_lambda=None, d=1, axis=1, is_uniform=True, periodic=False):\n",
    "        super(KalmanDiff, self).__init__()\n",
    "        # Kalman diff\n",
    "        self.alpha = alpha\n",
    "        self.diff_func = derivative.Kalman(alpha=self.alpha)\n",
    "        self.d = d\n",
    "        self.diff = partial(pysindydiff, **{\"diff_method\":self.diff_func, \"order\":self.d})\n",
    "        # Savgol denoising\n",
    "        self.poly_deg = poly_deg\n",
    "        if poly_deg is not None:\n",
    "            if poly_deg%2 == 0: window_length = self.poly_deg + 1\n",
    "            else: window_length = self.poly_deg + 2\n",
    "            self.denoise = partial(savgol_denoise, **{\"window_length\":window_length, \"poly_deg\":self.poly_deg})\n",
    "        else:\n",
    "            self.denoise = lambda _: _\n",
    "        # Robust PCA\n",
    "        self.rpca_lambda = rpca_lambda\n",
    "        # Other info...\n",
    "        self.axis = axis\n",
    "        self.is_uniform = is_uniform\n",
    "        self.periodic = periodic\n",
    "        # data transformation\n",
    "        # rs = np.ones(2).astype(np.int32); rs[self.axis] = -1; rs = tuple(rs)\n",
    "        self.transform = np.vectorize(composite_function(self.diff, self.denoise, left2right=True), signature=\"(m),(m)->(m)\")\n",
    "    # _differentiate\n",
    "    def _differentiate(self, x, t):\n",
    "        in_shape = x.shape\n",
    "        if len(in_shape) == 2: x = np.expand_dims(x, -1) # x should now be 3-dimensional\n",
    "        if isinstance(t, float) and self.is_uniform: \n",
    "            t = np.linspace(0, stop=t*(x.shape[self.axis]-1), num=x.shape[self.axis])\n",
    "        out = []\n",
    "        # wrt to x var\n",
    "        if self.axis == 0:\n",
    "            for i in range(x.shape[-1]):\n",
    "                # use lambda and partial from functools to help shorten the code\n",
    "                # diff = np.hstack([self.denoise(self.diff(x[:, j:j+1, i], t)).reshape(-1, 1) \n",
    "                #                   for j in range(x.shape[1])])\n",
    "                # diff = np.hstack([self.transform(x[:, j:j+1, i], t) for j in range(x.shape[1])])\n",
    "                # diff = np.vectorize(self.transform, signature=\"(m),(m)->(m)\")(x[:,:,i].T, t).T\n",
    "                diff = self.transform(x[:,:,i].T, t).T\n",
    "                if self.rpca_lambda is not None:\n",
    "                    diff = self._get_low_rank(diff)\n",
    "                out.append(np.expand_dims(diff, axis=-1))\n",
    "        # wrt to time var\n",
    "        elif self.axis == 1:\n",
    "            for i in range(x.shape[-1]):\n",
    "                # use lambda and partial from functools to help shorten the code\n",
    "                # diff = np.vstack([self.denoise(self.diff(x[j:j+1, :, i], t)).reshape(1, -1) \n",
    "                #                   for j in range(x.shape[0])])\n",
    "                # diff = np.vstack([self.transform(x[j:j+1, :, i], t) for j in range(x.shape[0])])\n",
    "                # diff = np.vectorize(self.transform, signature=\"(m),(m)->(m)\")(x[:,:,i], t)\n",
    "                diff = self.transform(x[:,:,i], t)\n",
    "                if self.rpca_lambda is not None:\n",
    "                    diff = self._get_low_rank(diff)\n",
    "                out.append(np.expand_dims(diff, axis=-1))\n",
    "        return np.concatenate(out, axis=-1).reshape(in_shape)\n",
    "    # _get_low_rank\n",
    "    def _get_low_rank(self, x):\n",
    "        rpca = RobustPCA(lamb=self.rpca_lambda, tol=10, use_fbpca=True, max_iter=int(1e6))\n",
    "        rpca.fit(x)\n",
    "        return rpca.get_low_rank()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### RPCA before Savgol (Best with window length = 11, Seems fine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "rpca_lambda = None; apply_savgol = False\n",
    "un_copy = un.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if rpca_lambda is not None:\n",
    "    rpca = RobustPCA(lamb=rpca_lambda, tol=10, use_fbpca=True, max_iter=int(1e4))\n",
    "    rpca.fit(un)\n",
    "    un = rpca.get_low_rank()\n",
    "    est_noise = un_copy-un\n",
    "    print(np.mean(est_noise), np.std(est_noise), np.max(est_noise), np.min(est_noise))\n",
    "    print(mean_squared_error(un, u))\n",
    "else:\n",
    "    ### noise40 ###\n",
    "    # un = sio.loadmat(\"../Datasets/l1rdae_noisy_burgers.mat\")[\"rdae_denoised_un\"].real\n",
    "    # un = sio.loadmat(\"../Datasets/rdae_noisy_burgers_best.mat\")[\"rdae_denoised_un\"].real    \n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy40_burgers_0.5.mat\")[\"rdae_denoised_un\"].real # best\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy40_burgers_0.05.mat\")[\"rdae_denoised_un\"].real\n",
    "    \n",
    "    ### noise30 ###\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy30_burgers_5.0.mat\")[\"rdae_denoised_un\"].real # BIC slope = -9600.72546420795\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy30_burgers_1.0.mat\")[\"rdae_denoised_un\"].real # BIC slope = -9707.105703779773\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_regression_noisy30_burgers_1.0.mat\")[\"rdae_denoised_un\"].real\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy30_burgers_0.5.mat\")[\"rdae_denoised_un\"].real # BIC slope = -9778.44580594571\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_regression_noisy30_burgers_0.5.mat\")[\"rdae_denoised_un\"].real\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy30_burgers_0.05.mat\")[\"rdae_denoised_un\"].real # BIC slope = -9766.93551576839\n",
    "    # un = sio.loadmat(\"../RDAE_data/l21rdae_noisy30_burgers_0.005.mat\")[\"rdae_denoised_un\"].real # BIC slope = -1346.286018082552    \n",
    "    \n",
    "    ### noise30 | pytroch ###\n",
    "    # RDAE_lambda = 1.0\n",
    "    # un = np.load(f\"../RDAE_data/pytorch/burgers_RDAE_denoised30_lambda{RDAE_lambda}.npy\")\n",
    "    \n",
    "    ### noise30 | ksvd ###\n",
    "    denoising_mode = 'spm_dctksvd' # ksvd, dictionary_learning\n",
    "    n_components = 32\n",
    "    smoother_name = 'savgol' # none, lowess, kalman, gaussian, filterpy\n",
    "    transform_n_nonzero = \"_none\" # '1'\n",
    "    un = np.load(f\"../RDAE_data/{denoising_mode}/{smoother_name}/transform_n_nonzero_coefs{transform_n_nonzero}/burgers_dictlearn_denoised30_components{n_components}.npy\")\n",
    "\n",
    "# divide into 2 5 10\n",
    "if apply_savgol:\n",
    "    un_savgol = np.vstack([savgol_denoise(un[i:i+1, :], 11, 2) for i in range(un.shape[0])])\n",
    "    print(mean_squared_error(u, un_savgol))\n",
    "    un = un_savgol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Avg weak coef from 10 runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# differentiation_method = ps.FiniteDifference\n",
    "# differentiation_kwargs = {}\n",
    "\n",
    "kalpha = 1e-1; poly_deg = None; diff_order = 2\n",
    "differentiation_method = KalmanDiff\n",
    "differentiation_kwargs = {\"alpha\":kalpha, \"poly_deg\":poly_deg, \"rpca_lambda\":None}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "weak_pde_lib = ps.WeakPDELibrary(library_functions=[lambda x: x, lambda x: x * x], \n",
    "                                 function_names=[lambda x: x, lambda x: x + x], \n",
    "                                 derivative_order=diff_order, p=diff_order, \n",
    "                                 spatiotemporal_grid=XT, \n",
    "                                 include_bias=False, is_uniform=True, K=10000, # new random K points in every calls to the ps.WeakPDELibrary\n",
    "                                 differentiation_method=differentiation_method, \n",
    "                                 differentiation_kwargs=differentiation_kwargs, \n",
    "                                 cache=True\n",
    "                                )\n",
    "kwargs = {'fit_intercept':False, 'copy_X':True, 'normalize_columns':False}\n",
    "X_pre, y_pre, fns = ps_features(un, t, weak_pde_lib, kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['u', 'uu', 'u_1', 'u_11', 'uu_1', 'uuu_1', 'uu_11', 'uuu_11']\n",
      "(u)' = 0.103 u_11 + -1.006 uu_1\n",
      "u_t = (0.103438 +0.000000i)u_11\n",
      "    + (-1.008914 +0.000000i)uu_1\n",
      "   \n"
     ]
    }
   ],
   "source": [
    "## give wrong answer\n",
    "# optimizer = ps.STLSQ(threshold=0.1, alpha=1e-5, normalize_columns=True)\n",
    "# optimizer = ps.SR3(threshold=0.1, thresholder='l0', tol=1e-8, normalize_columns=True, max_iter=1000)\n",
    "# optimizer = ABESS(abess_kw={'alpha':1e-2, 'support_size':2, 'cv':5}, group=None, is_normal=False, normalize_columns=True)\n",
    "# optimizer = BESS(bess_kw={'path_type':'seq', 'sequence':[2], 'is_cv':True, 'K':5}, is_normal=True, normalize_columns=False)\n",
    "\n",
    "## give correct answer (for reasonable noise levels) | L0BNB & ps.FROLS are now the best algos. \n",
    "# Fit a weak form model\n",
    "# optimizer = ps.SSR(criteria='model_residual', normalize_columns=True, kappa=1e-2)\n",
    "# optimizer = ps.FROLS(normalize_columns=True, kappa=5e-4, max_iter=100, alpha=1e-1) # kappa = 1e-3 or 5e-4 gives 2 effective candidates\n",
    "optimizer = L0BNB(max_nonzeros=2, lam=1e-3, is_normal=True, normalize_columns=False) # tune lam จาก (X_pre, y_pre) | ตอนนี้ยังไม่ได้ tune\n",
    "# optimizer = BruteForceRegressor(2)\n",
    "# if feature_library=weak_pde_lib, then just differentiation_method=None is fine.\n",
    "n_ensemble_models = 50\n",
    "model = ps.SINDy(feature_library=weak_pde_lib, optimizer=optimizer, \n",
    "                 # differentiation_method=None,\n",
    "                 differentiation_method=KalmanDiff(alpha=kalpha, poly_deg=poly_deg, rpca_lambda=None, axis=0, is_uniform=True), \n",
    "                 cache=True,\n",
    "                 feature_names=['u'])\n",
    "model.fit(np.expand_dims(un, -1), t=dt, ensemble=True, \n",
    "          library_ensemble=True, n_candidates_to_drop=1, n_models=n_ensemble_models)\n",
    "\n",
    "# print the model selected by Pysindy package\n",
    "# (Not giving the best model if set ensemble or library_ensemble = True)\n",
    "print(model.get_feature_names())\n",
    "model.print()\n",
    "\n",
    "# Use the best-performing (on any validation set) coef in model.coef_list (Plse add this functionality to pysindy)\n",
    "# np.einsum('ij,jkl',X_pre,np.array(model.get_coef_list()).T) -> a cool-looking code\n",
    "# from opt_einsum import contract\n",
    "# contract('ij,jkl',X_pre,np.array(model.get_coef_list()).T) -> a cool-looking code\n",
    "print_pde(model.get_coef_list()[np.argmin(np.sum((np.squeeze(np.tensordot(X_pre, np.array(model.get_coef_list()).T, axes=([-1], [0])), axis=1)-y_pre)**2, axis=0))].reshape(-1,1), model.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (0.103288 +0.000000i)u_11\n",
      "    + (-1.006440 +0.000000i)uu_1\n",
      "   \n",
      "['u_{xx}' 'uu_{x}']\n",
      "[ 0.1032882  -1.00644035]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1.9661197519878297, 1.3220849695960628)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ols_model, eff_rhs_indices = model.validate_coef_list()[0]\n",
    "print(np.array([convert2latex(f) for i,f in enumerate(model.get_feature_names()) if i in eff_rhs_indices]))\n",
    "print(ols_model.params)\n",
    "# (2.966546839959899, 1.8494019586055508) -> ksvd\n",
    "# (2.951366904136575, 1.8846719890201133) -> spm_ksvd\n",
    "# (2.0340810219237895, 1.5495206426166808) -> spm_ksvd + savgol\n",
    "evaluate_coefficients(ols_model.params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.939279 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.103288 +0.000000i)u_11\n",
      "    + (-1.006440 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.102698 +0.000000i)u_11\n",
      "    + (-1.052011 +0.000000i)uu_1\n",
      "    + (0.096979 +0.000000i)uuu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.095035 +0.000000i)u_11\n",
      "    + (-1.012175 +0.000000i)uu_1\n",
      "    + (0.069414 +0.000000i)uu_11\n",
      "    + (-0.081718 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.014513 +0.000000i)u_1\n",
      "    + (0.090353 +0.000000i)u_11\n",
      "    + (-0.976752 +0.000000i)uu_1\n",
      "    + (0.087361 +0.000000i)uu_11\n",
      "    + (-0.098409 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.010037 +0.000000i)uu\n",
      "    + (0.087444 +0.000000i)u_11\n",
      "    + (-1.091025 +0.000000i)uu_1\n",
      "    + (0.143433 +0.000000i)uuu_1\n",
      "    + (0.119847 +0.000000i)uu_11\n",
      "    + (-0.124001 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.010803 +0.000000i)u\n",
      "    + (-0.018069 +0.000000i)uu\n",
      "    + (0.085089 +0.000000i)u_11\n",
      "    + (-1.106424 +0.000000i)uu_1\n",
      "    + (0.185650 +0.000000i)uuu_1\n",
      "    + (0.131905 +0.000000i)uu_11\n",
      "    + (-0.151801 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.010803 +0.000000i)u\n",
      "    + (-0.018069 +0.000000i)uu\n",
      "    + (0.085089 +0.000000i)u_11\n",
      "    + (-1.106424 +0.000000i)uu_1\n",
      "    + (0.185650 +0.000000i)uuu_1\n",
      "    + (0.131905 +0.000000i)uu_11\n",
      "    + (-0.151801 +0.000000i)uuu_11\n",
      "   \n"
     ]
    }
   ],
   "source": [
    "all_ols_models = []\n",
    "all_eff_rhs = []\n",
    "for mnz in range(1, 9):\n",
    "    optimizer = L0BNB(max_nonzeros=mnz, lam=1e-3, is_normal=True, normalize_columns=False) # tune lam จาก (X_pre, y_pre) | ตอนนี้ยังไม่ได้ tune\n",
    "    n_ensemble_models = 50\n",
    "    model = ps.SINDy(feature_library=weak_pde_lib, optimizer=optimizer, \n",
    "                     differentiation_method=KalmanDiff(alpha=kalpha, poly_deg=poly_deg, rpca_lambda=rpca_lambda, axis=0, is_uniform=True), \n",
    "                     cache=True,\n",
    "                     feature_names=['u'])\n",
    "    model.fit(np.expand_dims(un, -1), t=dt, ensemble=True, \n",
    "              library_ensemble=True, n_candidates_to_drop=1, n_models=n_ensemble_models)\n",
    "    ols_model, eff_rhs_indices = model.validate_coef_list()[0]\n",
    "    all_ols_models.append(ols_model)\n",
    "    all_eff_rhs.append(eff_rhs_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_eff_rhs.append(tuple(i for i in range(X_pre.shape[1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RFE_PLinearRegression\n",
      "(3, 4)\n",
      "(4,)\n",
      "--------------------------------------------------\n",
      "(3, 4, 5)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(3, 4, 6, 7)\n",
      "(3, 4, 6)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(2, 3, 4, 6, 7)\n",
      "(3, 4, 6, 7)\n",
      "--------------------------------------------------\n",
      "(1, 3, 4, 5, 6, 7)\n",
      "(3, 4, 5, 6, 7)\n",
      "(3, 4, 6, 7)\n",
      "--------------------------------------------------\n",
      "(0, 1, 3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6, 7)\n",
      "(3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n",
      "(0, 1, 3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n",
      "(0, 1, 2, 3, 4, 5, 6, 7)\n",
      "(0, 1, 3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "ic_type = 'aic'; mode='rfe' # aic, bic | rfe, SelectKBest\n",
    "st = backward_refinement(all_eff_rhs, (X_pre, y_pre), \n",
    "                         mode=mode, ic_type=ic_type, verbose=True)\n",
    "# st += backward_refinement(all_eff_rhs, (normalize(X_pre, axis=0), y_pre), \n",
    "#                           mode=mode, ic_type=ic_type, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(3, 4)\n",
      "(3, 4, 5)\n",
      "(3, 4, 6, 7)\n",
      "(3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6, 7)\n",
      "(0, 1, 3, 4, 5, 6, 7)\n",
      "(0, 1, 2, 3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "decreasing_aics = []\n",
    "complexities = []\n",
    "eff_feature_names = []\n",
    "now_aic = 1e6\n",
    "for com in sorted(st.track.keys()):\n",
    "    indices, aic = st.track[com]\n",
    "    print(indices)\n",
    "    if aic < now_aic:\n",
    "        complexities.append(len(indices))\n",
    "        decreasing_aics.append(aic)\n",
    "        eff_feature_names.append([convert2latex(f) for i,f in enumerate(model.get_feature_names()) if i in indices])\n",
    "        now_aic = aic\n",
    "decreasing_aics = np.array(decreasing_aics)\n",
    "complexities = np.array(complexities)\n",
    "relative_decreasing_aics = decreasing_aics-np.min(decreasing_aics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8,4))\n",
    "ax.plot(complexities, relative_decreasing_aics, color='blue', linewidth=2.5, label=\"AIC-decreasing models\")\n",
    "ax.scatter(complexities, relative_decreasing_aics, marker='*', c='red', s=300)\n",
    "for com, name, rel_aic in zip(complexities, eff_feature_names, relative_decreasing_aics):\n",
    "    rotation = (90+45)/2\n",
    "    if com == 1: rotation = 0\n",
    "    ax.annotate(f\"    $({','.join(name)})$\", (com, rel_aic), rotation=rotation)\n",
    "plt.xlim(0.8,8.1)\n",
    "plt.title(r\"Model selection based on $\\frac{\\Delta AIC}{\\Delta s}$\")\n",
    "plt.ylabel(\"Relative AIC\")\n",
    "plt.xlabel(\"Number of support sizes\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "# plt.savefig(join_path(FIGURE_EXPORT_PATH, \"aic_model_selection.png\"), dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 improves 1\n",
      "Percent improve: 0.320784558097571\n",
      "5 does not improve 2\n",
      "Percent improve: 0.0008978741565110362\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n",
      "2 does not improve 1\n",
      "Percent improve: 0.320784558097571\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "good_coms = set()\n",
    "min_pok = 0.01\n",
    "max_pok = 1.\n",
    "delta_pok = min_pok\n",
    "for p in np.arange(min_pok, max_pok+delta_pok, delta_pok):\n",
    "    c = find_transition_V5(decreasing_aics, complexities, percent_ok=p)\n",
    "    good_coms.add(c)\n",
    "good_coms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "savgol 32\n",
      "-21717.57975960913\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([-67701.45012094, -89419.02988054, -89480.05416696, -89529.97368605,\n",
       "        -89659.89098864, -89727.94940066, -89739.18657217]),\n",
       " array([1, 2, 3, 4, 5, 6, 7]),\n",
       " [['uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}', 'u^2u_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u', 'u^2', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}']])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### RDAE ###\n",
    "# -12389.963195450575\n",
    "\n",
    "### ksvd ###\n",
    "# no filter\n",
    "# n_comp = 8 -> -9047.553796278982\n",
    "# n_comp = 16 -> -9765.622573120214\n",
    "# n_comp = 32 -> -10536.38751942126\n",
    "# n_comp = 64 -> -10352.02875804546\n",
    "\n",
    "# lowess transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -24401.9389418036\n",
    "# n_comp = 16 -> -24691.76627305709\n",
    "# n_comp = 32 -> -24959.709959679923\n",
    "# n_comp = 64 -> -24764.429429510492\n",
    "\n",
    "# kalman transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -24885.56632890232\n",
    "# n_comp = 16 -> -25232.98595637962\n",
    "# n_comp = 32 -> -25588.41567926969\n",
    "# n_comp = 64 -> -25426.439846555484\n",
    "# kalman transform_n_nonzero_coefs1\n",
    "# n_comp = 8 -> -25891.828620483968\n",
    "# n_comp = 16 -> -25971.78585120196\n",
    "# n_comp = 32 -> -25934.634833973236\n",
    "# n_comp = 64 -> -26581.895008216423\n",
    "\n",
    "# gaussian transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -25196.800131085605\n",
    "# n_comp = 16 -> -25431.84926941515\n",
    "# n_comp = 32 -> -25916.951667960224\n",
    "# n_comp = 64 -> -25736.902542940414\n",
    "# gaussian transform_n_nonzero_coefs1\n",
    "# n_comp = 8 -> -26469.26580282442\n",
    "# n_comp = 16 -> -26869.639789218723\n",
    "# n_comp = 32 -> -26454.30774999768\n",
    "# n_comp = 64 -> -26941.29946099699\n",
    "\n",
    "### dictionary learning (increase n_comp until the diff in AIC/BIC drops) ###\n",
    "### only with transform_n_nonzero_coefs_none\n",
    "### aic ###\n",
    "# lowess\n",
    "# n_comp = 8 -> -20140.686246364276\n",
    "# n_comp = 16 -> -20648.56772998038\n",
    "# n_comp = 32 -> -20432.913180842457\n",
    "# n_comp = 64 -> -21502.00430136999\n",
    "# kalman\n",
    "# n_comp = 8 -> -23844.3589917847\n",
    "# n_comp = 16 -> -24251.69743649113\n",
    "# n_comp = 32 -> -24075.305724278223\n",
    "# n_comp = 64 -> -24346.695904317035\n",
    "\n",
    "# gaussian\n",
    "\n",
    "print(smoother_name, n_components)\n",
    "print(decreasing_aics[1]-decreasing_aics[0])\n",
    "decreasing_aics, complexities, eff_feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filterpy\n",
    "# 8 : -10632.44623231511\n",
    "# 16 : -11283.159060366146\n",
    "# 32 : -12254.360922488995\n",
    "# 40: -12149.099591411665"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "com = 1, 0.00427157711237669\n",
      "com = 2, 0.0018324785633012652\n",
      "com = 3, 0.018487881869077682\n",
      "com = 4, 0.018136942759156227\n",
      "com = 5, 0.036770351231098175\n",
      "com = 6, 0.03867316246032715\n",
      "com = 7, 0.047671716660261154\n",
      "com = 8, 0.07248015701770782\n"
     ]
    }
   ],
   "source": [
    "baye_alpha = 1e-6\n",
    "mul_val = 1\n",
    "brr_uncertainties = []\n",
    "for com in sorted(st.track.keys()):\n",
    "    brr = BayesianRidge(compute_score=True, alpha_1=baye_alpha, alpha_2=baye_alpha)\n",
    "    brr.fit(X_pre[:, st.track[com][0]], y_pre)\n",
    "    print(f\"com = {com},\", mul_val*np.trace(np.sqrt(brr.sigma_)))\n",
    "    brr_uncertainties.append(mul_val*np.trace(np.sqrt(brr.sigma_)))\n",
    "brr_uncertainties = np.array(brr_uncertainties)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.018324785633012652\n",
      "0.18324785633012652\n",
      "1.8324785633012652\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 4.27157711,  1.83247856, 18.48788187, 18.13694276, 36.77035123,\n",
       "       38.67316246, 47.67171666, 72.48015702])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power = 1\n",
    "while 1:\n",
    "    e = brr_uncertainties.min()*(10**power)\n",
    "    print(e)\n",
    "    if e > 1: break\n",
    "    power += 1\n",
    "brr_uncertainties = brr_uncertainties*(10**power)\n",
    "brr_uncertainties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More model selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use PDE_FIND_Loss from parametric_pde_find.py by formulating as a parametric problem\n",
    "# Moving horizon in time\n",
    "\n",
    "def ssr2llf(ssr, nobs):\n",
    "    nobs2 = nobs / 2.0\n",
    "    llf = -nobs2 * np.log(2 * np.pi) - nobs2 * np.log(ssr / nobs) - nobs2\n",
    "    return llf\n",
    "\n",
    "def log_like_value(prediction, ground):                                                                                                               \n",
    "    nobs = float(ground.shape[0])\n",
    "    ssr = np.sum(np.abs(ground - prediction)**2)\n",
    "    return ssr2llf(ssr, nobs)\n",
    "\n",
    "def BIC_AIC(prediction, ground, nparams, reg_func = lambda x: x):\n",
    "    nparams = reg_func(nparams)\n",
    "    llf = log_like_value(prediction, ground)\n",
    "    return -2*llf + np.log(ground.shape[0])*nparams, -2*llf + 2*nparams\n",
    "\n",
    "def AIC_Loss(A,b,x,epsilon=1e-5):\n",
    "    N = A.shape[0]\n",
    "    k = np.count_nonzero(x)\n",
    "    # Rudy et al., 2019\n",
    "    rss = ((b-A.dot(x))**2).sum()\n",
    "    aic = N*np.log(rss/N+epsilon) + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "    return aic\n",
    "\n",
    "def PDE_FIND_Loss(As,bs,x,epsilon=1e-5,const_coeff=True,cv=0,ic_type=\"bic\",version=0):\n",
    "    # D: Number of candidates | m: either len(t) or len(x) (temporal or spatial group)\n",
    "    D,m = x.shape\n",
    "    # n: Number of horizon\n",
    "    n,_ = As[0].shape\n",
    "    N = n*m\n",
    "    \n",
    "    rss = [np.linalg.norm(bs[j] - As[j].dot(x[:,j].reshape(D,1)))**2 for j in range(m)]\n",
    "    rss = np.sum(rss)\n",
    "    llf = ssr2llf(rss, N)\n",
    "    \n",
    "    k = np.count_nonzero(x)\n",
    "    if const_coeff:\n",
    "        k = np.count_nonzero(x)/m\n",
    "    k = k + k*cv\n",
    "    \n",
    "    if ic_type == \"aic\":\n",
    "        aic1 = N*np.log(rss/N+epsilon) + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "        aic2 = -2*llf + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "        if version > 0:\n",
    "            return aic2\n",
    "        return aic1\n",
    "    elif ic_type == \"bic\":\n",
    "        bic1 = N*np.log(rss/N+epsilon) + np.log(N)*k\n",
    "        bic2 = -2*llf + np.log(N)*k\n",
    "        if version > 0:\n",
    "            return bic2\n",
    "        return bic1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "### useful for checking whether it worth having function coefficienst or not? ###\n",
    "# diff_lib = ps.PDELibrary(library_functions=library_functions, \n",
    "#                          function_names=library_function_names, \n",
    "#                          derivative_order=2, \n",
    "#                          spatial_grid=x, \n",
    "#                          is_uniform=True, \n",
    "#                          differentiation_method=ps.FiniteDifference, \n",
    "#                          differentiation_kwargs={})\n",
    "\n",
    "diff_lib = ps.PDELibrary(library_functions=library_functions, \n",
    "                         function_names=library_function_names, \n",
    "                         derivative_order=2, \n",
    "                         spatial_grid=x, \n",
    "                         is_uniform=True, \n",
    "                         differentiation_method=KalmanDiff, \n",
    "                         differentiation_kwargs=differentiation_kwargs)\n",
    "\n",
    "candidate_lib = diff_lib.fit_transform(np.expand_dims(un[:, :], -1))\n",
    "f_candidate_lib = np.stack([np.fft.fft2(candidate_lib[:, :, i]) \n",
    "                            for i in range(candidate_lib.shape[-1])], axis=-1)\n",
    "candidate_lib = candidate_lib.reshape(-1, candidate_lib.shape[-1])\n",
    "dynamics = diff_lib.differentiation_method(**diff_lib.differentiation_kwargs, \n",
    "                                           axis=1)._differentiate(un[:, :], \n",
    "                                                                  t)\n",
    "f_dynamics = np.fft.fft2(dynamics)\n",
    "dynamics = dynamics.reshape(-1,1)\n",
    "\n",
    "dependent = \"temporal\"\n",
    "Theta_grouped, Ut_grouped = spatial_temporal_group(candidate_lib, dynamics, \n",
    "                                                   (len(x), len(t)), \n",
    "                                                   dependent=dependent)\n",
    "\n",
    "com2coeff = {}\n",
    "com2paracoeff = {}\n",
    "for com in sorted(st.track.keys()):\n",
    "    indices, _ = st.track[com]\n",
    "    paracoeff = np.zeros(shape=(candidate_lib.shape[-1], len(Theta_grouped)))\n",
    "    \n",
    "    paracoeff[list(indices)] = np.hstack([np.linalg.lstsq(Theta_grouped[_][:, indices], \n",
    "                                                          Ut_grouped[_], \n",
    "                                                          rcond=None)[0] for _ in range(len(Theta_grouped))])\n",
    "    \n",
    "    coeff = np.zeros(shape=(candidate_lib.shape[-1], 1))\n",
    "    coeff[list(indices)] = np.linalg.lstsq(candidate_lib[:, indices], dynamics)[0]\n",
    "    coeff = np.hstack([coeff for _ in range(len(Theta_grouped))])\n",
    "    \n",
    "    com2coeff[com] = coeff\n",
    "    com2paracoeff[com] = paracoeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "PDE_Losses = np.array([PDE_FIND_Loss(Theta_grouped, Ut_grouped, com2coeff[com])\n",
    "                       for com in sorted(st.track.keys())])\n",
    "paraPDE_Losses = np.array([PDE_FIND_Loss(Theta_grouped, Ut_grouped, com2paracoeff[com], const_coeff=False)\n",
    "                       for com in sorted(st.track.keys())])\n",
    "\n",
    "### decide whether you are dealing with functional coefficients here ###\n",
    "plt.plot(sorted(st.track.keys()), PDE_Losses, label='const')\n",
    "plt.plot(sorted(st.track.keys()), paraPDE_Losses, label='para')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0638831716228206\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAD4CAYAAAD//dEpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAoV0lEQVR4nO3deXhV5bn38e+dgYQhCRACCTtACJMyCMEIjuAsWitDHai2cqqnWOvV4fT09NQz9pz32Lf22Nrat61a59axilOdZ0QZDIMikzIT5pkwhJDkfv/IAgOGJCTZWXvv/D7XtS9XnrXW3ncQ8suznrXvbe6OiIhIQ5LCLkBEROKDAkNERBpFgSEiIo2iwBARkUZRYIiISKOkhF1AtHTr1s0LCgrCLkNEJK7MnTt3m7vn1LUvYQOjoKCAkpKSsMsQEYkrZrbmePt0SUpERBpFgSEiIo2iwBARkUZRYIiISKMoMEREpFEUGCIi0igKDBERaRQFxjF27a/gN29+xpKNe8IuRUQkpigw6vCHd1bwVMm6sMsQEYkpUQsMM/tfM1tqZp+Y2bNm1rnWvlvNbLmZLTOzS2qNn2pmC4N9d5mZBeNpZvZkMD7bzAqiVXfnDu04/6TuvPjxBiqrqqP1MiIicSeaM4w3gKHufgrwGXArgJkNBiYDQ4BxwB/MLDk454/AVGBA8BgXjN8I7HT3/sCdwO1RrJuJIyNs21vB+59vi+bLiIjElagFhru/7u6VwZezgPxgezzwhLsfdPdVwHJglJnlAZnuPtNrPjf2EWBCrXMeDrafBi44PPuIhvMGdadzh1SmzV8frZcQEYk7rbWGcQPwSrAdAWovEJQGY5Fg+9jxo84JQmg3kH3si5jZVDMrMbOSrVu3NrnYdilJfPWUnry+aBNl5Yea/DwiIomkWYFhZm+a2ad1PMbXOuZfgUrg0cNDdTyV1zNe3zlHD7jf6+7F7l6ck1Nnd95GmzgywsHKal5ZuKlZzyMikiia1d7c3S+sb7+ZTQEuBy4ILjNBzcyhV63D8oENwXh+HeO1zyk1sxQgC9jRnNobUtSrM327dWTa/FKuPq1XwyeIiCS4aN4lNQ74Z+AKd99fa9cLwOTgzqe+1Cxuz3H3jUCZmZ0erE9cDzxf65wpwfaVwNu1Aiha9TNhRIRZK3ewfteBaL6UiEhciOYaxv8DMoA3zGyBmd0N4O6LgKeAxcCrwC3uXhWcczNwHzUL4Sv4Yt3jfiDbzJYDPwJ+GsW6j5hYVLOE8pwWv0VEsCj/oh6a4uJib4lP3Lvq7g/Zsa+CN380lijemCUiEhPMbK67F9e1T+/0bsDEonxWbN3HwvW7wy5FRCRUCowGfGVYHu2Sk5g2T5elRKRtU2A0IKtDKhcOrmkVckitQkSkDVNgNMLEony276tg+mdNfzOgiEi8U2A0wtiBOXRRqxARaeMUGI3QLiWJrw7vyRuLN7NHrUJEpI1SYDTSpJH5VFRW88rCjWGXIiISCgVGIw3Pz6KwW0ee0d1SItJGKTAaycyYWBRhzqodrNuxv+ETREQSjALjBEwIWoU8v0CzDBFpexQYJ6BX1w6M6tuVafPXk6gtVUREjkeBcYImFUVYuXUfn5SqVYiItC0KjBN06bA82qUkMW1eacMHi4gkEAXGCcpqn8pFJ/fgxU82qlWIiLQpCowmmDQywo59Fby3TK1CRKTtUGA0wZiBOWR3bMezahUiIm2IAqMJUpODViFLNrP7gFqFiEjboMBooolFESoqq3lZrUJEpI1QYDTRKflZ9MvpyLNqFSIibYQCo4nMjEkj85mzWq1CRKRtUGA0w/gRPQG0+C0ibYICoxnyu3RgdN+uPKtWISLSBigwmulrI/NZtW0fC9btCrsUEZGoUmA006XDcklLSdJlKRFJeAqMZspIT+WiwT144eMNVFSqVYiIJC4FRguYNDLCrv2HeHfZlrBLERGJGgVGCzhngFqFiEjii3pgmNmPzczNrFutsVvNbLmZLTOzS2qNn2pmC4N9d5mZBeNpZvZkMD7bzAqiXfeJSE1O4ooRPXlryRZ271erEBFJTFENDDPrBVwErK01NhiYDAwBxgF/MLPkYPcfganAgOAxLhi/Edjp7v2BO4Hbo1l3U0wqyqeiqpqX1CpERBJUtGcYdwI/AWq/SWE88IS7H3T3VcByYJSZ5QGZ7j7Ta97U8AgwodY5DwfbTwMXHJ59xIqhkUz6d++kD1YSkYQVtcAwsyuA9e7+8TG7IsC6Wl+XBmORYPvY8aPOcfdKYDeQXcdrTjWzEjMr2bq1dT+rwsyYWBShZM1O1m5XqxARSTzNCgwze9PMPq3jMR74V+A/6jqtjjGvZ7y+c44ecL/X3YvdvTgnJ6ex30aLmVAUwUytQkQkMTUrMNz9QncfeuwDWAn0BT42s9VAPjDPzHKpmTn0qvU0+cCGYDy/jnFqn2NmKUAWsKM5tUdDpHN7Tu+bzbPzS9UqREQSTlQuSbn7Qnfv7u4F7l5AzQ/8ke6+CXgBmBzc+dSXmsXtOe6+ESgzs9OD9YnrgeeDp3wBmBJsXwm87TH6E3niyAirt+9n3tpdYZciItKiWv19GO6+CHgKWAy8Ctzi7lXB7puB+6hZCF8BvBKM3w9km9ly4EfAT1u16BNw6dDDrUK0+C0iiSWlNV4kmGXU/vo24LY6jisBhtYxXg5cFa36WlJGeiqXDMnlb59s5D8uH0K7FL03UkQSg36aRcHEoFXIO2oVIiIJRIERBef070a3Tml6T4aIJBQFRhSkJCdxxfCevL10C7v2V4RdjohIi1BgRMmkkREOVTl/+0StQkQkMSgwomRIz0wG9uikN/GJSMJQYERJTauQfOau2cnqbfvCLkdEpNkUGFE0oainWoWISMJQYERRXlZ7zuyXzXML1qtViIjEPQVGlE0symfN9v3MW7sz7FJERJpFgRFl44bmkp6axLR5uiwlIvFNgRFlndJSjrQKOVhZ1fAJIiIxSoHRCiaNzGf3gUO8s1StQkQkfikwWsFZ/bLJyUjTZSkRiWsKjFaQkpzE+OE9eWfZFnbuU6sQEYlPCoxWMvFIq5ANDR8sIhKDFBitZHBeJiflZjBNb+ITkTilwGglNa1CIsxfu4tVahUiInFIgdGKxo+IqFWIiMQtBUYrys1K56x+3Xh2fqlahYhI3FFgtLJJIyOs23GAkjVqFSIi8UWB0couGZJL+9RkvSdDROKOAqOVdUxLYdzQXF76ZAPlh9QqRETihwIjBBOLIuwpr+RttQoRkTiiwAjBWf270V2tQkQkzigwQpCcZEwoivDusi3sUKsQEYkTCoyQTCyKUFmtViEiEj8UGCE5+XCrEF2WEpE4EdXAMLPvmdkyM1tkZr+sNX6rmS0P9l1Sa/xUM1sY7LvLzCwYTzOzJ4Px2WZWEM26W8vXRuazYN0uVmzdG3YpIiINilpgmNl5wHjgFHcfAtwRjA8GJgNDgHHAH8wsOTjtj8BUYEDwGBeM3wjsdPf+wJ3A7dGquzWNH9GTJIPn1CpEROJANGcYNwO/cPeDAO5++B7S8cAT7n7Q3VcBy4FRZpYHZLr7TK/pm/EIMKHWOQ8H208DFxyefcSz7pnpnNW/G8/OX091tVqFiEhsi2ZgDATOCS4hvWdmpwXjEWBdreNKg7FIsH3s+FHnuHslsBvIPvYFzWyqmZWYWcnWrVtb9JuJlkkjI5TuVKsQEYl9zQoMM3vTzD6t4zEeSAG6AKcD/wQ8FcwK6poZeD3jNLDviwH3e9292N2Lc3JymvQ9tbZLhuTSoV0y0+aVNnywiEiImhUY7n6huw+t4/E8NTOEaV5jDlANdAvGe9V6mnxgQzCeX8c4tc8xsxQgC9jRnNpjRYd2QauQhRvVKkREYlo0L0k9B5wPYGYDgXbANuAFYHJw51Nfaha357j7RqDMzE4PZiLXA88Hz/UCMCXYvhJ42xOoP/ikonzKyit5a4lahYhI7IpmYDwAFJrZp8ATwJRgtrEIeApYDLwK3OLuh3+1vhm4j5qF8BXAK8H4/UC2mS0HfgT8NIp1t7oz+mXTIzONZ+frspSIxK6UaD2xu1cA3zjOvtuA2+oYLwGG1jFeDlzV0jXGiuQkY8KICPfPWMX2vQfJ7pQWdkkiIl+id3rHiEkj86msdl78WK1CRCQ2KTBixKDcDAbnZerzvkUkZikwYsikkRE+Lt3N8i1qFSIisUeBEUOuGF7TKkSL3yISixQYMaR7ZjrnDMjhufkb1CpERGKOAiPGTBoZYf2uA8xZnRDvSxSRBKLAiDEXD86lY7tkntXnZIhIjFFgxJj27ZIZNzSPl9UqRERijAIjBn1tZISyg5W8sXhz2KWIiByhwIhBpxdmk5eVrvdkiEhMUWDEoKQkY/yICO99tpVtew+GXY6ICKDAiFmTRkaoUqsQEYkhCowYNbBHBkMjmUzT3VIiEiMUGDFsYlE+C9fvZvmWsrBLERFRYMSyK4b3JDnJNMsQkZigwIhhORlpnDOgG8/NX69WISISOgVGjJs0Mp8Nu8uZtWp72KWISBunwIhxFw/uQae0lIRoFeLurNuxnwT6OHaRNkWBEePSU5O5dGgur3y6iQMV8dkq5FBVNc8vWM+E33/AOb98h4c/XB12SSLSBAqMODBxZIS9Byt5Y0l8tQrZua+C37+znHNuf4cfPLGAsvJK+uV05N7pKzlUVR12eSJyglLCLkAadnrfbHpmpTNtXilXDO8ZdjkNWr6ljAc+WM20eaWUH6rm7P7d+PmkoZw7sDvvLNvCjQ+X8NInG5lQFAm7VBE5AQqMOJCUZEwoinDP9JVsLTtITkZa2CV9ibsz/fNtPDBjFe99tpV2KUlMHBHhW2cXcFJu5pHjzhvUnQHdO3H3eysYP6InZhZi1SJyInRJKk4cbhXyQoy1CjlQUcVjs9dy0Z3TmfLAHBZv3MOPLhrIzJ+ez+1XnnJUWEBN+E0dU8jSTWVM/3xbSFWLSFNohhEn+nfPYFgki2fnl3Lj2X3DLodNu8t5ZOZqHpuzll37DzGkZya/vno4Xzklj7SU5HrPHT8iwh2vL+Oe91YwdmBOK1UsIs2lwIgjk0ZG+K8XF/PZ5jIG9sgIpYaP1+3igQ9W8dInG6ly5+LBPbjhrL6M6tu10ZeX2qUkcePZffn5y0tZWLqbYflZUa5aRFqCLknFka+G1Cqksqqalxdu5Mo/fsj433/AW0u2cP0ZBbz34/O455vFjC7MPuG1iK+P6k1GWgr3TF8RpapFpKVphhFHunVKY+zAHJ5fsJ6fXDKIpKToLhjvPnCIpz5ax0Mfrmb9rgP06tqef798MFcX55ORntqs585IT+Xa03vzp+krWbt9P72zO7RQ1SISLVGbYZjZCDObZWYLzKzEzEbV2nermS03s2Vmdkmt8VPNbGGw7y4Lfm01szQzezIYn21mBdGqO9ZNLIqwcXc5s1ZGr1XI6m37+NkLizjj/77FbS8vIb9Le+755qm8++PzuPHsvs0Oi8NuOKsvyUnGfTNWtsjziUh0RXOG8Uvgv9z9FTO7LPj6XDMbDEwGhgA9gTfNbKC7VwF/BKYCs4CXgXHAK8CNwE53729mk4HbgWuiWHvMumhwDzLSUpg2fz1n9u/WYs/r7sxcuZ0HZqziraVbSEkyvjq8Jzec1ZehkeisMfTITGdiUYSnStbxwwsH0rVju6i8joi0jGiuYThw+J7KLODw/aDjgSfc/aC7rwKWA6PMLA/IdPeZXtNs6BFgQq1zHg62nwYusDZ6A396ajKXDcvjlYUbW6RVSPmhKp4qWcelv32fa/80m3lrd/G98/rzwT+fz6+vHhG1sDhs6phCyg9V88jM1VF9HRFpvmjOMH4IvGZmd1ATTGcG4xFqZhCHlQZjh4LtY8cPn7MOwN0rzWw3kA20yRv5J46M8GTJOl5fvInxI5r2bumtZQf5y6w1PDp7Ddv2VjCoRwa3f20Y40dESE+t/7bYltS/ewYXntydhz9czU1j+tG+Xeu9toicmGYFhpm9CeTWsetfgQuAf3D3Z8zsauB+4EKgrpmB1zNOA/tq1zOVmkta9O7du8H649Wogq5EOrdn2rz1JxwYizbs5sEPVvPCgg1UVFVz/kndufHsvpzZ78TvdGopN43tx1V3z+Svc9dx/RkFodQgIg1rVmC4+4XH22dmjwA/CL78K3BfsF0K9Kp1aD41l6tKg+1jx2ufU2pmKdRc4tpRRz33AvcCFBcXJ2wP7aQkY2JRhD+8u5wtZeV0z0iv9/iqauftpVu4f8ZKZq3cQfvUZCaP6sXfnVlAYU6nVqr6+Ir7dGFk78786f2VXDuqNynJuttbJBZF81/mBmBssH0+8Hmw/QIwObjzqS8wAJjj7huBMjM7PVifuB54vtY5U4LtK4G3vY1/qMLEkRGqHV5YcPxWIXsPVvLgB6s4/1fv8u1HSli7fT+3XnoSs269gP8ePzQmwgLAzLhpbD/W7TjAK59uCrscETmOaK5hfBv4bTAjKCe4VOTui8zsKWAxUAncEtwhBXAz8BDQnpq7o14Jxu8H/mxmy6mZWUyOYt1xoV9OJ4bnZzFt3nr+/pzCo/at27Gfhz9czZMfraPsYCUje3fmny4ZxLghuTH72/tFJ/egsFtN6/PLT8lTU0KRGBS1wHD3GcCpx9l3G3BbHeMlwNA6xsuBq1q6xng3sSjCz15czLJNZQzs0YmSNTt5YMYqXlu0CTPjsmF53HBWAUW9u4RdaoOSkoxvjynk1mkLmblie4veMiwiLUPv9I5jXx3ek/95aQk/f3kJO/dX8EnpbrLap3LT2H5cf0Yf8rLah13iCZlYFOFXr3/G3dNXKjBEYpACI45ld0rj3EHdeXPJZgpzOvI/E4YyaWSEDu3i839remoy3zqrgP99bRmLN+xhcM/Mhk8SkVZjibp2XFxc7CUlJWGXEXVbyspZtXUfpxV0jXpvqdawe/8hzvzFW1w8JJc7rxkRdjkibY6ZzXX34rr2xeYKqDRa94x0RhdmJ0RYAGR1SGXyqN688PEGSnfuD7scEalFgSEx54az+2LAAzNWh12KiNSiwJCYE+ncniuG9+SJj9aya39F2OWISECBITFp6thC9ldU8ZdZa8IuRUQCCgyJSSflZnLuoBwe+nA15Yea35VXRJpPgSExa+qYQrbtrWj1j6QVkbopMCRmnVGYzSn5Wfzp/ZVUVSfm7d8i8USBITHLzLhpTD9WbdvHG4vVlFAkbAoMiWnjhubSu2sH7n5vJYn6JlOReKHAkJiWHDQlXLBuFx+t3hl2OSJtmgJDYt5Vp+bTtWM77nlvRdiliLRpCgyJeempyUw5o4C3lm7hs81lYZcj0mYpMCQuXH9GH9qnJnPv9JVhlyLSZikwJC506diOa07rxfML1rNpd3nY5Yi0SQoMiRs3nt2XqmrnwQ9WhV2KSJukwJC40atrB75ySk8enb2WPeWHwi5HpM1RYEhcuWlMIXsPVvLY7LVhlyLS5igwJK4MjWRxdv9uPPjBKg5WqimhSGtSYEjcuWlsIZv3HOT5BRvCLkWkTVFgSNw5u383Budlcu/0lVSrKaFIq1FgSNwxM24aW8jyLXt5e+mWsMsRaTMUGBKXLhuWR6Rze+6ZrnYhIq1FgSFxKTU5ib8/py8frd7J3DVqSijSGhQYEreuOa0XnTukcq9mGSKtQoEhcatDuxS+eXofXl+8mRVb94ZdjkjCa1ZgmNlVZrbIzKrNrPiYfbea2XIzW2Zml9QaP9XMFgb77jIzC8bTzOzJYHy2mRXUOmeKmX0ePKY0p2ZJLFPOLCA1OYn73ldTQpFoa+4M41NgEjC99qCZDQYmA0OAccAfzCw52P1HYCowIHiMC8ZvBHa6e3/gTuD24Lm6Av8JjAZGAf9pZl2aWbckiG6d0rjq1HyembeeLWVqSigSTc0KDHdf4u7L6tg1HnjC3Q+6+ypgOTDKzPKATHef6TWft/kIMKHWOQ8H208DFwSzj0uAN9x9h7vvBN7gi5AR4dvnFHKoqpqHP1wddikiCS1aaxgRYF2tr0uDsUiwfez4Uee4eyWwG8iu57m+xMymmlmJmZVs3bq1Bb4NiQcF3Tpy6dBc/jxzDXsPVoZdjkjCajAwzOxNM/u0jsf4+k6rY8zrGW/qOUcPut/r7sXuXpyTk1NPeZJopo7px57ySp6Yo6aEItGS0tAB7n5hE563FOhV6+t8YEMwnl/HeO1zSs0sBcgCdgTj5x5zzrtNqEkS2IhenRndtysPzFh1ZCFcRFpWtP5VvQBMDu586kvN4vYcd98IlJnZ6cH6xPXA87XOOXwH1JXA28E6x2vAxWbWJVjsvjgYEznKd8b2Y8Pucv72iZoSikRDc2+rnWhmpcAZwEtm9hqAuy8CngIWA68Ct7j74V7UNwP3UbMQvgJ4JRi/H8g2s+XAj4CfBs+1A/g/wEfB47+DMZGjnDsoh0E9MrjnvZXU/K4hIi3JEvUfVnFxsZeUlIRdhrSyp+eW8uO/fsxD3zqNcwd1D7sckbhjZnPdvbiufbrQKwnliuE9yc1M55739EY+kZamwJCE0i4liRvP7svMldv5pHRX2OWIJBQFhiScyaN6kZGewj3TNcsQaUkKDEk4GempfOP0PryycCNrtu8LuxyRhKHAkIT0rTMLSElK4r73V4VdikjCUGBIQuqemc7EoghPlaxj+96DYZcjkhAUGJKwvj2mkIOV1Twyc03YpYgkBAWGJKz+3Ttx0eAePDJzNfsr1JRQpLkUGJLQvjO2kJ37D/HXktKGDxaReikwJKGd2qcrp/bpwp/eX0llVXXY5YjENQWGJLybxhRSuvMAL3+6KexSROKaAkMS3oUn96AwpyP3Tl+hpoQizaDAkISXlGTcNKaQT9fv4cMV28MuRyRuKTCkTZhQFCEnI42731sRdikicUuBIW1CWkoy3zqrgPc/38aiDbvDLkckLikwpM24bnQfOrZL5k9qSijSJAoMaTOy2qdy7ejevPjJRkp37g+7nBZVWVXNh8u3sWTjHioqdfuwREdK2AWItKYbzu7Lgx+s5v4Zq/jPrw4Ju5xmq652Xv50I79+4zNWbq3pzJuSZBTmdGRQbiYn5WYwqEcGg3IzyO/SHjMLuWKJZwoMaVPystozfkSEJ+as4/vnD6BLx3Zhl9Qk7s47y7Zwx2ufsXjjHgZ078RvJ48AYOmmMpZtKmPemp28+PGGI+d0SkthYI9OXwRJbgYn5WbQuUN8/hlI61NgSJszdUwhz8wr5S+z1vC9CwaEXc4J+3DFNu54bRnz1u6id9cO3HnNcK4YHiE5qWb2ML7WsXvKD/H55rIjIbJ0UxkvL9zI43PWHjmmR2bal2Yj/bt3Ij01uZW/M4l1CgxpcwblZnDeoBwenrmab48pjJsfjPPX7uSO15fxwfLt5Gam8/OJw7iqOJ/U5OMvRWampwbtUboeGXN3Nu85yNJNe1hWK0geWrGdiqB9SnKSUZDdgZNyMxlUazbSq0sHkpJ0WautUmBIm3TT2H5MvncWz8wr5brRfcIup15LNu7hV68v480lW8ju2I5/v3ww143u3eSgMzNys9LJzUrn3EHdj4xXVlWzevu+o2YjC9fv5qWFG48c06FdMgN6ZHBSjy9CZFBuBtmd0pr9fUrss0RtlVBcXOwlJSVhlyExyt2Z8IcP2b2/grf+8dwjl3Niycqte7nzzc958eMNZKSncNOYQr51Vl86prXu73n7Dlby2eYvQmTZpjKWbS5jx76KI8fkZKQddUnrpNxMBvTQZa14ZGZz3b24rn2aYUibZFbTLuS7j87j9UWbuHRYXtglHVG6cz93vfU5z8xbT1pKErec14+p5/Qjq0NqKPV0TEuhqHcXinp3OTLm7mzde/CoS1rLNpXx51lrOBjc1ptkUJDd8ahLWoNyM+ndtUNMBrQ0TIEhbdYlQ3Lpk92Bu6evZNzQ3NBvOd1SVs7v317OY3PWYmZMOaOA757Xj24xeLnHzOiekU73jHTOGZBzZLyq2lmzfd9RIbJ0UxmvLtrE4YsZ6alJDOyRQXGfrnx9VC8G9MgI6buQE6XAkDYrOcn49jmF/NtznzJn1Q5GF2aHUsfOfRXcPX0FD3+4mkNVztXFvfje+f3p2bl9KPU0R3KSUZjTicKcTkfN2g5UVPH5ltohsoe/zFrDAx+sYlTfrlw3ujfjhuaSlqJLWLFMaxjSppUfquKsX7zN8F6deeDvTmvV1y4rP8QDM1Zz3/sr2VtRyfjhPfnhhQMp6NaxVesIy/a9B3l6bimPzVnLmu376dqxHVedms/XR/VuM38Gsai+NYxmtQYxs6vMbJGZVZtZca3xi8xsrpktDP57fq19pwbjy83sLguuA5hZmpk9GYzPNrOCWudMMbPPg8eU5tQsUlt6ajJ/d2YBby/dwrJNZa3ymuWHqrh3+grG/PId7nzzM87sn82rPxjDbyYXtakflNmd0rhpbD/e+cdz+fONoxjdtyv3zVjFuXe8yzfvn82rn27kkD4lMaY0a4ZhZicD1cA9wI/dvSQYLwI2u/sGMxsKvObukWDfHOAHwCzgZeAud3/FzL4LnOLu3zGzycBEd7/GzLoCJUAx4MBc4FR331lfbZphSGPt3FfBmb94m8uG5fGrq4dH7XUqKqt58qO1/O7t5WwpO8iYgTn8+OKBnJLfOWqvGW827ynnqY/W8fictWzYXU73jDQmn9aLa0b1JhKHl+jiUX0zjBa5JGVm71IrMI7ZZ8A2oCfQFXjH3U8K9n0dONfdbzKz14CfuftMM0sBNgE5wOTDxwTn3AO86+6P11eTAkNOxM9eWMSjs9cw/SfnkZfVsj+YKquqeXb+en771ueU7jzAaQVd+PHFg0JbM4kHVdXOu8u28OjstbyzbAsGnDeoO9ed3puxA7vrLqsoCvu22q8B8939oJlFgNJa+0qBSLAdAdYBuHulme0GsmuP13HOUcxsKjAVoHfv3i35PUiCu/Hsvvx51hoe/GA1/3LZyS3ynIcbA975xmes2LqPYZEs/mfCUMYOzAn9jqxYl5xkXHByDy44uQelO/fz5EfreOKjdbz1UAmRzu35+qheXF3ci+6Z6WGX2qY0GBhm9iaQW8euf3X35xs4dwhwO3Dx4aE6DvMG9tV3ztGD7vcC90LNDKO+2kRq69W1A5efksdjs9dyy3n9yWrf9Pc81NUY8O5vjOSSIeHfuhuP8rt04B8vHsT3LxjAm4s38+jstdzx+mf85s3PuXhID64d1Ycz+2WrZUkraDAw3P3CpjyxmeUDzwLXu/vhz8UsBfJrHZYPbKi1rxdQGlySygJ2BOPnHnPOu02pSaQ+U8cU8vyCDTw2ey03n9uvSc/RUGNAabrU5CQuHZbHpcPyWLVtH4/PWctfS9bx8sJNFGR34NrRvbny1F50jdMOxPEgKmsYZtYZeA/4b3d/5phjPwK+B8ymZtH7d+7+spndAgyrteg9yd2vDha95wIjg6eYR82i9476atIahjTFN++fzbJNZbz/z+ed0HsCjm0M+P0LBjTYGFCar/xQFa8t2sSjs9YyZ/UO2iUncdmwXK47vQ/FfbpoRtcEUVv0NrOJwO+oWZzeBSxw90vM7N+AW4HPax1+sbtvCW6/fQhoD7wCfM/d3czSgT8DRdTMLCa7+8rgdW4A/iV4ntvc/cGGalNgSFPM+Hwb37h/Nr/82ilcfVqvBo8/tjHgd8/r36zGgNJ0n20u47HZa3lmXill5ZUM7NGJ60b3YUJRpFmXGNuaqN8lFYsUGNIU7s7lv5tB+aEq3viHsce9Lh4rjQHly/ZXVPK3jzfy6Ow1fFy6m/TUJK4Y3pPrRvfhlPwszToaoMAQOQEvfLyB7z8+nz9dX8xFg3scte/YxoDfOqsg1MaAUr9P1+/m0dlreX7BevZXVDE0ksl1o/twxfCeCvfjUGCInIDKqmrOveNdcjPTefrmM4EvGgM+PmcdGHxjdJ+YbQwoX1ZWfojnFmzg0VlrWLqpjE5pKUwsinDt6N6cnJcZdnkxRYEhcoIe+mAVP3txMfdPKeaj1Tt56MNVcd8YUGouOc5bu4vHZq/lb59s4GBlNSN7d+a60X34yil5WntCgSFywvZXVHLmL95m1/5DmNHmGgO2Bbv2V/DMvPU8OnsNK7fuI6t9Kleems+1o3vTL6dT2OWFRoEh0gRPzy3lg+Xb+M7YfgzK1Wc2JCp3Z9bKHTw6ew2vLdrEoSrnjMJsrh3dm0uG5NIupW3dGq3AEBFphG17D/LXklIem7OGdTsO0K1TO64q7sU1xb3okZmOGTUPLPhvzYdJJRkJc/eVAkNE5ARUVzvvL9/Go7PW8NbSLVRVN/7npBkkmQVhUhMuWM1H1tYOmqRg43DoHHseHA6iL85LCkKpdnAdDqvgFJLMODkvk999vahJ33vYzQdFROJKUpIxdmAOYwfmsHH3AV5ftJkDh6pwh+rgl2x3D74Gp2bba3Z8aaw62PDgvGon2Bcc4x7sqxk7vB/8yGv6kfNrH+/B83+xjUOvLtG5KUOBISJSj7ys9kw5syDsMmJC21rNERGRJlNgiIhIoygwRESkURQYIiLSKAoMERFpFAWGiIg0igJDREQaRYEhIiKNkrCtQcxsK7CmGU/RDdjWQuVEWzzVCvFVbzzVCvFVbzzVCvFVb3Nq7ePuOXXtSNjAaC4zKzleP5VYE0+1QnzVG0+1QnzVG0+1QnzVG61adUlKREQaRYEhIiKNosA4vnvDLuAExFOtEF/1xlOtEF/1xlOtEF/1RqVWrWGIiEijaIYhIiKNosAQEZFGUWAcw8weMLMtZvZp2LU0xMx6mdk7ZrbEzBaZ2Q/Crul4zCzdzOaY2cdBrf8Vdk0NMbNkM5tvZn8Lu5aGmNlqM1toZgvMLOY/m9jMOpvZ02a2NPj7e0bYNdXFzAYFf6aHH3vM7Idh13U8ZvYPwb+vT83scTNLb9Hn1xrG0cxsDLAXeMTdh4ZdT33MLA/Ic/d5ZpYBzAUmuPvikEv7EjMzoKO77zWzVGAG8AN3nxVyacdlZj8CioFMd7887HrqY2argWJ3j4s3lpnZw8D77n6fmbUDOrj7rpDLqpeZJQPrgdHu3pw3BUeFmUWo+Xc12N0PmNlTwMvu/lBLvYZmGMdw9+nAjrDraAx33+ju84LtMmAJEAm3qrp5jb3Bl6nBI2Z/WzGzfOArwH1h15JozCwTGAPcD+DuFbEeFoELgBWxGBa1pADtzSwF6ABsaMknV2AkCDMrAIqA2SGXclzBJZ4FwBbgDXeP2VqB3wA/AapDrqOxHHjdzOaa2dSwi2lAIbAVeDC45HefmXUMu6hGmAw8HnYRx+Pu64E7gLXARmC3u7/ekq+hwEgAZtYJeAb4obvvCbue43H3KncfAeQDo8wsJi/5mdnlwBZ3nxt2LSfgLHcfCVwK3BJcWo1VKcBI4I/uXgTsA34abkn1Cy6bXQH8NexajsfMugDjgb5AT6CjmX2jJV9DgRHngvWAZ4BH3X1a2PU0RnD54V1gXLiVHNdZwBXBusATwPlm9pdwS6qfu28I/rsFeBYYFW5F9SoFSmvNMJ+mJkBi2aXAPHffHHYh9bgQWOXuW939EDANOLMlX0CBEceCheT7gSXu/uuw66mPmeWYWedguz01f7mXhlrUcbj7re6e7+4F1FyGeNvdW/Q3tZZkZh2Dmx4ILu1cDMTsXX7uvglYZ2aDgqELgJi7UeMYXyeGL0cF1gKnm1mH4GfDBdSsa7YYBcYxzOxxYCYwyMxKzezGsGuqx1nAN6n5DfjwbX+XhV3UceQB75jZJ8BH1KxhxPztqnGiBzDDzD4G5gAvufurIdfUkO8BjwZ/H0YAPw+3nOMzsw7ARdT8xh6zghnb08A8YCE1P99btEWIbqsVEZFG0QxDREQaRYEhIiKNosAQEZFGUWCIiEijKDBERKRRFBgiItIoCgwREWmU/w+qUyJZFsQygwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 5 to 10 percent as threshold\n",
    "print(np.min(paraPDE_Losses-PDE_Losses)/PDE_Losses[np.argmin(paraPDE_Losses-PDE_Losses)])\n",
    "plt.plot(sorted(st.track.keys()), paraPDE_Losses-PDE_Losses)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if dependent == \"temporal\":\n",
    "    plt.plot(t, com2paracoeff[2][list(st.track[2][0])][0])\n",
    "    plt.plot(t, com2paracoeff[2][list(st.track[2][0])][1])\n",
    "elif dependent == \"spatial\":\n",
    "    plt.plot(x, com2paracoeff[2][list(st.track[2][0])][0])\n",
    "    plt.plot(x, com2paracoeff[2][list(st.track[2][0])][1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 -> 50\n",
      "1 -> 51\n",
      "2 -> 52\n",
      "3 -> 53\n",
      "4 -> 54\n",
      "5 -> 55\n",
      "6 -> 56\n",
      "7 -> 57\n",
      "8 -> 58\n",
      "9 -> 59\n",
      "10 -> 60\n",
      "11 -> 61\n",
      "12 -> 62\n",
      "13 -> 63\n",
      "14 -> 64\n",
      "15 -> 65\n",
      "16 -> 66\n",
      "17 -> 67\n",
      "18 -> 68\n",
      "19 -> 69\n",
      "20 -> 70\n",
      "21 -> 71\n",
      "22 -> 72\n",
      "23 -> 73\n",
      "24 -> 74\n",
      "25 -> 75\n",
      "26 -> 76\n",
      "27 -> 77\n",
      "28 -> 78\n",
      "29 -> 79\n",
      "30 -> 80\n",
      "31 -> 81\n",
      "32 -> 82\n",
      "33 -> 83\n",
      "34 -> 84\n",
      "35 -> 85\n",
      "36 -> 86\n",
      "37 -> 87\n",
      "38 -> 88\n",
      "39 -> 89\n",
      "40 -> 90\n",
      "41 -> 91\n",
      "42 -> 92\n",
      "43 -> 93\n",
      "44 -> 94\n",
      "45 -> 95\n",
      "46 -> 96\n",
      "47 -> 97\n",
      "48 -> 98\n",
      "49 -> 99\n",
      "50 -> 100\n"
     ]
    }
   ],
   "source": [
    "maxi = np.max(t); mini = np.min(t)\n",
    "mid = (mini+maxi)/2\n",
    "ss = np.arange(0, len(t)-(list(t).index(mid)), dtype=np.int)\n",
    "\n",
    "com2coeff_sub = {}\n",
    "for s in ss:\n",
    "    t_sub_indices = [i+s for i in range(list(t).index(mid)+1)]\n",
    "    t_sub = t[t_sub_indices]\n",
    "    un_sub = (un.copy())[:, t_sub_indices]\n",
    "    print(t_sub_indices[0], \"->\", t_sub_indices[-1])\n",
    "\n",
    "    diff_lib = ps.PDELibrary(library_functions=library_functions, \n",
    "                             function_names=library_function_names, \n",
    "                             derivative_order=2, \n",
    "                             spatial_grid=x, \n",
    "                             is_uniform=True, \n",
    "                             differentiation_method=KalmanDiff, \n",
    "                             differentiation_kwargs=differentiation_kwargs)\n",
    "\n",
    "    candidate_lib_sub = diff_lib.fit_transform(np.expand_dims(un_sub, -1))\n",
    "    candidate_lib_sub = candidate_lib_sub.reshape(-1, candidate_lib_sub.shape[-1])\n",
    "    dynamics_sub = diff_lib.differentiation_method(**diff_lib.differentiation_kwargs, \n",
    "                                                   axis=1)._differentiate(un_sub, \n",
    "                                                                          t_sub).reshape(-1,1)\n",
    "    \n",
    "    Theta_grouped_sub, Ut_grouped_sub = spatial_temporal_group(candidate_lib_sub, dynamics_sub, \n",
    "                                                               (len(x), len(t_sub)), \n",
    "                                                               dependent=dependent)\n",
    "    \n",
    "    for com in sorted(st.track.keys()):\n",
    "        indices, _ = st.track[com]\n",
    "        \n",
    "        coeff = np.hstack([np.linalg.lstsq(Theta_grouped_sub[_][:, indices], \n",
    "                                           Ut_grouped_sub[_], \n",
    "                                           rcond=None)[0] for _ in range(len(Theta_grouped_sub))])\n",
    "\n",
    "#         coeff = np.zeros(shape=(candidate_lib_sub.shape[-1], 1))\n",
    "#         coeff[list(indices)] = np.linalg.lstsq(candidate_lib_sub[:, indices], dynamics_sub)[0]\n",
    "#         coeff = np.hstack([coeff for _ in range(n)])\n",
    "\n",
    "        coeff = np.expand_dims(coeff, 0)\n",
    "        if com not in com2coeff_sub: \n",
    "            com2coeff_sub[com] = coeff\n",
    "        else: \n",
    "            com2coeff_sub[com] = np.vstack((com2coeff_sub[com], coeff))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvs = np.zeros((len(st.track.keys()), len(diff_lib.get_feature_names())))\n",
    "for com in sorted(st.track.keys()):\n",
    "    indices, _ = st.track[com]\n",
    "    cv_com = np.zeros(len(diff_lib.get_feature_names()))\n",
    "    \n",
    "    ### treat a seq of coeff values in one horizon as a mean constant number ###\n",
    "    # mh_coeffs = np.mean(com2coeff_sub[com], axis=-1)\n",
    "    # cv_com[list(indices)] = np.abs(np.std(mh_coeffs, axis=0)/np.mean(mh_coeffs, axis=0))\n",
    "    \n",
    "    ### mean over the horizon axis as well\n",
    "    cv_com[list(indices)] = np.abs(com2coeff_sub[com].std(axis=0)/com2coeff_sub[com].mean(axis=0)).mean(axis=-1)\n",
    "    \n",
    "    cvs[com-1] = cv_com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4, 6, 7}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxp = 10 # 10 for aic | 100 for BIC\n",
    "maxp_step = 0.01\n",
    "agg_PDE_Losses_cv = []\n",
    "\n",
    "for p in np.arange(0., maxp+maxp_step, maxp_step):\n",
    "    PDE_Losses_cv = []\n",
    "    for com in sorted(st.track.keys()):\n",
    "        PDE_Loss = PDE_FIND_Loss(Theta_grouped, Ut_grouped, com2coeff[com], \n",
    "                                 cv=p*cvs.sum(axis=-1)[com-1], ic_type='bic', version=1)\n",
    "        PDE_Losses_cv.append(PDE_Loss)\n",
    "    agg_PDE_Losses_cv.append(PDE_Losses_cv)\n",
    "# consider min -> max\n",
    "set(np.argmin(agg_PDE_Losses_cv, axis=-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(len(agg_PDE_Losses_cv)):\n",
    "    plt.plot([i for i in range(1,9)], agg_PDE_Losses_cv[i], c='blue')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "from scipy.stats import gamma\n",
    "from scipy.optimize import curve_fit\n",
    "\n",
    "# FFT stuff\n",
    "def convert2fspace(sig):\n",
    "    return np.fft.fftn(sig, s=sig.shape)\n",
    "\n",
    "def convert2tspace(sig):\n",
    "    return np.fft.ifft(sig, s=sig.shape)\n",
    "\n",
    "def cal_psd(sig):\n",
    "    return (np.abs(sig)**2)/np.prod(sig.shape)\n",
    "\n",
    "def remove_high_f(f_space, z, mode='gaussian'):\n",
    "    f_space_clean = f_space.copy()\n",
    "    psd = cal_psd(f_space_clean)\n",
    "    upper_bound = -1.0\n",
    "    if mode == 'gaussian':\n",
    "        upper_bound = psd.mean()+z*psd.std()\n",
    "    elif mode == 'tukey':\n",
    "        q1, q3 = np.percentile(psd, [25, 75])\n",
    "        upper_bound = q3+z*1e4*(q3-q1)\n",
    "    f_space_clean[psd>upper_bound] = 0j\n",
    "    return f_space_clean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "remove_f_mode = 'gaussian'\n",
    "\n",
    "bic_collections = []\n",
    "ff_dynamics = f_dynamics.reshape(-1,1)\n",
    "for kkk in range(3, 11, 3): # or range(3, 6, 1)\n",
    "    bics = []\n",
    "    ff_candidate_lib = remove_high_f(f_candidate_lib, kkk, mode=remove_f_mode)\n",
    "    ff_candidate_lib = ff_candidate_lib.reshape(-1, ff_candidate_lib.shape[-1])\n",
    "    \n",
    "    for com in sorted(st.track.keys()):\n",
    "        indices, _ = st.track[com]\n",
    "        coeff = np.linalg.lstsq(ff_candidate_lib[:, indices], ff_dynamics)[0]\n",
    "        pred = candidate_lib[:, indices]@coeff\n",
    "        bic = BIC_AIC(pred, dynamics, com+cvs.sum(axis=-1)[com-1])[0]\n",
    "        bics.append(bic)\n",
    "\n",
    "    bic_collections.append(bics)\n",
    "\n",
    "print(np.argmin(np.average(bic_collections, axis=0))+1)\n",
    "for i in range(len(bic_collections)):\n",
    "    plt.plot(range(1, 9), bic_collections[i])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.661069524991966e-10 170\n"
     ]
    }
   ],
   "source": [
    "# Generate some sample data\n",
    "data = cal_psd(f_candidate_lib).flatten()\n",
    "\n",
    "# Define the gamma probability density function (PDF)\n",
    "def gamma_pdf(x, a, loc, scale):\n",
    "    return gamma.pdf(x, a, loc, scale)\n",
    "\n",
    "# Fit the gamma PDF to the normalized histogram of the data using curve_fit\n",
    "best_mse_fit = 1e6; best_popt = None\n",
    "for n_bins in range(10, 500, 10):\n",
    "    hist, bin_edges = np.histogram(data, bins=n_bins, density=True)\n",
    "    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.0\n",
    "    try: \n",
    "        popt, pcov = curve_fit(gamma_pdf, bin_centers, hist)\n",
    "        # Extract the fitted parameters\n",
    "        mse_fit = ((hist-gamma_pdf(bin_centers, *popt))**2).mean()\n",
    "        if mse_fit < best_mse_fit:\n",
    "            best_mse_fit = mse_fit\n",
    "            best_popt = popt\n",
    "            print(mse_fit, n_bins)\n",
    "    except RuntimeError:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def remove_high_f_dist(f_space, z, dist, best_popt):\n",
    "    f_space_clean = f_space.copy()\n",
    "    psd = cal_psd(f_space_clean)\n",
    "    # gaussian way\n",
    "    f_space_clean[dist(psd, *best_popt)<z] = 0j\n",
    "    return f_space_clean\n",
    "\n",
    "bic_collections = []\n",
    "ff_dynamics = f_dynamics.reshape(-1,1)\n",
    "aaa = 1e-3 # 1e-1, 1e-2, 1e-3\n",
    "for kkk in [aaa, aaa/10, aaa/100]:\n",
    "    bics = []\n",
    "    ff_candidate_lib = remove_high_f_dist(f_candidate_lib, kkk, gamma.sf, best_popt)\n",
    "    ff_candidate_lib = ff_candidate_lib.reshape(-1, ff_candidate_lib.shape[-1])\n",
    "    \n",
    "    for com in sorted(st.track.keys()):\n",
    "        indices, _ = st.track[com]\n",
    "        coeff = np.linalg.lstsq(ff_candidate_lib[:, indices], ff_dynamics)[0]\n",
    "        pred = candidate_lib[:, indices]@coeff\n",
    "        bic = BIC_AIC(pred, dynamics, com+cvs.sum(axis=-1)[com-1])[0]\n",
    "        # bic = BIC_AIC(pred, dynamics, com+cvs.sum(axis=-1)[com-1], ic_type='bic', version=1)[0]\n",
    "        bics.append(bic)\n",
    "\n",
    "    bic_collections.append(bics)\n",
    "\n",
    "print(np.argmin(np.average(bic_collections, axis=0))+1)\n",
    "for i in range(len(bic_collections)):\n",
    "    plt.plot(range(1, 9), bic_collections[i])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "Stop right here!",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m Stop right here!\n"
     ]
    }
   ],
   "source": [
    "raise SystemExit(\"Stop right here!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_pre = np.zeros(X_pre.shape)\n",
    "y_pre = np.zeros(y_pre.shape)\n",
    "n_times = 10\n",
    "weak_coeffs = []\n",
    "for _ in range(n_times):\n",
    "    weak_pde_lib = ps.WeakPDELibrary(library_functions=[lambda x: x, lambda x: x * x], \n",
    "                                     function_names=[lambda x: x, lambda x: x + x], \n",
    "                                     derivative_order=diff_order, p=diff_order, \n",
    "                                     spatiotemporal_grid=XT, \n",
    "                                     include_bias=False, is_uniform=True, K=10000, \n",
    "                                     differentiation_method=differentiation_method, \n",
    "                                     differentiation_kwargs=differentiation_kwargs, \n",
    "                                     cache=True\n",
    "                                    )\n",
    "    kwargs = {'fit_intercept':False, 'copy_X':True, 'normalize_columns':False}\n",
    "    # Apply moving horizon to un is an interesting idea.\n",
    "    X_pre_sub, y_pre_sub, fns = ps_features(un, t, weak_pde_lib, kwargs)\n",
    "    X_pre = X_pre + X_pre_sub\n",
    "    y_pre = y_pre + y_pre_sub\n",
    "    optimizer = L0BNB(max_nonzeros=2, lam=1e-3, is_normal=True, normalize_columns=False)\n",
    "    n_ensemble_models = 50\n",
    "    model = ps.SINDy(feature_library=weak_pde_lib, optimizer=optimizer, \n",
    "                     differentiation_method=KalmanDiff(alpha=kalpha, poly_deg=poly_deg, rpca_lambda=rpca_lambda, axis=0, is_uniform=True), \n",
    "                     cache=True,\n",
    "                     feature_names=['u'])\n",
    "    model.fit(np.expand_dims(un, -1), t=dt, ensemble=True, \n",
    "              library_ensemble=True, n_candidates_to_drop=1, n_models=n_ensemble_models)\n",
    "    ols_model, eff_rhs_indices = model.validate_coef_list()[0]\n",
    "    print(np.array([convert2latex(f) for i,f in enumerate(model.get_feature_names()) if i in eff_rhs_indices]))\n",
    "    print(ols_model.params)\n",
    "    # percent_coeff = evaluate_coefficients(ols_model.params)\n",
    "    # print(percent_coeff)\n",
    "    # if percent_coeff[0] > 100: break\n",
    "    weak_coeffs.append(ols_model.params)\n",
    "weak_coeffs = np.array(weak_coeffs)\n",
    "avg_weak_coeff = np.mean(weak_coeffs, axis=0)\n",
    "X_pre = X_pre/n_times\n",
    "y_pre = y_pre/n_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RDAE 5e-0: cv = 0.005062929348375081, 0.011023507990422338\n",
    "# RDAE 1e-0: cv = 0.004408008789094885, 0.00910193468516509\n",
    "# RDAE 5e-1: cv = 0.003467511174737858, 0.008040505161991068\n",
    "# RDAE 5e-2: cv = 0.004305311364345706, 0.007809099375818377\n",
    "\n",
    "cv_abs = (weak_coeffs.std(axis=0)/np.abs(weak_coeffs.mean(axis=0))).mean()\n",
    "cv = (weak_coeffs.std(axis=0)/weak_coeffs.mean(axis=0)).mean()\n",
    "cv, cv_abs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 50 percent noise\n",
    "# Robust PCA: (14.745720655392669, 6.347415766367691)\n",
    "# RDAE failed...\n",
    "\n",
    "# 40 percent noise\n",
    "# Robust PCA: (14.818002368919029, 7.899799685479938)\n",
    "# RDAE 5e-0: (2.9505659028666087, 1.8024006266427972)\n",
    "# RDAE 1e-0: (3.2008235132427463, 2.56690175990938)\n",
    "# RDAE 5e-1: (2.469185388081714, 1.7166311808760781)\n",
    "# RDAE 5e-2: (6.015975755333656, 5.859365864415776)\n",
    "# RDAE 5e-3: Failed\n",
    "\n",
    "evaluate_coefficients(avg_weak_coeff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_coeff(pred, ground):\n",
    "    return 100*np.abs(pred-ground)/np.abs(ground)\n",
    "print(avg_weak_coeff)\n",
    "errs = percent_coeff(avg_weak_coeff, np.array([0.1, -1]))\n",
    "errs.mean(), errs.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.linalg.lstsq(X_pre[:, [3,4]], y_pre, rcond=None)[0].flatten())\n",
    "evaluate_coefficients(np.linalg.lstsq(X_pre[:, [3,4]], y_pre, rcond=None)[0].flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_subsets = sorted([indices for _, (indices, _) in st.track.items()], key=lambda _: len(_))\n",
    "tmp = np.zeros((len(best_subsets), X_pre.shape[-1]))\n",
    "for i in range(len(best_subsets)):\n",
    "    tmp[i:i+1, :][0, best_subsets[i]] = 1.0\n",
    "best_subsets = tmp.astype(np.float32)\n",
    "del tmp\n",
    "\n",
    "pms_data = {nameof(un): un, \n",
    "            nameof(X_pre): X_pre, \n",
    "            nameof(y_pre): y_pre, \n",
    "            nameof(avg_weak_coeff): avg_weak_coeff, \n",
    "            nameof(best_subsets): best_subsets}\n",
    "pms_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_vars = {'u'}\n",
    "encoded_feature_names = []\n",
    "for feature in model.get_feature_names():\n",
    "    out_feature = []\n",
    "    last_index = -1\n",
    "    for i, c in enumerate(feature):\n",
    "        if i+1 < len(feature) and feature[i+1] in basic_vars:\n",
    "            last_index = i\n",
    "            out_feature.append(c+'*')\n",
    "    out_feature.append(feature[last_index+1:])\n",
    "    encoded_feature_names.append(''.join(out_feature))\n",
    "encoded_feature_names = np.array(encoded_feature_names)\n",
    "encoded_feature_names.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com in sorted(st.track.keys()):\n",
    "    indices, _ = st.track[com]\n",
    "    expr = '+'.join(encoded_feature_names[list(indices)])\n",
    "    print(expr)\n",
    "    print('----------')\n",
    "encoded_pde_names = ['+'.join(encoded_feature_names[list(indices)]) for _, (indices, _) \n",
    "                     in sorted(st.track.items())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "from omegaconf import OmegaConf\n",
    "yml = {}\n",
    "yml[\"encoded_feature_names\"] = encoded_feature_names.tolist()\n",
    "yml[\"encoded_pde_names\"] = encoded_pde_names\n",
    "yml[\"information_criterion_score\"] = [float(ic) for _, (_, ic) in st.track.items()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save files for training PINNs & DeepONets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fp1 = f\"../PMS_data/{denoising_mode}/{smoother_name}/transform_n_nonzero_coefs{transform_n_nonzero}/burgers_pms_noise30_dictlearn{n_components}.h5\"\n",
    "fp2 = f\"../PMS_data/{denoising_mode}/{smoother_name}/transform_n_nonzero_coefs{transform_n_nonzero}/burgers_pms_feature_names_noise30_dictlearn{n_components}.yaml\"\n",
    "fp1, fp2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h5file(file_path=fp1, cdict=pms_data, mode='w')\n",
    "OmegaConf.save(config=OmegaConf.create(yml), f=fp2)\n",
    "yml2 = OmegaConf.load(fp2)\n",
    "X_pre_rev, avg_weak_coeff, best_subsets, un, y_pre_rev = h5file(file_path=fp1, mode='r', return_dict=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.linalg.lstsq(X_pre_rev[:, [3,4]], y_pre_rev, rcond=None)[0].flatten())\n",
    "evaluate_coefficients(np.linalg.lstsq(X_pre_rev[:, [3,4]], y_pre_rev, rcond=None)[0].flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Physics-informed model selection.... (2 options)\n",
    "    - Fixed coefficients + learned diffivative values (by autodiff)\n",
    "    - Fixed polynomial candidate values (following feature_names: ['u', 'uu', 'u_1', 'u_11', 'uu_1', 'uuu_1', 'uu_11', 'uuu_11']) + learned coefficients"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:pysr]",
   "language": "python",
   "name": "conda-env-pysr-py"
  },
  "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.10.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}