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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PDE-FIND for Burger's Equation\n",
    "\n",
    "Samuel Rudy, 2016\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",
    "# %pylab inline\n",
    "# pylab.rcParams['figure.figsize'] = (12, 8)\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": [],
   "source": [
    "# from matplotlib import cm\n",
    "# cmap_name = cm.get_cmap().name\n",
    "# print(\"cmap =\", cmap_name)\n",
    "\n",
    "# plt.contourf(X, T, u.T, levels=10, cmap=cmap_name)\n",
    "# plt.colorbar()\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig = figure()\n",
    "# ax = fig.gca(projection='3d')\n",
    "# ax.set_zlabel(\"$u$\", fontsize=20)\n",
    "# ax.set_xlabel(\"$x$\", fontsize=20)\n",
    "# ax.set_ylabel(\"$t$\", fontsize=20)\n",
    "# surf = ax.plot_surface(X, T, u.T, \n",
    "#                        rstride=1, cstride=1, cmap=cmap_name, \n",
    "#                        linewidth=1, antialiased=False)\n",
    "# # plt.title(\"Burgers' PDE\", fontsize=20)\n",
    "# # plt.savefig(fname=join_path(FIGURE_EXPORT_PATH, \"burgers3d.png\"), dpi=300)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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=True)\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": 6,
   "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": 7,
   "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": 8,
   "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": 8,
     "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": 9,
   "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": 10,
   "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": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "### also works ###\n",
    "# un, _ = RPCA(un, 6e-2)\n",
    "# un, _ = R_pca(un, lmbda=5e-2).fit(max_iter=5000, iter_print=1000)\n",
    "\n",
    "rpca_lambda = None; apply_savgol = False # Set to False for IBIS2022\n",
    "# rpca_lambda = 5e-2\n",
    "\n",
    "un_copy = un.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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 = 'ksvd' # ksvd, dictionary_learning\n",
    "    n_components = 32\n",
    "    smoother_name = 'none' # lowess, kalman, gaussian\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": [
    "#### Savgol before RPCA (Best with window length = 51, Seems to be tailored to perform well with highly noisy data)\n",
    "    - Need to test with other datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # divide into 2 5 10\n",
    "# apply_savgol = True\n",
    "# if apply_savgol:\n",
    "#     un_savgol = np.vstack([savgol_denoise(un[i:i+1, :], 51, 2) for i in range(un.shape[0])])\n",
    "#     print(mean_squared_error(u, un_savgol))\n",
    "#     un = un_savgol\n",
    "\n",
    "# rpca_lambda = None\n",
    "# rpca_lambda = 5e-2\n",
    "# if rpca_lambda is not None:\n",
    "#     rpca = RobustPCA(lamb=rpca_lambda, tol=10, use_fbpca=True, max_iter=int(1e6))\n",
    "#     un_copy = un.copy()\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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Avg weak coef from 10 runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "kalpha = 1e-1; poly_deg = None; diff_order = 2\n",
    "\n",
    "# differentiation_method = ps.FiniteDifference\n",
    "# differentiation_kwargs = {}\n",
    "\n",
    "differentiation_method = KalmanDiff\n",
    "differentiation_kwargs = {\"alpha\":kalpha, \"poly_deg\":poly_deg, \"rpca_lambda\":None}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "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.106132 +0.000000i)u_11\n",
      "    + (-1.011114 +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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (0.104816 +0.000000i)u_11\n",
      "    + (-1.011171 +0.000000i)uu_1\n",
      "   \n",
      "['u_{xx}' 'uu_{x}']\n",
      "[ 0.10481595 -1.01117145]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2.966546839959899, 1.8494019586055508)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For poster: No savgol before or after RPCA\n",
    "# u_t = (0.094309 +0.000000i)u_11\n",
    "#     + (-0.851764 +0.000000i)uu_1\n",
    "# For future Savgol (win_len = 11) after RPCA (performance little bit better)\n",
    "# u_t = (0.094646 +0.000000i)u_11\n",
    "#     + (-0.859442 +0.000000i)uu_1\n",
    "# model.validate_coef_list()\n",
    "# model.validate_coef_list(X_pre, y_pre)\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",
    "evaluate_coefficients(ols_model.params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.942209 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.104816 +0.000000i)u_11\n",
      "    + (-1.011171 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.100787 +0.000000i)u_11\n",
      "    + (-1.017165 +0.000000i)uu_1\n",
      "    + (0.016204 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.018422 +0.000000i)u_1\n",
      "    + (0.094810 +0.000000i)u_11\n",
      "    + (-0.973144 +0.000000i)uu_1\n",
      "    + (0.020156 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.017310 +0.000000i)uu\n",
      "    + (-0.013876 +0.000000i)u_1\n",
      "    + (0.092668 +0.000000i)u_11\n",
      "    + (-0.998420 +0.000000i)uu_1\n",
      "    + (0.040552 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.026035 +0.000000i)uu\n",
      "    + (0.081807 +0.000000i)u_11\n",
      "    + (-1.127324 +0.000000i)uu_1\n",
      "    + (0.166981 +0.000000i)uuu_1\n",
      "    + (0.140399 +0.000000i)uu_11\n",
      "    + (-0.106872 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.007562 +0.000000i)u\n",
      "    + (0.006426 +0.000000i)uu\n",
      "    + (0.080515 +0.000000i)u_11\n",
      "    + (-1.137705 +0.000000i)uu_1\n",
      "    + (0.196060 +0.000000i)uuu_1\n",
      "    + (0.145902 +0.000000i)uu_11\n",
      "    + (-0.122223 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.007562 +0.000000i)u\n",
      "    + (0.006426 +0.000000i)uu\n",
      "    + (0.080515 +0.000000i)u_11\n",
      "    + (-1.137705 +0.000000i)uu_1\n",
      "    + (0.196060 +0.000000i)uuu_1\n",
      "    + (0.145902 +0.000000i)uu_11\n",
      "    + (-0.122223 +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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_eff_rhs.append(tuple(i for i in range(X_pre.shape[1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RFE_PLinearRegression\n",
      "(3, 4)\n",
      "(4,)\n",
      "--------------------------------------------------\n",
      "(3, 4, 7)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(2, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(1, 2, 3, 4, 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, 1, 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, 1, 3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n",
      "(0, 1, 2, 3, 4, 5, 6, 7)\n",
      "(0, 1, 3, 4, 5, 6, 7)\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "ic_type = 'aic'; mode='rfe' # aic, bic | rfe, SelectKBest\n",
    "st = backward_refinement(all_eff_rhs, (X_pre, y_pre), \n",
    "                         mode=mode, ic_type=ic_type, verbose=True)\n",
    "# st += backward_refinement(all_eff_rhs, (normalize(X_pre, axis=0), y_pre), \n",
    "#                           mode=mode, ic_type=ic_type, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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, 1, 3, 4, 5, 6, 7)\n",
      "(0, 1, 2, 3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "decreasing_aics = []\n",
    "complexities = []\n",
    "eff_feature_names = []\n",
    "now_aic = 1e6\n",
    "for com in sorted(st.track.keys()):\n",
    "    indices, aic = st.track[com]\n",
    "    print(indices)\n",
    "    if aic < now_aic:\n",
    "        complexities.append(len(indices))\n",
    "        decreasing_aics.append(aic)\n",
    "        eff_feature_names.append([convert2latex(f) for i,f in enumerate(model.get_feature_names()) if i in indices])\n",
    "        now_aic = aic\n",
    "decreasing_aics = np.array(decreasing_aics)\n",
    "complexities = np.array(complexities)\n",
    "relative_decreasing_aics = decreasing_aics-np.min(decreasing_aics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 improves 1\n",
      "Percent improve: 0.1652447290393721\n",
      "4 does not improve 2\n",
      "Percent improve: 0.000544265224371957\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1652447290393721\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "none 32\n",
      "-10536.38751942126\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([-63762.32138037, -74298.7088998 , -74330.81920716, -74379.58530674,\n",
       "        -74405.34064758, -74448.66917638]),\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": 25,
     "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More model selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use PDE_FIND_Loss from parametric_pde_find.py by formulating as a parametric problem\n",
    "# Moving horizon in time\n",
    "\n",
    "def log_like_value(prediction, ground):                                                                                                               \n",
    "    nobs = float(ground.shape[0])\n",
    "    nobs2 = nobs / 2.0\n",
    "    ssr = np.sum(np.abs(ground - prediction)**2)\n",
    "    llf = -nobs2 * np.log(2 * np.pi) - nobs2 * np.log(ssr / nobs) - nobs2\n",
    "    return llf\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",
    "    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,cv=0,epsilon=1e-5,ic_type=\"bic\"):\n",
    "    D,m = x.shape\n",
    "    n,_ = As[0].shape\n",
    "    N = n*m\n",
    "    rss = np.sum([np.linalg.norm(bs[j] - As[j].dot(x[:,j].reshape(D,1)))**2 for j in range(m)])  \n",
    "    k = (np.count_nonzero(x)/m)*(1+cv)\n",
    "    if ic_type == \"aic\":\n",
    "        return N*np.log(rss/N+epsilon) + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "    elif ic_type == \"bic\":\n",
    "        return N*np.log(rss/N+epsilon) + np.log(N)*k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n_ensemble_models = 50\n",
    "# model = ps.SINDy(feature_library=diff_lib, optimizer=optimizer, \n",
    "#                  differentiation_method=KalmanDiff(alpha=kalpha, poly_deg=poly_deg, rpca_lambda=rpca_lambda, axis=0, is_uniform=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",
    "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",
    "m, n = len(x), len(t)\n",
    "\n",
    "com2coeff = {}\n",
    "for com in st.track.keys():\n",
    "    indices, _ = st.track[com]\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(n)])\n",
    "    com2coeff[com] = coeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-67912.33446611, -69525.52741269, -70021.37516584, -70006.77648679,\n",
       "       -69817.10860449, -70282.60535745, -70304.05660183, -70302.18125563])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_grouped = [candidate_lib[j*n:(j+1)*n,:] for j in range(m)]\n",
    "Ut_grouped = [dynamics[j*n:(j+1)*n] for j in range(m)]\n",
    "\n",
    "# how about calculate coeff wrt to time var as well\n",
    "PDE_Losses = []\n",
    "for com in st.track.keys():\n",
    "    PDE_Loss = PDE_FIND_Loss(Theta_grouped, Ut_grouped, com2coeff[com])\n",
    "    PDE_Losses.append(PDE_Loss)\n",
    "PDE_Losses = np.array(PDE_Losses)\n",
    "PDE_Losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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",
    "    m, n = len(x), len(t_sub)\n",
    "    Theta_grouped_sub = [candidate_lib_sub[j*n:(j+1)*n,:] for j in range(m)]\n",
    "    Ut_grouped_sub = [dynamics_sub[j*n:(j+1)*n] for j in range(m)]\n",
    "    \n",
    "    for com in 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(n)])\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": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.        ,  0.        ,  0.        ,  3.16716919,\n",
       "         0.        ,  0.        ,  0.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  5.48933162,  5.58056449,\n",
       "         0.        ,  0.        ,  0.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  2.66511713, 10.7763951 ,\n",
       "         0.        ,  5.35752902,  0.        ],\n",
       "       [ 0.        ,  5.7949652 ,  0.        ,  3.6186125 ,  5.04595557,\n",
       "         0.        ,  3.7002179 ,  0.        ],\n",
       "       [ 0.        ,  3.81283412,  0.        ,  5.32012283,  8.9548675 ,\n",
       "         0.        ,  3.58646322,  5.90513308],\n",
       "       [ 3.53348098,  0.        ,  0.        , 18.95569615,  4.53690324,\n",
       "         4.89314907,  5.24903873,  5.17690473],\n",
       "       [45.80213691,  4.60757453,  0.        ,  4.31612437,  3.37140872,\n",
       "         5.20547556, 12.97400718,  5.80361758],\n",
       "       [ 4.38632671,  7.0125313 ,  5.6127036 ,  5.3912857 ,  6.91203321,\n",
       "         6.03198753,  2.79888429,  3.24593969]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvs = np.zeros((len(st.track.keys()), len(diff_lib.get_feature_names())))\n",
    "for com in st.track.keys():\n",
    "    indices, _ = st.track[com]\n",
    "    cv_com = np.zeros(len(diff_lib.get_feature_names()))\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",
    "    cv_com[list(indices)] = np.abs(com2coeff_sub[com].std(axis=0)/com2coeff_sub[com].mean(axis=0)).mean(axis=-1)\n",
    "    cvs[com-1] = cv_com\n",
    "cvs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": [
    "plt.plot([i for i in range(1,9)], np.array([i for i in range(1,9)])*(1+cvs.sum(axis=-1)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxp = 1000 # 10 for aic | 1000 for BIC\n",
    "agg_PDE_Losses_cv = []\n",
    "for p in range(1, maxp+1):\n",
    "    PDE_Losses_cv = []\n",
    "    for com in 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')\n",
    "        PDE_Losses_cv.append(PDE_Loss)\n",
    "    agg_PDE_Losses_cv.append(PDE_Losses_cv)\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, 11):\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.626039089023259e-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",
    "for kkk in [0.1, 0.01, 0.001]:\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",
    "        bics.append(bic)\n",
    "\n",
    "    bic_collections.append(bics)\n",
    "\n",
    "print(np.argmin(np.average(bic_collections, axis=0))+1)\n",
    "for i in range(len(bic_collections)):\n",
    "    plt.plot(range(1, 9), bic_collections[i])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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
}