Examples/Burgers-now-20230218-without-RPCA-SPMKSVD.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_ksvd' # ksvd, dictionary_learning\n",
    "    n_components = 32\n",
    "    smoother_name = 'none' # 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.105 u_11 + -1.011 uu_1\n",
      "u_t = (0.106337 +0.000000i)u_11\n",
      "    + (-1.014317 +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.104836 +0.000000i)u_11\n",
      "    + (-1.010667 +0.000000i)uu_1\n",
      "   \n",
      "['u_{xx}' 'uu_{x}']\n",
      "[ 0.10483604 -1.01066695]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2.951366904136575, 1.8846719890201133)"
      ]
     },
     "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.941689 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.104836 +0.000000i)u_11\n",
      "    + (-1.010667 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.098215 +0.000000i)u_11\n",
      "    + (-1.018875 +0.000000i)uu_1\n",
      "    + (0.016297 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.021533 +0.000000i)u_1\n",
      "    + (0.093943 +0.000000i)u_11\n",
      "    + (-0.965196 +0.000000i)uu_1\n",
      "    + (0.021642 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.018452 +0.000000i)uu\n",
      "    + (0.093481 +0.000000i)u_11\n",
      "    + (-1.097112 +0.000000i)uu_1\n",
      "    + (0.130590 +0.000000i)uuu_1\n",
      "    + (0.041017 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.026878 +0.000000i)uu\n",
      "    + (0.080185 +0.000000i)u_11\n",
      "    + (-1.134709 +0.000000i)uu_1\n",
      "    + (0.180147 +0.000000i)uuu_1\n",
      "    + (0.152535 +0.000000i)uu_11\n",
      "    + (-0.119200 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.009825 +0.000000i)u\n",
      "    + (-0.010408 +0.000000i)u_1\n",
      "    + (0.077793 +0.000000i)u_11\n",
      "    + (-1.087182 +0.000000i)uu_1\n",
      "    + (0.148418 +0.000000i)uuu_1\n",
      "    + (0.156911 +0.000000i)uu_11\n",
      "    + (-0.136024 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.009825 +0.000000i)u\n",
      "    + (-0.010408 +0.000000i)u_1\n",
      "    + (0.077793 +0.000000i)u_11\n",
      "    + (-1.087182 +0.000000i)uu_1\n",
      "    + (0.148418 +0.000000i)uuu_1\n",
      "    + (0.156911 +0.000000i)uu_11\n",
      "    + (-0.136024 +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, 6)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(2, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(1, 3, 4, 5, 6)\n",
      "(1, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(1, 3, 4, 5, 6, 7)\n",
      "(1, 3, 4, 6, 7)\n",
      "(1, 3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(0, 2, 3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6)\n",
      "(3, 4, 5, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(0, 2, 3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n",
      "(0, 1, 2, 3, 4, 5, 6, 7)\n",
      "(0, 2, 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, 6)\n",
      "(1, 3, 4, 6)\n",
      "(1, 3, 4, 6, 7)\n",
      "(0, 3, 4, 5, 6, 7)\n",
      "(0, 2, 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.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 improves 1\n",
      "Percent improve: 0.1587098458777827\n",
      "6 does not improve 2\n",
      "Percent improve: 0.000533403295139673\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1587098458777827\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": [
      "none 32\n",
      "-10080.063987776593\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([-63512.53088317, -73592.59487095, -73625.32504543, -73671.65305555,\n",
       "        -73702.73287732, -73749.61300136, -73750.57642216]),\n",
       " array([1, 2, 3, 4, 5, 6, 7]),\n",
       " [['uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}', 'uu_{xx}'],\n",
       "  ['u^2', 'u_{xx}', 'uu_{x}', 'uu_{xx}'],\n",
       "  ['u^2', 'u_{xx}', 'uu_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u', 'u_{x}', '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": "markdown",
   "metadata": {},
   "source": [
    "#### More model selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "com = 1, 5.187141243368387\n",
      "com = 2, 3.970781806856394\n",
      "com = 3, 8.035367354750633\n",
      "com = 4, 13.538455590605736\n",
      "com = 5, 42.64110326766968\n",
      "com = 6, 79.7097384929657\n",
      "com = 7, 130.97141683101654\n",
      "com = 8, 147.98396825790405\n"
     ]
    }
   ],
   "source": [
    "baye_alpha = 1e-6\n",
    "mul_val = 1e3\n",
    "brr_uncertainties = []\n",
    "brr_bics = []\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_bics.append(BIC_AIC(brr.predict(X_pre[:, st.track[com][0]]).reshape(-1, 1), \n",
    "                            y_pre, \n",
    "                            np.count_nonzero(brr.coef_)+mul_val*np.trace(np.sqrt(brr.sigma_)))[0])\n",
    "    brr_uncertainties.append(mul_val*np.trace(np.sqrt(brr.sigma_)))\n",
    "brr_uncertainties = np.array(brr_uncertainties)\n",
    "\n",
    "power = 0\n",
    "while 1:\n",
    "    e = brr_uncertainties.min()*(10**power)\n",
    "    if e > 1: break\n",
    "    power += 1\n",
    "brr_uncertainties = brr_uncertainties*(10**power)\n",
    "# brr_uncertainties\n",
    "assert power == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": [
    "for i in range(len(brr_bics)):\n",
    "    if brr_bics[i] < brr_bics[i+1]:\n",
    "        print(np.argmin(brr_bics[:i+1]))\n",
    "        break\n",
    "plt.plot(range(1, i+3), brr_bics[:i+2])\n",
    "plt.xticks(range(1, i+3))\n",
    "plt.show()"
   ]
  },
  {
   "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.00941057379026096\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": [
    "# 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": [
       "{1, 3, 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, 6, 1): # or range(3, 11, 3)\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": [
      "6.472264263983109e-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": "markdown",
   "metadata": {},
   "source": [
    "#### Denoised weak form"
   ]
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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
}