Examples/Burgers-now-20230218-without-RPCA-DCTKSVDREG.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, wiener\n",
    "from scipy.integrate import trapz\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\n",
    "\n",
    "from findiff import FinDiff\n",
    "from tqdm import tqdm, trange"
   ]
  },
  {
   "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 = 'dctksvd_reg' # 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}_8x8.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.010 uu_1\n",
      "u_t = (0.107289 +0.000000i)u_11\n",
      "    + (-1.018068 +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.105158 +0.000000i)u_11\n",
      "    + (-1.009547 +0.000000i)uu_1\n",
      "   \n",
      "['u_{xx}' 'uu_{x}']\n",
      "[ 0.10515842 -1.00954748]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3.05658148186686, 2.101833972875855)"
      ]
     },
     "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) # (3.05658148186686, 2.101833972875855)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.940388 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.105158 +0.000000i)u_11\n",
      "    + (-1.009547 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.099087 +0.000000i)u_11\n",
      "    + (-1.017038 +0.000000i)uu_1\n",
      "    + (0.014869 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.018631 +0.000000i)uu\n",
      "    + (0.095780 +0.000000i)u_11\n",
      "    + (-1.032028 +0.000000i)uu_1\n",
      "    + (0.038091 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.016717 +0.000000i)uu\n",
      "    + (0.094719 +0.000000i)u_11\n",
      "    + (-1.088811 +0.000000i)uu_1\n",
      "    + (0.119994 +0.000000i)uuu_1\n",
      "    + (0.037348 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.023954 +0.000000i)uu\n",
      "    + (0.083135 +0.000000i)u_11\n",
      "    + (-1.121421 +0.000000i)uu_1\n",
      "    + (0.163160 +0.000000i)uuu_1\n",
      "    + (0.133131 +0.000000i)uu_11\n",
      "    + (-0.102052 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.008792 +0.000000i)u\n",
      "    + (-0.005951 +0.000000i)u_1\n",
      "    + (0.081294 +0.000000i)u_11\n",
      "    + (-1.098481 +0.000000i)uu_1\n",
      "    + (0.157595 +0.000000i)uuu_1\n",
      "    + (0.137230 +0.000000i)uu_11\n",
      "    + (-0.117746 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.008792 +0.000000i)u\n",
      "    + (-0.005951 +0.000000i)u_1\n",
      "    + (0.081294 +0.000000i)u_11\n",
      "    + (-1.098481 +0.000000i)uu_1\n",
      "    + (0.157595 +0.000000i)uuu_1\n",
      "    + (0.137230 +0.000000i)uu_11\n",
      "    + (-0.117746 +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",
      "(1, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(1, 3, 4, 5, 6)\n",
      "(1, 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.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 improves 1\n",
      "Percent improve: 0.19588787697667887\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0006214688433183032\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\n",
      "2 does not improve 1\n",
      "Percent improve: 0.19588787697667887\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",
      "-12676.295143150885\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([-64711.99412029, -77388.28926344, -77428.21458313, -77484.47808467,\n",
       "        -77515.25671617, -77570.27683442]),\n",
       " array([1, 2, 3, 4, 5, 6]),\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}']])"
      ]
     },
     "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": "markdown",
   "metadata": {},
   "source": [
    "#### Consider uncert from BayesianRidge (brr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  4.88250004   3.28388601   6.65940484  11.20275259  35.4989171\n",
      "  66.30036235 109.18642581 123.38069826]\n",
      "2\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\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": [
    "baye_alpha = 1e-6\n",
    "mul_val = 1\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",
    "    uncert = mul_val*np.trace(np.sqrt(brr.sigma_))\n",
    "    brr_uncertainties.append(uncert)\n",
    "    brr_bics.append((brr.predict(X_pre[:, st.track[com][0]]).reshape(-1, 1), \n",
    "                     np.count_nonzero(brr.coef_), \n",
    "                     uncert))\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",
    "mul_val = 10**power\n",
    "brr_uncertainties = brr_uncertainties*mul_val\n",
    "print(brr_uncertainties)\n",
    "\n",
    "for kkk in range(1, 10):\n",
    "    brr_bicaics = [BIC_AIC(brr_pred, y_pre, brr_com+kkk*mul_val*brr_uncert)[0] \n",
    "                   for brr_pred, brr_com, brr_uncert in brr_bics]\n",
    "    print(np.argmin(brr_bicaics))\n",
    "    plt.plot(brr_bicaics)\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": 26,
   "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": 27,
   "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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.013445847744009854\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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 5, 7}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxp = 100 # 10 for aic | 100 for BIC\n",
    "maxp_step = 0.1\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": 33,
   "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": 34,
   "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": 35,
   "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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.600889011733283e-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": 37,
   "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: Tune (p, q), ws"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weight_poly(x, m, k):\n",
    "    \"\"\"\n",
    "    Polynomial piece of weighting function used to satisfy BC A = d^k/dx^k[(x^2 - 1)^m]\n",
    "    x: independent variable\n",
    "    m: power of base function\n",
    "    k: order of derivative\n",
    "    \"\"\"\n",
    "    a = np.zeros((2*m+1, 1)) # initial coefficient vector\n",
    "    for l in range(m+1):\n",
    "        a[2*l] = ((-1)**(m-l))*np.math.comb(m, l) # set polynomial coefficients\n",
    "    \n",
    "    c = np.zeros((2*m+1, 1)) # final coefficient vector\n",
    "    for n in range(2*m-k+1):\n",
    "        c[n] = a[n+k]*np.math.factorial(n+k)/np.math.factorial(n)\n",
    "    \n",
    "    p = 0\n",
    "    for n in range(2*m-k+1):\n",
    "        p += c[n]*(x**n) # final windowing function\n",
    "\n",
    "    return p\n",
    "\n",
    "def weight_full(k, p, x, t):\n",
    "    \"\"\"\n",
    "    Assemble the 1D weight functions into the full weight\n",
    "    k = [kx,ky,kt]: order of derivative(s)\n",
    "    p = [px,py,pt]: exponents of weight polynomials\n",
    "    \"\"\"\n",
    "    if len(k) == 3:\n",
    "        wx = weight_poly(x, p[0], k[0])\n",
    "        wy = weight_poly(x, p[1], k[1])\n",
    "        wt = weight_poly(t, p[2], k[2])\n",
    "        wX, wY, wT = np.meshgrid(wx, wy, wt)\n",
    "        W = wX * wY * wT\n",
    "    elif len(k) == 2:\n",
    "        wx = weight_poly(x, p[0], k[0])\n",
    "        wt = weight_poly(t, p[1], k[1])\n",
    "        wT, wX = np.meshgrid(wt, wx)\n",
    "        W = wX * wT\n",
    "    \n",
    "    return W, wx, wt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "u_weak = un.copy()\n",
    "n_domain = 10000\n",
    "div = 3.5\n",
    "x_size, t_size = int(max(u_weak.shape)/div), int(max(u_weak.shape)/div)\n",
    "\n",
    "xsup = np.linspace(-1,1,x_size+1)\n",
    "tsup = np.linspace(-1,1,t_size+1)\n",
    "S_x = 2/(dx*x_size)\n",
    "S_t = 2/(dt*t_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Numba: Attempted to fork from a non-main thread, the TBB library may be in an invalid state in the child process.\n",
      "100%|███████████████████████████████████████████████████████████| 10000/10000 [00:02<00:00, 4022.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2.635646814962908e-07 (0.6329005501340843, 0.16667656491581168)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████| 10000/10000 [00:02<00:00, 4321.52it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1.512632115600827e-07 (0.056665324122559535, 0.02299620990049711)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████| 10000/10000 [00:02<00:00, 4184.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "1.7069969792818892e-07 (0.044135567416853094, 0.028855968627244932)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([ 0.09996633, -0.99920338]),\n",
       " (0.056665324122559535, 0.02299620990049711))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_order = 2\n",
    "best_loss = 1e6; best_coeff = None\n",
    "for mo in range(max_order, max_order+10, 1):\n",
    "    wx, wt = np.meshgrid((xsup**2-1)**mo, (tsup**2-1)**(mo-1))\n",
    "    W = (wx*wt).T\n",
    "    \n",
    "    # Define the derivative:\n",
    "    d_dx = FinDiff(0, xsup[1]-xsup[0], 1)\n",
    "    d_dxx = FinDiff(0, xsup[1]-xsup[0], 2)\n",
    "    d_dxxxx = FinDiff(0, xsup[1]-xsup[0], 4)\n",
    "    d_dt = FinDiff(1, tsup[1]-tsup[0], 1)\n",
    "\n",
    "    dA01 = d_dt(W)\n",
    "    dA10 = d_dx(W)\n",
    "    dA20 = d_dxx(W)\n",
    "    dA40 = d_dxxxx(W)\n",
    "\n",
    "    X_weak = []\n",
    "    y_weak = []\n",
    "    for _ in trange(n_domain):\n",
    "        ix = np.random.randint(0, len(x)-x_size, size=1)[0] + np.arange(0, x_size+1)\n",
    "        it = np.random.randint(0, len(t)-t_size, size=1)[0] + np.arange(0, t_size+1)\n",
    "\n",
    "        usup = (u_weak[ix, :][:, it])\n",
    "\n",
    "        f1 = -(1/2)*(usup**2)*dA10*S_x\n",
    "        f1 = trapz(trapz(f1, tsup, dt, 1), xsup, dx, 0)\n",
    "\n",
    "        f2 = usup*dA20*(S_x**2)\n",
    "        f2 = trapz(trapz(f2, tsup, dt, 1), xsup, dx, 0)\n",
    "\n",
    "        X_weak.append([f2, f1])\n",
    "\n",
    "        f4 = -usup*dA01*S_t\n",
    "        f4 = trapz(trapz(f4, tsup, dt, 1), xsup, dx, 0)\n",
    "        y_weak.append(f4)\n",
    "\n",
    "    X_weak = np.array(X_weak)\n",
    "    y_weak = np.array(y_weak)\n",
    "\n",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    loss = ((X_weak@coeff-y_weak)**2).mean()\n",
    "\n",
    "    print(mo)\n",
    "    print(loss, evaluate_coefficients(coeff))\n",
    "    if loss < best_loss:\n",
    "        best_loss = loss\n",
    "        best_coeff = coeff\n",
    "    else:\n",
    "        break\n",
    "\n",
    "best_coeff, evaluate_coefficients(best_coeff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Savgol_filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████| 15/15 [01:32<00:00,  6.13s/it]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1.7180848493523203e-07,\n",
       " array([ 0.09999214, -1.00084266]),\n",
       " (0.04606205985549505, 0.03820344646573992))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wx, wt = np.meshgrid((xsup**2-1)**(mo-1), (tsup**2-1)**(mo-1))\n",
    "W = wx*wt\n",
    "\n",
    "# Define the derivative:\n",
    "d_dx = FinDiff(0, xsup[1]-xsup[0], 1, acc=4)\n",
    "d_dxx = FinDiff(0, xsup[1]-xsup[0], 2, acc=4)\n",
    "d_dxxxx = FinDiff(0, xsup[1]-xsup[0], 4, acc=4)\n",
    "d_dt = FinDiff(1, tsup[1]-tsup[0], 1, acc=4)\n",
    "\n",
    "dA01 = d_dt(W)\n",
    "dA10 = d_dx(W)\n",
    "dA20 = d_dxx(W)\n",
    "dA40 = d_dxxxx(W)\n",
    "\n",
    "min_loss = 1e6; best_coeff = None\n",
    "for ws in trange(3, 33, 2):\n",
    "    X_weak = []\n",
    "    y_weak = []\n",
    "    for _ in range(n_domain):\n",
    "        ix = np.random.randint(0, len(x)-x_size, size=1)[0] + np.arange(0, x_size+1)\n",
    "        it = np.random.randint(0, len(t)-t_size, size=1)[0] + np.arange(0, t_size+1)\n",
    "        \n",
    "        usup = savgol_filter(u_weak[ix, :][:, it], ws, 2)\n",
    "\n",
    "        f1 = -(1/2)*(usup**2)*dA10*S_x\n",
    "        f1 = trapz(trapz(f1, tsup, 1), xsup, 0)\n",
    "\n",
    "        f2 = usup*dA20*(S_x**2)\n",
    "        f2 = trapz(trapz(f2, tsup, 1), xsup, 0)\n",
    "\n",
    "        X_weak.append([f2, f1])\n",
    "\n",
    "        f4 = -usup*dA01*S_t\n",
    "        f4 = trapz(trapz(f4, tsup, 1), xsup, 0)\n",
    "        y_weak.append(f4)\n",
    "\n",
    "    X_weak = np.array(X_weak)\n",
    "    y_weak = np.array(y_weak)\n",
    "    \n",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    loss = ((X_weak@coeff-y_weak)**2).mean()\n",
    "    if loss < min_loss:\n",
    "        min_loss = loss\n",
    "        best_coeff = coeff\n",
    "\n",
    "# Maybe do simulation next? | 1.0553637050127729e-08\n",
    "min_loss, best_coeff, evaluate_coefficients(best_coeff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### wiener"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████| 30/30 [04:16<00:00,  8.56s/it]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1.727670018665707e-07,\n",
       " array([ 0.10046543, -1.0034009 ]),\n",
       " (0.4027586839031899, 0.06266909774915452))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min_loss = 1e6; best_coeff = None\n",
    "for ws in trange(3, 33, 1):\n",
    "    X_weak = []\n",
    "    y_weak = []\n",
    "    for _ in range(n_domain):\n",
    "        ix = np.random.randint(0, len(x)-x_size, size=1)[0] + np.arange(0, x_size+1)\n",
    "        it = np.random.randint(0, len(t)-t_size, size=1)[0] + np.arange(0, t_size+1)\n",
    "        \n",
    "        usup = wiener(u_weak[ix, :][:, it], ws)\n",
    "\n",
    "        f1 = -(1/2)*(usup**2)*dA10*S_x\n",
    "        f1 = trapz(trapz(f1, tsup, 1), xsup, 0)\n",
    "\n",
    "        f2 = usup*dA20*(S_x**2)\n",
    "        f2 = trapz(trapz(f2, tsup, 1), xsup, 0)\n",
    "\n",
    "        X_weak.append([f2, f1])\n",
    "\n",
    "        f4 = -usup*dA01*S_t\n",
    "        f4 = trapz(trapz(f4, tsup, 1), xsup, 0)\n",
    "        y_weak.append(f4)\n",
    "\n",
    "    X_weak = np.array(X_weak)\n",
    "    y_weak = np.array(y_weak)\n",
    "    \n",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    loss = ((X_weak@coeff-y_weak)**2).mean()\n",
    "    if loss < min_loss:\n",
    "        min_loss = loss\n",
    "        best_coeff = coeff\n",
    "\n",
    "# Maybe do simulation next? | 1.0553637050127729e-08\n",
    "min_loss, best_coeff, evaluate_coefficients(best_coeff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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
}