Examples/Burgers-now-20230218-without-RPCA-KSVDREG.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",
    "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 trange\n",
    "from scipy.integrate import trapz"
   ]
  },
  {
   "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 = 'ksvd_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}.npy\")\n",
    "\n",
    "# divide into 2 5 10\n",
    "if apply_savgol:\n",
    "    un_savgol = np.vstack([savgol_denoise(un[i:i+1, :], 11, 2) for i in range(un.shape[0])])\n",
    "    print(mean_squared_error(u, un_savgol))\n",
    "    un = un_savgol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Avg weak coef from 10 runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# differentiation_method = ps.FiniteDifference\n",
    "# differentiation_kwargs = {}\n",
    "\n",
    "kalpha = 1e-1; poly_deg = None; diff_order = 2\n",
    "differentiation_method = KalmanDiff\n",
    "differentiation_kwargs = {\"alpha\":kalpha, \"poly_deg\":poly_deg, \"rpca_lambda\":None}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "weak_pde_lib = ps.WeakPDELibrary(library_functions=[lambda x: x, lambda x: x * x], \n",
    "                                 function_names=[lambda x: x, lambda x: x + x], \n",
    "                                 derivative_order=diff_order, p=diff_order, \n",
    "                                 spatiotemporal_grid=XT, \n",
    "                                 include_bias=False, is_uniform=True, K=10000, # new random K points in every calls to the ps.WeakPDELibrary\n",
    "                                 differentiation_method=differentiation_method, \n",
    "                                 differentiation_kwargs=differentiation_kwargs, \n",
    "                                 cache=True\n",
    "                                )\n",
    "kwargs = {'fit_intercept':False, 'copy_X':True, 'normalize_columns':False}\n",
    "X_pre, y_pre, fns = ps_features(un, t, weak_pde_lib, kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['u', 'uu', 'u_1', 'u_11', 'uu_1', 'uuu_1', 'uu_11', 'uuu_11']\n",
      "(u)' = 0.105 u_11 + -1.011 uu_1\n",
      "u_t = (0.106501 +0.000000i)u_11\n",
      "    + (-1.016661 +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.105021 +0.000000i)u_11\n",
      "    + (-1.011191 +0.000000i)uu_1\n",
      "   \n",
      "['u_{xx}' 'uu_{x}']\n",
      "[ 0.10502113 -1.01119065]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3.0700976751743267, 1.9510327970991002)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ols_model, eff_rhs_indices = model.validate_coef_list()[0]\n",
    "print(np.array([convert2latex(f) for i,f in enumerate(model.get_feature_names()) if i in eff_rhs_indices]))\n",
    "print(ols_model.params)\n",
    "# (2.966546839959899, 1.8494019586055508) -> ksvd\n",
    "# (2.951366904136575, 1.8846719890201133) -> spm_ksvd\n",
    "# (2.0340810219237895, 1.5495206426166808) -> spm_ksvd + savgol\n",
    "evaluate_coefficients(ols_model.params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.942204 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.105021 +0.000000i)u_11\n",
      "    + (-1.011191 +0.000000i)uu_1\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.098942 +0.000000i)u_11\n",
      "    + (-1.018708 +0.000000i)uu_1\n",
      "    + (0.014895 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (-0.019175 +0.000000i)u_1\n",
      "    + (0.095098 +0.000000i)u_11\n",
      "    + (-0.970943 +0.000000i)uu_1\n",
      "    + (0.019715 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.017574 +0.000000i)uu\n",
      "    + (0.094485 +0.000000i)u_11\n",
      "    + (-1.088320 +0.000000i)uu_1\n",
      "    + (0.114139 +0.000000i)uuu_1\n",
      "    + (0.038371 +0.000000i)uu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.009341 +0.000000i)u\n",
      "    + (0.081207 +0.000000i)u_11\n",
      "    + (-1.134250 +0.000000i)uu_1\n",
      "    + (0.195066 +0.000000i)uuu_1\n",
      "    + (0.141842 +0.000000i)uu_11\n",
      "    + (-0.122976 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.009079 +0.000000i)u\n",
      "    + (-0.009524 +0.000000i)u_1\n",
      "    + (0.080362 +0.000000i)u_11\n",
      "    + (-1.078652 +0.000000i)uu_1\n",
      "    + (0.130513 +0.000000i)uuu_1\n",
      "    + (0.140945 +0.000000i)uu_11\n",
      "    + (-0.120802 +0.000000i)uuu_11\n",
      "   \n",
      "hasattr threshold in optimizer...\n",
      "u_t = (0.009079 +0.000000i)u\n",
      "    + (-0.009524 +0.000000i)u_1\n",
      "    + (0.080362 +0.000000i)u_11\n",
      "    + (-1.078652 +0.000000i)uu_1\n",
      "    + (0.130513 +0.000000i)uuu_1\n",
      "    + (0.140945 +0.000000i)uu_11\n",
      "    + (-0.120802 +0.000000i)uuu_11\n",
      "   \n"
     ]
    }
   ],
   "source": [
    "all_ols_models = []\n",
    "all_eff_rhs = []\n",
    "for mnz in range(1, 9):\n",
    "    optimizer = L0BNB(max_nonzeros=mnz, lam=1e-3, is_normal=True, normalize_columns=False) # tune lam จาก (X_pre, y_pre) | ตอนนี้ยังไม่ได้ tune\n",
    "    n_ensemble_models = 50\n",
    "    model = ps.SINDy(feature_library=weak_pde_lib, optimizer=optimizer, \n",
    "                     differentiation_method=KalmanDiff(alpha=kalpha, poly_deg=poly_deg, rpca_lambda=rpca_lambda, axis=0, is_uniform=True), \n",
    "                     cache=True,\n",
    "                     feature_names=['u'])\n",
    "    model.fit(np.expand_dims(un, -1), t=dt, ensemble=True, \n",
    "              library_ensemble=True, n_candidates_to_drop=1, n_models=n_ensemble_models)\n",
    "    ols_model, eff_rhs_indices = model.validate_coef_list()[0]\n",
    "    all_ols_models.append(ols_model)\n",
    "    all_eff_rhs.append(eff_rhs_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_eff_rhs.append(tuple(i for i in range(X_pre.shape[1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RFE_PLinearRegression\n",
      "(3, 4)\n",
      "(4,)\n",
      "--------------------------------------------------\n",
      "(3, 4, 6)\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "(2, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(1, 3, 4, 5, 6)\n",
      "(1, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(0, 3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6)\n",
      "(0, 3, 4, 6)\n",
      "(3, 4, 6)\n",
      "--------------------------------------------------\n",
      "(0, 2, 3, 4, 5, 6, 7)\n",
      "(0, 3, 4, 5, 6, 7)\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, 5, 6)\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.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 improves 1\n",
      "Percent improve: 0.1755170395255912\n",
      "4 does not improve 2\n",
      "Percent improve: 0.0005430103203391077\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\n",
      "2 does not improve 1\n",
      "Percent improve: 0.1755170395255912\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",
      "-11253.637737281417\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([-64117.06674007, -75370.70447735, -75403.08792897, -75452.55861811,\n",
       "        -75473.66650405, -75522.22154965, -75523.15576642]),\n",
       " array([1, 2, 3, 4, 5, 6, 7]),\n",
       " [['uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}'],\n",
       "  ['u_{xx}', 'uu_{x}', 'uu_{xx}'],\n",
       "  ['u^2', 'u_{xx}', 'uu_{x}', 'uu_{xx}'],\n",
       "  ['u^2', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}'],\n",
       "  ['u', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}'],\n",
       "  ['u', 'u_{x}', 'u_{xx}', 'uu_{x}', 'u^2u_{x}', 'uu_{xx}', 'u^2u_{xx}']])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### RDAE ###\n",
    "# -12389.963195450575\n",
    "\n",
    "### ksvd ###\n",
    "# no filter\n",
    "# n_comp = 8 -> -9047.553796278982\n",
    "# n_comp = 16 -> -9765.622573120214\n",
    "# n_comp = 32 -> -10536.38751942126\n",
    "# n_comp = 64 -> -10352.02875804546\n",
    "\n",
    "# lowess transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -24401.9389418036\n",
    "# n_comp = 16 -> -24691.76627305709\n",
    "# n_comp = 32 -> -24959.709959679923\n",
    "# n_comp = 64 -> -24764.429429510492\n",
    "\n",
    "# kalman transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -24885.56632890232\n",
    "# n_comp = 16 -> -25232.98595637962\n",
    "# n_comp = 32 -> -25588.41567926969\n",
    "# n_comp = 64 -> -25426.439846555484\n",
    "# kalman transform_n_nonzero_coefs1\n",
    "# n_comp = 8 -> -25891.828620483968\n",
    "# n_comp = 16 -> -25971.78585120196\n",
    "# n_comp = 32 -> -25934.634833973236\n",
    "# n_comp = 64 -> -26581.895008216423\n",
    "\n",
    "# gaussian transform_n_nonzero_coefs_none\n",
    "# n_comp = 8 -> -25196.800131085605\n",
    "# n_comp = 16 -> -25431.84926941515\n",
    "# n_comp = 32 -> -25916.951667960224\n",
    "# n_comp = 64 -> -25736.902542940414\n",
    "# gaussian transform_n_nonzero_coefs1\n",
    "# n_comp = 8 -> -26469.26580282442\n",
    "# n_comp = 16 -> -26869.639789218723\n",
    "# n_comp = 32 -> -26454.30774999768\n",
    "# n_comp = 64 -> -26941.29946099699\n",
    "\n",
    "### dictionary learning (increase n_comp until the diff in AIC/BIC drops) ###\n",
    "### only with transform_n_nonzero_coefs_none\n",
    "### aic ###\n",
    "# lowess\n",
    "# n_comp = 8 -> -20140.686246364276\n",
    "# n_comp = 16 -> -20648.56772998038\n",
    "# n_comp = 32 -> -20432.913180842457\n",
    "# n_comp = 64 -> -21502.00430136999\n",
    "# kalman\n",
    "# n_comp = 8 -> -23844.3589917847\n",
    "# n_comp = 16 -> -24251.69743649113\n",
    "# n_comp = 32 -> -24075.305724278223\n",
    "# n_comp = 64 -> -24346.695904317035\n",
    "\n",
    "# gaussian\n",
    "\n",
    "print(smoother_name, n_components)\n",
    "print(decreasing_aics[1]-decreasing_aics[0])\n",
    "decreasing_aics, complexities, eff_feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filterpy\n",
    "# 8 : -10632.44623231511\n",
    "# 16 : -11283.159060366146\n",
    "# 32 : -12254.360922488995\n",
    "# 40: -12149.099591411665"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More model selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use PDE_FIND_Loss from parametric_pde_find.py by formulating as a parametric problem\n",
    "# Moving horizon in time\n",
    "\n",
    "def ssr2llf(ssr, nobs):\n",
    "    nobs2 = nobs / 2.0\n",
    "    llf = -nobs2 * np.log(2 * np.pi) - nobs2 * np.log(ssr / nobs) - nobs2\n",
    "    return llf\n",
    "\n",
    "def log_like_value(prediction, ground):                                                                                                               \n",
    "    nobs = float(ground.shape[0])\n",
    "    ssr = np.sum(np.abs(ground - prediction)**2)\n",
    "    return ssr2llf(ssr, nobs)\n",
    "\n",
    "def BIC_AIC(prediction, ground, nparams, reg_func = lambda x: x):\n",
    "    nparams = reg_func(nparams)\n",
    "    llf = log_like_value(prediction, ground)\n",
    "    return -2*llf + np.log(ground.shape[0])*nparams, -2*llf + 2*nparams\n",
    "\n",
    "def AIC_Loss(A,b,x,epsilon=1e-5):\n",
    "    N = A.shape[0]\n",
    "    k = np.count_nonzero(x)\n",
    "    # Rudy et al., 2019\n",
    "    rss = ((b-A.dot(x))**2).sum()\n",
    "    aic = N*np.log(rss/N+epsilon) + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "    return aic\n",
    "\n",
    "def PDE_FIND_Loss(As,bs,x,epsilon=1e-5,const_coeff=True,cv=0,ic_type=\"bic\",version=0):\n",
    "    # D: Number of candidates | m: either len(t) or len(x) (temporal or spatial group)\n",
    "    D,m = x.shape\n",
    "    # n: Number of horizon\n",
    "    n,_ = As[0].shape\n",
    "    N = n*m\n",
    "    \n",
    "    rss = [np.linalg.norm(bs[j] - As[j].dot(x[:,j].reshape(D,1)))**2 for j in range(m)]\n",
    "    rss = np.sum(rss)\n",
    "    llf = ssr2llf(rss, N)\n",
    "    \n",
    "    k = np.count_nonzero(x)\n",
    "    if const_coeff:\n",
    "        k = np.count_nonzero(x)/m\n",
    "    k = k + k*cv\n",
    "    \n",
    "    if ic_type == \"aic\":\n",
    "        aic1 = N*np.log(rss/N+epsilon) + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "        aic2 = -2*llf + 2*k + (2*k**2+2*k)/(N-k-1)\n",
    "        if version > 0:\n",
    "            return aic2\n",
    "        return aic1\n",
    "    elif ic_type == \"bic\":\n",
    "        bic1 = N*np.log(rss/N+epsilon) + np.log(N)*k\n",
    "        bic2 = -2*llf + np.log(N)*k\n",
    "        if version > 0:\n",
    "            return bic2\n",
    "        return bic1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Consider uncert from BayesianRidge (brr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  5.03216404   3.63344746   7.3743579   12.40898669  44.52624172\n",
      "  73.54772091 120.77376992 136.44504547]\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": "markdown",
   "metadata": {},
   "source": [
    "#### Help from the parametric view"
   ]
  },
  {
   "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.010368880647595302\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, 4, 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": "markdown",
   "metadata": {},
   "source": [
    "#### In freq space"
   ]
  },
  {
   "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": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAD4CAYAAADGmmByAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABNUElEQVR4nO3dd3hUVfrA8e+bTHojlRYgodeEEgFBiihFBEGRFSu2xQ6KuuLPggXrrg0LigVBV1FBpKkIUizU0DuEECAQIJDe2/n9cS9sAoEQksmdCefzPPMwOfeeO+9oMu/cU0UphaZpmqZdLBerA9A0TdOcm04kmqZpWpXoRKJpmqZViU4kmqZpWpXoRKJpmqZVic3qAKwQEhKiIiIirA5D0zTNqaxfv/6EUir0zPJLMpFEREQQGxtrdRiapmlORUQOlFeum7Y0TdO0KtGJRNM0TasSnUg0TdO0KtGJRNM0TasSnUg0TdO0KtGJRNM0TasSnUg0TdO0KtGJpBK+XzCZz394zuowNE3THIpOJJXw05EZ/JQ2x+owNE3THIpOJJUQ6RnBATfYn7jX6lA0TdMchk4kldAxvBdKhD82fG91KJqmaQ5DJ5JK6NflRgB2H1tjcSSapmmOQyeSSggOaEh4ISQWH7I6FE3TNIdxSa7+WxWREspW92Nk5uTi5+1ldTia5lSUUmTkFXEiK5+TWQWczMrnRHYBJzLzOZltlCkFT13TmsgQH6vD1S6Q3RKJiEQDHwO+QAJwq1IqQ0T6A68D7kAB8KRSaqlZpwvwJeAF/AyMU0opEfEAZgBdgJPATUqpBLPOaOBZ82UnKaWm2+s9AbQJ6sCfGcn8vX4hg3rdaM+X0jSnkF9UTEp2ASezCjiRlc8JM0GczC44nTBOJ47sfAqL1VnXEIFAb3eCfdw5lpHHjVNW8uVdXekQHmDBO9Iqy553JJ8BTyilVojI3cCTwHPACWCoUuqIiLQHFgENzTpTgDHAaoxEMgj4BbgHSFVKNReRUcAbwE0iEgRMBGIABawXkXlKqVR7vale7a9j6sqlbN6/SCcSrVZSSpGRW8SJ7NJJwEwQ2fmcyCw4ffdwIiufjLyicq/jYXMhxNeDEF936vl70q6BP8G+HgT7uBPq50GwjwfBvu4E+7oT5O2OzdVoaY9PzuKOL9YyauoqPr69C71anLWPkuZg7JlIWgF/mM8XYySM55RSG0udsx3wNO84ggB/pdQqABGZAQzHSCTDgBfMOrOAD0REgIHAYqVUillnMUby+dZeb6pD0z54/aU4lLfTXi+hadXu1F3DicyC0wni9F1DptG8dLISdw3Bvu60beBPiJkYgs2EUfpfH3dXjD/Tymka6svsB3ow+ou13P3lOt76R0eui25QHf8ZNDuxZyLZBlwHzAVGAo3KOWcEsFEplS8iDYHEUscS+d+dSkPgEIBSqkhE0oHg0uXl1ClDRMZg3O3QuHHji3xL4Opqo1mxF4muqRQVl5z+FqVpjqi4RHHfV+tZsvNYuccv9q7B3ur6e/LdfZfzzxmxjP12Iyez8rmrZ2SNvLZWeVVKJCKyBKhXzqFngLuBySLyPDAPoz+kdN12GE1UA04VlXMdVcGx89UpW6jUVGAqQExMTLnnXKgWXpHMK9zBtrjddGzVpiqX0jS7mrI8jiU7j3HH5U1oXc+/2u4aakKAlxsz7u7KozM38eL8HSRn5vPkwFYOG++lrEqJRCl1dQWnDAAQkZbAtacKRSQcmAPcoZTaZxYnAuGl6oYDR0odawQkiogNCABSzPK+Z9RZfhFvpVK6NLmCOft2snbrbDq2erbiCppmgY0HU3lnyV6GRjfgxevaOeUHsKebKx/e2plnf9rGR8v3cSIrn1ev76BbAhyM3f5viEiY+a8Lxqiqj82f6wALgaeVUn+fOl8plQRkikh3s//jDoxmMTDuaEabz28EliqlFEa/ywARCRSRQIzEtche7+mUXtFGJ3v8CT0xUXNMmXmFjJu5iXr+nkwa3t4pk8gpri7Cq9e3Z9xVLfg+NpH7v15PbkGx1WFppdgzrd8sInuAXRh3FtPM8oeB5sBzIrLJfISZxx7AGO0VB+zD6GgH+BwIFpE4YDwwAcDsZH8ZWGc+XjrV8W5PQX4NqF8kHC1JrPhkTbPAxLnbSUzN4d1RHQnwcrM6nCoTER7r35KXh7fn913Huf3zNaTlFFRcUasRYnyxv7TExMSo2NjYKl3jwWn92FFylK+HryY82L+aItO0qpu76TDjZm5i3FUteKx/S6vDqXY/b03i0ZmbiAjxZvrdXakfoCcG1xQRWa+UijmzXDc0XqQOIdGctLmyduMvFZ+saTXkUEoOz87ZRpcmgTzSr7nV4djF4A71+fLuy0hKy2PERyuJO55pdUiXPJ1ILtIV7YyxAzsPLLY4Ek0zFBWXMG6mMU3r3Zs61uoO6R7NQph5X3cKihU3fryKDQftNgdZuwC19zfNzlo36Y1HiSJJT0zUHMT7S+PYcDCNSde3p1GQt9Xh2F27BgH8+EAPArzcuOXT1SzbddzqkC5ZOpFcJDdXd5qVeHHUlkZGXqHV4WiXuHUJKby/dC83dGrIsI7lzsmtlRoHezPr/h40D/Pl3hmxzF6vB8BYQSeSKmjtE8k+D2HjLn1XolknPbeQR2duIjzQmxeHtbM6nBoX6ufBzDGX071pEI//sJlPVuyruJJWrXQiqYLuTftQJMKWHXofd80aSimembOVoxl5vDeqI36ezj/U92L4etj44s7LGBJVn9d+2cWkBTsoKbn0RqRaRSeSKohpPQyAQ6nrLI5Eu1TN3nCYBVuSeOzqFnRqHGh1OJbysLkyeVQn7uwRwWd/7Wf895soKCqxOqxLgt7YqgpC/cMJKxaSSaSwuAS3WjxKRnM8CSeyeX7uNrpGBvFA39o51LeyXFyEiUPbEurnwb8X7SYlp5Apt3bGx0N/1NmT/uSrolauIRzyLGBH4kmrQ9EuIYXmUF+bi/DuTR1xdXHeJVCqm4jw0JXNeWNEB/7am8wtn60hJVvPgrcnnUiqqFPdjhyzubJ5i55PotWcdxbvYXNiOq+PiKJBHT2zuzw3XdaYT26PYVdSBjdOWUliao7VIdVaOpFUUbeW1wCw/7BOJFrNWLnvBFNW7OOmmEYM7lDf6nAcWv+2dfn63m6cyMpnxJSV7DqaYXVItZJOJFXUpnEf3JUiuWA3l+K6ZVrNSsspYPx3m4kM9uH5oW2tDscpXBYRxA/39wBg5MerWLvf7uu6XnJ0IqkiN5s7TUu8SHZP41BKrtXhaLWYUooJs7dyMjuf90Z10h3IldCqnh+zH+hBqJ8Ht32+hkXbj1odUq2iE0k1aO/X1JyYuN3qULRabOa6Q/y6/ShPDGhFh/AAq8NxOuGBxiz4tvX9eeDr9Xy79qDVIdUaOpFUg64Rvch3cWH3ngVWh6LVUnHHs3hp/g56Ng/mn72aWh2O0wryceebf3ajd8tQnv5xK+//vlc3SVcDnUiqQacWQwA4nqEnJmrVL7+omHEzN+Lp5sLb/+iIix7qWyXe7jY+vSOGGzo15K3Fe5g4bzvFehZ8lehG1mpQr04EIcVCmusR0nMKCfC+NJep0Ozjrd/2sP1IBlNv70Jdf0+rw6kV3Fxd+M/IaEL8PJj6Rzwnswp4+6ZoPGyuVofmlPQdSTVp7RZKomc+G/brTjyt+vy5N5mpf8RzW/fGDGhXz+pwahUXF+H/BrfhmcFtWLg1ibumrSNTr+R9UXQiqSZd6kVz2M3Grh3LrA5FqyVOZuUz/vvNNA/z5ZnBeqivvfyzd1PeuSmatftTGDV1NcmZ+VaH5HTslkhEJFpEVonIVhGZLyL+ZxxvLCJZIvJEqbIu5vlxIjJZRMQs9xCR78zyNSISUarOaBHZaz5G2+v9VKRLs0EAHD661KoQtFpEKcVTs7eQnlPI5FGd8HLXTS72dH2ncD4dHUN8cjY3frySAyezrQ7JqdjzjuQzYIJSqgMwB3jyjOPvAGdueD4FGAO0MB+DzPJ7gFSlVHOz3hsAIhIETAS6AV2BiSJiyRKobRr3xlUp0ov36BVHtSr7evUBluw8zoRrWtO2gX/FFbQqu7JVGN/8sxsZuYWMmLKSbYfTrQ7JadgzkbQC/jCfLwZGnDogIsOBeGB7qbL6gL9SapUyxuPNAIabh4cB083ns4CrzLuVgcBipVSKUirVfJ1TyadGedo8aa68SPFMY9sR/QuoXbw9xzKZtHAnfVqGclfPCKvDuaR0ahzID/f3wMPmyqipq1kZd8LqkJyCPRPJNuA68/lIoBGAiPgATwEvnnF+Q6D0PpmJZtmpY4cAlFJFQDoQXLq8nDpliMgYEYkVkdjk5OSLfEvn1yGgKXs9hO27dtjl+lrtl1dYzNhvN+LnaeM/I6MxW3e1GtQ8zJfZD/SgYR0v7py2jgVbjlgdUrXIyi9iS2IaRcXV32JSpeG/IrIEKG8oyTPA3cBkEXkemAecWsf5ReAdpVTWGX8k5f3FqAqOna9O2UKlpgJTAWJiYuwyaDym0RXMytxBQvzPQE97vIRWy73+yy52Hc1k2p2XEernYXU4l6x6AZ58f9/l3DtjHY98u5GU7ALuuDzC6rAqpJTieGY++45nEZecxb7jWexLzibueBZHM/IAWDK+D83DfKv1dauUSJRSV1dwygAAEWkJXGuWdQNuFJE3gTpAiYjkAbOB8FJ1w4FTXwUSMe5oEkXEBgQAKWZ53zPqLL+4d1N10S2uhR1TSc1Zj1JKf5vUKmXZruN8uTKBO3tEcGXrMKvDueQFeLvx1T3dePibjTw/dzvJmfmM79/SIf6uC4tLOHAyh33JWcQdz2JfspEw4o9nkZlfdPo8Xw8bzcJ86dE8mGahvjQL9aWuf/V/QbHbhEQRCVNKHRcRF+BZ4GMApVSvUue8AGQppT4wf84Uke7AGuAO4H3z1HnAaGAVcCOwVCmlRGQR8GqpDvYBwNP2ek8VaRgQSWCJkOOWRMLJHCJDfKwKRXMyyZn5PDlrM63r+THhmtZWh6OZPN1c+fi2zjwzZxvvL40jOTOfScPbY6uh3VAz8gqJT84+4w4jiwMncygqNRu/nr8nzcN8uaFzQ5qF+dI81JdmYb6E+XnUSOKz58z2m0XkIfP5j8C0C6jzAPAl4IUxouvUqK7Pga9EJA7jTmQUgFIqRUReBk6tTfKSUsqyNaJFhLbuoRzyPML6+GNEhug1kbSKlZQonvhhM5l5RXzzz+54uumhvo7E5urC6yM6EOrnwQfL4kjJLmDyzZ2q7f+TUoqjGXnsO559xh1GFscy/jenxeYiRIT40CLMj0Ht69Es1JfmYb40DfXF1+KVoO326kqp94D3KjjnhTN+jgXal3NeHkaHfXnX+AL44qIDrWZd6kbz9+HjJOxcBl11ItEqNm1lAiv2JPPysHa0rOtndThaOUSEJwa2IsTXnRcX7OCOz9fy6egYArwufDmkgqISDpwsnSyM5/uOZ5FdUHz6PD9PG83DfOnVItRsjvKheZgvjYK8cauhO6HK0mttVbOOkf3h8GKST67AmP6iaee240gGb/yyi6vbhHFb9yZWh6NV4M6ekQT7ejD++0384+NVzLin61nrn6XnFp5OEEZzVDbxyVkcSMkpszhkgwBPmoX5MjKmUanmKB9CfWumOao66URSzdo17oOLUuTJXlKyCwjycbc6JM1B5RYUM3bmRgK83XhjRJTTfXhcqoZGNyDQ2537vorlho9WclfPCPafyD7d4V16iRV3VxciQrxpXd+Pa6Pqn26OigzxqVUbk9Wed+IgvN28aYoXaZ7prD+QSv+2da0OSXNQkxbuIO54Fl/d05VgXz3U15lc0SKE7+67nDunrWXSwp34m81RV7YKPT06qnmYL+GBXjXWMW8lnUjsoGNAU35V29i5e4dOJFq5ftt+lP+uOciY3k3p1SLU6nC0i9C+YQB//qsfWflFhPi6X9J3lLU/VVqgU3hPslxcOHboN6tD0RzQ0fQ8/jV7C+0a+PPEgFZWh6NVgZe7K6E1NMTWkelEYgdRza4BIDdvI3mFxRWcrV1KSkoUj/+wifzCEibf3Al3m/4T1Jyf/i22gyaBzfEvEfK9ktiqVxDVSvn0z3j+jjvJxKFtaRZavctUaJpVdCKxAxGhg4e5Y2L8MavD0RzElsQ0/r1oN4Pa1eOmyxpZHY6mVRudSOykY1gH9rvZSNr7p9WhaA4gO7+IcTM3EeLrwesjOlzybepa7aITiZ1ERw5AiZCRtoKSErssNqw5kZfm7yDhZDbv3NSROt56bpFWu+hEYiftG/VClAK3eOJPZFkdjmahn7cm8V3sIR7o04zLmwVbHY6mVTudSOzEz92PCPEizSuN2IRUq8PRLHIkLZcJs7cQHR7AY/1bWh2OptmFTiR21Ckgkt0ewp49O60ORbNAcYni0e82UVyieG9UJ4ddcE/Tqkr/ZttRdIPuZLi6kn7kd6tD0SwwZXkca/en8OKw9kTovWm0WkwnEjuKajbYeKK2lFnITav9Nh5M5Z0lexka3YARnRtaHY6m2ZVOJHbUNKglPkoo8kpi/QHL9tvSalhmXiHjZm6inr8nk4a310N9tVpPJxI7chEXOniEcNgzj43xR60OR6shE+duJzE1h/dGdazUxkea5qx0IrGzjiEd2Ovuxon4lVaHotWAuZsO8+PGwzzSrwUxEUFWh6NpNUInEjuLiryaEhGKs/8mt0Av4FibHUrJ4dk52+jSJJBH+jW3OhxNqzE6kdhZVKPeALh57mdzYpq1wWh2U1RcwriZGwF496aOl8RmRpp2it1+20UkWkRWichWEZkvIv6ljkWZx7abxz3N8i7mz3EiMlnMXkoR8RCR78zyNSISUepao0Vkr/kYba/3c7ECPAJoIp6ke6USu/+k1eFodvL+0jg2HExj0vXtaRTkbXU4mlaj7Pm16TNgglKqAzAHeBJARGzA18D9Sql2QF+g0KwzBRgDtDAfg8zye4BUpVRz4B3gDfNaQcBEoBvQFZgoIoF2fE8XJdovgt2eLsTH77I6FM0O1iWk8P7SvdzQuSHDOuqhvtqlx56JpBXwh/l8MTDCfD4A2KKU2gyglDqplCoWkfqAv1JqlVJKATOA4WadYcB08/ks4CrzbmUgsFgplaKUSjVf51TycRjRDbqT4upK/jG9gGNtk55byKMzNxEe6M1Lw9pbHY6mWcKeiWQbcJ35fCRwagOGloASkUUiskFE/mWWNwQSS9VPNMtOHTsEoJQqAtKB4NLl5dQpQ0TGiEisiMQmJydX6Y1VVnQzI7f5uG1jz/HMGn1tzX6UUjwzZytHM/J4b1RHfD1sVoekaZaoUiIRkSUisq2cxzDgbuAhEVkP+AEFZjUbcAVwq/nv9SJyFVDerK1TX9/Pdex8dcoWKjVVKRWjlIoJDQ294PdYHZoFtcJLCUWeSXoBx1pk9obDLNiSxPj+LenU2OFaVDWtxlTpK5RS6uoKThkAICItgWvNskRghVLqhHnsZ6AzRr9JeKm64cCRUnUaAYlmH0sAkGKW9z2jzvKLezf2Y3Ox0d4jhMNeh7HtPwrdm1gdklZFCSeyeX7uNrpFBnF/n2ZWh6NplrLnqK0w818X4FngY/PQIiBKRLzNpNAH2KGUSgIyRaS72f9xBzDXrDMPODUi60ZgqdmPsggYICKBZif7ALPM4USHtGOPuxvp+1dZHYpWRYXmUF+bi/DOTR1xddFLoGiXNnv2kdwsInuAXRh3FtMAzE7xt4F1wCZgg1JqoVnnAYzRXnHAPuAXs/xzIFhE4oDxwATzWinAy+a11gEvmWUOJ6rJVRSJ4F28lmMZeVaHo1XBJyv2sTkxnddHRNGgjpfV4Wia5cT4Yn9piYmJUbGxsTX6midzT9L3+75ce8KXXv1/5Nqo+jX6+lr12JecxTXv/kn/tnX58NbOVoejaTVKRNYrpWLOLNfTb2tIsFcw4eJBhmcq6/TERKdUUqJ4+seteLq5MPG6tlaHo2kOQyeSGhTlF8FuT+Hgfj0x0RnNXHeItftTePbatoT5eVodjqY5DJ1IalB0g24ct9lwT1tJdn6R1eFolXAsI4/Xft7J5U2DGRkTXnEFTbuE6ERSg6IjBwAQ6LmdTYfSrA1Gq5SJc7dTUFzCqzd00BtVadoZdCKpQS1D2uKhhGIvPTHRmfy67Si/bj/KuKtbEKn3Xte0s+hEUoPcXNxo5xHEYc88tuw/UnEFzXLpuYU8P3cbber7889eTa0OR9Mckk4kNSwquB273N0pSFxHsV7A0eG98esuTmTl88aIDrjpPUY0rVz6L6OGRUdcRYGLUNe2gV1HM6wORzuPNfEn+WbNQe7uGUlUeB2rw9E0h6UTSQ2LCr8CAE+veN1P4sDyCot5es5WwgO9GD+gpdXhaJpD04mkhoV5h1FP3Mn0SiU2wSFXc9GAD5fFEZ+czavXd8DbXS8Pr2nnoxOJBaL9mrDLw4WkhJ1Wh6KVY9fRDKYs38cNnRrSu2XNbjmgac5IJxILRNXvxhE3GyG5sRxOy7U6HK2U4hLFhNlb8fdy49khehkUTbsQOpFYICqyPwAh3jt085aDmbEqgU2H0nh+SFuCfNytDqd6HN0KKfFWR6HVYjqRWKBtSHvcFJR4J7H+gO5wdxSH03L596Ld9GkZyrCODawOp+oOrIIZw+HjK+CDrrD8dSgqqLCaplWWTiQWcHd1p41HEEc88tiyP8nqcDSM/defnbMVpWDS8PbOuwyKUrD/T/hyCEwbBMe2wdUvQrvhsPw1+PRKOLLJ6ii1WkYnEotEBbdju4cbHsc3kplXaHU4l7z5W5JYtjuZJwa2olGQt9XhVJ5SsG8ZTBsM04fAiT0w8DUYtwWueBRGfAajvoXsE/BpP/j9ZSjKtzpqrZbQicQi0U36kefiQoTnJjYeTLM6nEtaanYBL87bTnR4AHf2iLA6nMpRCvYugc8HwFfDITUBrvk3jNsMlz8I7qWSYuvB8NBqiLoJ/vwPfNIHEtdbFblWi+hEYpGohj0A8PKO1x3uFpu0cCfpuYW8PiLKefZfVwp2/2I0Vf13BGQmwbVvw7hN0G0MuJ1jC2CvQLh+Ctw6C/Iz4POr4bfnoFCPHtQunp5pZZH6PvUJFXeyvFLZoxOJZf7ae4LZGxJ56MpmtKnvb3U4FSspgd0LYcWbcHQL1GkC170PUaPAVolRZi36w4OrjCSycjLs/hmGfQSNu9kvdq3WstsdiYhEi8gqEdkqIvNFxN8sdxOR6Wb5ThF5ulSdLmZ5nIhMFrPHU0Q8ROQ7s3yNiESUqjNaRPaaj9H2ej/VTUSI8m3MTg8hJXE3hcUlVod0ycktKOb/5mwlMsSHR/q1sDqc8yspge1zjBFY390GBVkwfAo8sh4631G5JHKKZwBcNxlu/8kYzfXFQPj1aSjIrvbwtdrNnk1bnwETlFIdgDnAk2b5SMDDLO8C3FcqMUwBxgAtzMcgs/weIFUp1Rx4B3gDQESCgIlAN6ArMFFEAu34nqpVVP3LOOjmRjO1mZ1JegHHmvbukj0cTMnhtRs64OnmanU45Ssphq2zYMrl8MOdUFIIN3wKD62DjreAq1vVX6PZlfDgSrjsHlj9EUzpCQl/Vf262iXDnomkFfCH+XwxMMJ8rgAfEbEBXkABkCEi9QF/pdQqpZQCZgDDzTrDgOnm81nAVebdykBgsVIqRSmVar7OqeTj8KIjSk9M1PNJatK2w+l8+mc8N3dtRPemwZWuX1hs55F2xUWweSZ82BVm3wMI3PgFPLgaov4BrtXcKu3hB9e+BaMXAAq+vBYWPg75WdX7OlqtZM9Esg24znw+EmhkPp8FZANJwEHgP0qpFKAhkFiqfqJZhvnvIQClVBGQDgSXLi+nThkiMkZEYkUkNjk5uWrvrJq0DW2PDRA9MbFGFRWX8NTsLQT7ejDhmjaVrv/L/l+47L+XMfqX0czaM4uMgmq8mywuhI1fwwcxMOc+sHnCP2bAAyuh/QhwsfOdU2Qv47W6PQDrPoePLjeGFWvaeVQpkYjIEhHZVs5jGHA38JCIrAf8MO48wGiCKgYaAJHA4yLSFChvuMypnZ/Odex8dcoWKjVVKRWjlIoJDXWMhfi8bF60dAvkkEcu2/YfxrgR0+zt87/2s/1IBi9d144Ar8o1DW0/sZ3n/n6O5nWak5qfyourXuTK765k/PLxLDu47OLvVIoKYP2X8H5nmPsQePrDqG/gvj+h7TBwqcEBlu4+cM3rcPevRt/LV8Nh3ljIS6+5GDSnUqX7Y6XU1RWcMgBARFoC15pltwC/KqUKgeMi8jcQA/wJhJeqGw6c2o82EeOOJtFsEgsAUszyvmfUWX6Rb8cSUcFtmZd/ksic7SSmXuWck+GcyIGT2by9eA/929ZlUPt6lap7IvcEY5eNJdgzmKkDphLoEciOkzuYHz+fX/b/wuIDi6njUYdBEYMY2mwoHUI6VDxDvigfNn4Ff74DGYnQsAsM/g+0GABWz65v3B3u/wuWvQKrPoS4JTB0MrSo6M9eu9TYc9RWmPmvC/As8LF56CDQTww+QHdgl1IqCcgUke5m/8cdwFyzzjzg1IisG4GlZj/KImCAiASanewDzDKnEdXkSnJcXIj02ErsAT0M2J6UUvzfnK24u7rw8rDKLYNSUFzAuGXjyCzIZHK/yQR5BiEitAtpx4SuE1gycgkfXvUh3et3Z07cHG79+VaG/jSUjzd/TGJm4tkXLMyF1R/Dex2NvoiAhnDbbLj3d2g50PokcoqbFwyYBPcsNvpR/jsCfnoQcnVTrPY/9pxHcrOIPGQ+/xGYZj7/0Hy+DaNpappSaot57AHgS4xO+F/MB8DnwFciEodxJzIKQCmVIiIvA+vM814y+1ucRscGxsREX5941iWkcn2n8ApqaBdr1vpE/o47yaTh7akX4HnB9ZRSvLTqJbYkb+Gdvu/QKqjVWee4ubjRO7w3vcN7k1mQyZIDS5gfP58PN33Ih5s+pHNYZ4Y0G8KABlcQsGU2/P0eZB+HJj3h+o8hsrfjJI/yhMfAfX/Aijfgr3ch7ncY+i60usbqyDQHIJdiu3xMTIyKjY21OgzA+JDq81UXemRmszF/KovG97E6pFopOTOfq99eQcu6vnw35nJcKjGDfcb2Gfw79t882PFBHoh+oFKvm5SVxML9C5kfN5f4jATclKJvTi5DfCLo1es53Jr2reQ7cQBHNsJPD8Hx7dBhJFzzJngHWR2VVgNEZL1SKubMcr1EisWMiYmN2OEu5CfvJT1HL+BoDy8t2EFuQTGv3dChUknk78N/89b6t+jfpD/3Rd1X6detb/Ph3tQ0ftqzjZmHk7hJAllfpy7jOE6/tc8xafUkNh3f5FwDLRp0gjHLoc8EY5Lkh11hx9wKq2m1l14ixQFE1+vKisx4rnTdwYaDqVzZOszqkGqVpbuOMX/zER67uiXNw/wuuF5CegJPrniSFnVaMKnnJFykEt+7ctNgzSew+kPIS0daDKRdn3/RLjyGx0uKWHlkJQv2LeCnuJ/4bvd3NPZrzJBmQxjSdAiN/BpVeHnL2dzhyqehzRCjz+T7O6DtcGOggK9jjIrUao5u2nIAaw6v4t4lY7jpSAM8Or/HkwNbWx1SrZGVX8SAt1fg62ljwSO9cLddWDLIKMjg1oW3klGQwbfXfksD3wvc6ConBVZPgTUfG4sitroW+jxpfIsvL76CLBYfWMyC+AWsO7oOhaJTWCeGNB3CwIiBBHgEXOhbtU5xIfz9rrH+l4ef0dTVfoRj9/loF+VcTVs6kTiA7MJsenzTnX+kC5s9PuH7+y63OqRa44V525m+KoFZ9/egS5MLWz2nuKSYh5Y+xJoja/hs4Gd0qdul4krZJ2HVB7B2qrEOVpvroPeTUD/qgmM9mn2UBfELWLBvAfvS9+Hm4kaf8D4MaTqEXuG9cHd18K1/j+807k6ObIDWQ4zViP3qWh2VVo3OlUh005YD8HHzoblbHQ66HSXuUBIFRSUX/M1ZO7f1B1KZviqBO7o3ueAkAvDuhnf5+/DfTLx8YsVJJOs4rHzfmAVemAPtrjcSSN22lY63nk897u1wL/e0v4edKTuZv8+Yn7Lk4BICPAIYFDGIIU2HEB0a7Zg7OIa1MYYJr/4Qlr5i9J1c84ax/4kjxqtVG51IHERUUBsW5aXQqmQP24+k06mx06w96ZAKikp4+sct1PP35MlBF95UOG/fPL7c/iU3t76ZG1veeO4TM5KM5ddjp0FxPrS/EXo/AaFnDw2uLBGhbXBb2ga35fGYx1l1ZBXz4+czN27u//pTmpr9Kf4O1p/iaoOe46DVYGOG/pz7YNuPxlBh/wtsHtScjk4kDiK6cV9mHVtFM4+txCak6kRSRR+v2MeeY1l8PjoGX48L+zXfkryFF1e+SLd63XjysifPfeKOufDjGKNvIOomI4EEN6umyMuyudjoFd6LXuG9yCrIYsnBJSzYt4Apm6fw0eaP6BjakaHNhjpef0pIC7jrF2PAwe8vwYfdYOAr0Ol2fXdSC+k+EgcRnx7PsJ+GMfqEH3vDJvPJ7Wc1Q2oXKO54FoPf+5MB7erywS2dL6jOsexj3LzwZjxcPfj22m+p41mn/BO3zjKSSHiMMZEwqGn1BV4JR7OPsjB+IQviFxCXFofNxUbvhr0Z2mwovcN7O1Z/ysl9xlpdB/6CZv2MZVbqONidlHZBdB+Jg4vwj8BPbKR5nmB9QgpKKcdsB3dwJSWKp3/cgpe7KxOHtrugOnlFeTy67FGyC7OZ2n/quZPIpm9h7oPQuAfc8h14+FZf4JVUz6ce93S4h7vb382ulF3Mj5/Pz/E/s/TQUvzd/U+v9+UQ/SnBzWD0fIj9HBZPhI+6Q/+XoMtdNbsYpWY3OpE4CBdxIcqnETvyd+Ofc4CEkzlEhvhYHZbT+WbtQdYlpPLmjVGE+nlUeL5SihdWvcD2k9uZ3G8yzQObl3/ihhnGt+qmfWDUt+DuGItrightgtvQJrgN47uMZ3XSahbEL2B+/Hy+3/M94b7hDGk2hN4Ne9O0TlN83Cz6nXJxga7/NBajnD8WFo43JjNe9z4ERVoTk1ZtdCJxINH1LmNKZjz9XHcSm5CiE0klHU3P441fdtGjWTAju1zYmmXTtk9jYfxCxnYaS99Gfcs/ad1nxsKKza+Gm742FjJ0QDYXG1c0vIIrGl5BdmH26fW+Ptn8CR9vNtZMDfMOo2lA0/896jQlMiCSYM/gmrlzCWxibO27YToseham9ICrX4DL/qnvTpyYTiQOJLrJlai476nvu5P1B1IZGaPbkSvj+bnbKCgu4dXrL2D5duCPxD94d/27DIoYxL0d7i3/pNVT4NcJ0PIa+Md0sFV8l+MIfNx8GNZ8GMOaD+N4znG2ntjK/vT9xKfFE58ez09xP5FTlHP6fH93/9OJpWmAkVyaBjSlgW+Dys3ovxAi0OVOIzHPHwe//Au2/wTDPrDboAXNvnQicSDtw4zJay7eh1mX4FSLGFvu121J/LbjGBOuaU3EBdzJxafF868//kXroNa81POl8hPP3+/B4ueNyYUjPjeWBXFCYd5hXNX4qjJlSimO5Rw7nVji0+PZn76f5YeW8+PeH0+f5+nqSURAxOnEcurRxL8JblXdLz4gHG6dBZu+gUVPG3cn/Z6D7g/YfydIrVrpROJA/N39aermT4LbMY4dSSY1u4BAH+f88KpJ6bmFPDd3O+0a+HPvFRW3t6fnp/PI0kfwdPVkcr/JeNnKaapa8W9YNslY6uP6qdW/R7rFRIR6PvWo51OPHg17lDmWlpfG/oz9ZZLMluQt/LL/l9PnuIorjfwaERkQWTbJVLYfRgQ63WqM5lrwGPz2DOz4ydgDpXH3anq3mr3Vrr+OWiA6sA3L81KJdolj/YFUrm6rl5ioyOu/7ORkVj5fjL4Mm+v5m2GKSop4YsUTJGUn8cXAL6jnc8YuiUrBslfhjzchahQM/+iS+3Zcx7MOnTw70Sms7PpguUW5JKQnlLmDiU+L58/Df1JUUnT6vIvqh/GvDzd/awyvXvQ0fDEQml0FVz4D4RewRI0dFZcUk1ecR05hDjlFOWf96+fmR5OAJtT3qV/9zYDVSSk4urVSy/ZcKJ1IHExU4z7MOb6Gqz23se5Aik4kFVgdf5Jv1x5iTO+mdAiveELeW7FvsTppNS/1eImOYR3LHlQKfn8R/nrHmDg39L1LLomcj5fN6/QIsdIKSwpJzEwsk1wuqh9GBKJGQuvBxgCHv96Fz/pBy0HQ92lo0PG88SmlKCwpPPsD/4wP/9yiXHKKcsgtzC03MZQ5rzCHvOK8C/rv4+7iTmP/xkT4RxAREEET/yZE+Bv/BnpaOMG4pAR2/wx/vQ2H1xvbJ9frUK0voROJg4lq0A2AQL/9rEjQ25meT15hMf/341YaBXnx2NUtKzz/x70/8vXOr7m97e1c3+L6sgeVgkXPGOtExdwNg9/So4gukJuL2+kmrtIuth8m3C+cwrDG5Ax+jtyEFeQcWEXurGHkBDYhJ6w1OTa3sz78cwtzyS3KpUgVcaE8XT3xdvPGy+aFl80LbzdvvG3eBHsGn35e+t8zzztVlp6fzoGMAySkJ3Ag4wBxaXEsP7S8TCwBHgFlEsupfxv7Ny6/abU6FBfCttnGF6PkXVCnibGQZnCLan8pnUgcTLOAZvjgSopbMlsTU8krLMbTTX8rLs8HS+OIP5HNV/d0xcv9/P+NNh7fyMurX6ZHgx6M7zK+7MGSEmPk0LpPodv9MOh1vYxHNahqP8wprv7eeOOLV+FJvA/+gbdHAN6BEYR4h+Dl51XuB37psjM//E+VuVbj3eZl9S4r83NhSSFHso6cTjAJGUaSWZ20mnn75pU5t75PfZr4N6GJfxMiAyJPP2/g0+DiYizMhY1fw9+TIf0ghLWFGz4zFhS1U1+fTiQOxtXFlfY+4WzP30t4yWG2HU4nJkJvY3qmnUkZfLxiHyM6h9Orxfk3UkrKSuLRZY/S0Lchb/Z+E5tLqV/7khJY8Kgxr6HHI9D/ZZ1EasD5+mGSspPwdPU8nQDcXdyNvpXcVFj1oTEkO343dLgR+jxqrOvlYNxc3E4nhN7hvcscyynM4UDGASPJZJhJJv0AC+MXklWYVeYajf0aG9cJaEKk//+STJBn0Nn9TXnpxirUqz+C7GQI7wqD34QWA+1+d60TiQOKrn8Zn2clcKXrTmIPpOpEcobiEsWE2VsI8HLj2WvbnPfc3KJcxi0bR0FxAZOvnFx2YcOSYpj3CGz6L/R6Avo9q5OIxbxsXjQNOMf6ZV6Bxv+jbg8YKy+vnWo03USNMjYPs2jds8rydvMut69JKUVKXsrpu5eEjITTdzN/HP6jzIAGP3e/081jTTxDiUjaQcTuJTTOScO7aT/oNR6a9Kyx3+cqJRIRGQm8ALQBuiqlYksdexq4BygGxiqlFpnlXYAvAS/gZ2CcUkqJiAcwA+gCnARuUkolmHVGA8+al56klJpulkcCM4EgYANwu1KqoCrvyRFEN+pDcdwsmgbsJjYhBfroSVqlTV+ZwObEdN4b1fG8w6OVUjz393PsStnFB1d9QNM6pT5oiovgp/th6w/Q9/+g71M1ELlWLXyCof+LcPnDxs6M6z6DLd9Bx1uMvWACm1gd4UUREYK9ggn2Cj5rH5yikiKSspNO98MkZCRwIGU3sQlLWFBiDgYI8wP8CPNMJ3L3lzRJWmb0xwREEOEfQQPfBmXvxqtRVa+6DbgB+KR0oYi0BUYB7YAGwBIRaamUKgamAGOA1RiJZBDwC0bSSVVKNReRUcAbwE0iEgRMBGIABawXkXlKqVTznHeUUjNF5GPzGlOq+J4s1yEsGoASz0TWH0jVCziWkpiaw39+203fVqFcF33+/S0+3fopixIWMb7L+LLNC8WFMPteY77CVRONb2+a8/ENNZam7/GI0aEcOw02z4TOt0Ovx40Jj7WEzcVGI79GNPJrRK/jobD7L9j6MwC5USM5GDWCBJeSMk1mvyb8SkZBRplrhPuG816/985913ex8VWlslJqJ1Deh9wwYKZSKh/YLyJxQFcRSQD8lVKrzHozgOEYiWQYxt0NwCzgAzEuPBBYrJRKMessBgaJyEygH3CLWWe6Wd/pE0mgZyBNbH7Eux6jKCedfcnZNA+zbqVZR6GU4tmftgEwaXj78ybXpQeX8v7G9xnSdAh3trvzfweK8mHW3bBrAQx4BXo8bOeoNbvzq2fsxNhjrDHEdf10o7O5y51wxXhjjkptcHg9/Pm28bvr5m2sT9bjYbwCwmkFnLmlmlKKtPy0Ms1kBzIOEORR/U3l9uojaYhxx3FKollWaD4/s/xUnUMASqkiEUkHgkuXn1EnGEhT6vQYu9LXOouIjMG4E6Jx48YX9aZqUlRga1blpRHtspfYhG46kQDzNh9h+e5kJg5tS3jguVff3ZO6h6f/fJoOIR14occL/0s4hXnw/R2wdxFc82/oNqaGItdqREBDuPYtY4fGP/4DsV8YqzbH3ANXPAq+YVZHWHlKwf4VRgLZvwI8A6D3v4zRhT7B560qIgR6BhLoGXj2nKlqVmFXvogsEZFt5TyGna9aOWXqPOUXU+d81zr7gFJTlVIxSqmY0NDzj/JxBFGNenPC5kqU9y5iD+j5JCnZBbw4fwcdG9Xhjssjznleal4qY5eOxcfNh3evfBcPV3ORxYIcmHmzkUSGvKuTSG1WpzFcNxkejjWWuFkzBd6Ngt+eg+yTVkd3YUpKYOcC+OwqmDHMmAfS/2V4bDv0e6bCJFLTKrwjUUpdfRHXTQRKL10bDhwxy8PLKS9dJ1FEbEAAkGKW9z2jznLgBFBHRGzmXUnpazm96AbdYAPU8YvnF51ImLRwBxm5hbw+ogOuLuU3aRWWFPL4isdJzknmy0FfEuZtfgMtyIZvboKEv2DYh9DpthqMXLNMUKSxxM0V42HFG7DyfeMupdt9Rke9twOOhjxzEmFgBAx5B6JvATdPq6M7J3sNLp4HjBIRD3NkVQtgrVIqCcgUke5m/8cdwNxSdUabz28ElipjH+BFwAARCRSRQGAAsMg8tsw8F7PuqWs5vRaBLfDChROux0g4kUlyZr7VIVnmjz3J/LjhMPf3aUbrev7nPO+NtW+w7ug6XujxAh1CzSUg8jPh6xvhwN9w/Sc6iVyKQprDiE/hoTXGxlp/vgXvRcOy1yA3zeroDIW5sPZTmNwZ5twH4mqsOP3wemOlBQdOIlDFRCIi14tIInA5sFBEFgEopbYD3wM7gF+Bh8wRWwAPAJ8BccA+jI52gM+BYLNjfjwwwbxWCvAysM58vHSq4x14Chhv1gk2r1Er2FxstPNpyDY3obkcYf0leleSU1DEMz9tpWmIDw/3O8fuhcD3u7/nu93fcVe7uxjabKhRmJcOX10Ph9YYf5TRN9VQ1JpDCm0FI6fBAyuNnS5XvA7vRcEf/za+cFghL93o/3i3A/z8hLl45XfwwN/GhEsnWXVajC/2l5aYmBgVGxtb8YkWe+ev55kR9yMD4wfg1+1enrm2rdUh1bhXFu7g0z/3892Y7nRrWn678Lqj6xjz2xi6N+jOB/0+MJaVyE01ksjRbcaHR5uhNRy55vCSNsPy140FDb2CoOdY6DoG3GtgZ9KsZGMG+rrPID/DWOm41+PQpIdDT4oVkfVKqZgzy50j3V2iohr1oWjfHFrU2cP8S3ABxy2JaXz+135u7tr4nEnkcNZhHl/+OOF+4bzZ+00jiWSfhK+GQfJuY2vcVoNqOHLNKdSPNpauP7zeaOZa8gKs/ACueMxoTnI/98jAi5Z20Oir2TDDGIredpjxehWsbOzodCJxYNHmxMR8t4NsP5J+SS3gWFhcwoTZWwnx9WDCNa3LPSenMIexS8dSpIp4v9/7+Ln7Gd/0ZlwHKfHGh0Tzixkrol1SGnaB22bBobWw7BVjc62Vk41O+i53Vk//xPFdxiz8rT8AYjSz9nzUIdcJuxg6kTiwEK8QGtp82edyDK/iTDYfSjvnN/Pa5rM/97MjKYOPb+tMgNfZW7qWqBL+76//Iy4tjilXTSEiIAIyj8L06yD9ENzyvdEOrmkXqlFXuGMuJPxtbG7261PGdsu9H4dOd1zcVstnTiLsOgYuf6hWzboH+43a0qpJVGArtnh60Mll3yUznyThRDbvLtnDwHZ1GdS+/FnJH2/+mN8P/s4TMU8YS5SnH4ZpgyHjsLEPuE4i2sWK6Al3LoA75kGdRrDwcXi/szFjvriw4vpKQfxy40vNp/0g4U9jEuGj22DQa7UuiYBOJA4vulFvjtpsdPXfYyzgWMsppXj6x624u7rw0rD25Z7zW8JvTNk8heHNh3Nbm9uMducvBxtLZ9/2o/FBoGlVIWJ8Gbl7kfE75RsG88fCBzGw6Rtj0c8znTWJcLdDTyKsTrppy8FFmRvm+Hobe7iXlChczjEhrzb4ITaRVfEneeX69tT1P7ttelfKLp79+1miQ6N5rvtzSGoCTB9qjHy54yejvVvTqosINL8KmvWDvb8ZfSg/PWAswdJ3gjFzXpUYe83//a5TTSKsTjqROLjWQa1xx4VjcpTMvAL2Hs+iVT0/q8Oyi+OZebzy8066RgRx82Vnr4d2MvckY5eOxd/dn3evfBf31INGEinKhdHzjVE4mmYPItByoDGhcddCWP4a/PhPYw5KYZ65E2E7Y75S2+FOM/+julxa79YJubm60da7Advy4mghh4k9kFJrE8mL83eQW1DMqzd0OOuuq7C4kPHLx5OSl8L0a6YTknXSSCIlxTB6AdQrvxlM06qVCLQZAq0Gw855xlIm3iEw+N9GonHgOSD2pBOJE4iq15nvsg4y1CuO9Qmp3NrNOTfuOZ/fdx5j4ZYkHu/f8qyVjpVSvLLmFTYc38Cbvd+kXREwfTC4uMKdCyGs/OHBmmY3Li7Qbrjx0HRnuzOIbtSbfBcXmgfsYd2B2tfhHp+cxRM/bKZVXT/uK2c3yG93fcvsvbP5Z4d/co1nA/hyCLi6w50/6ySiaQ5AJxInEBVqtP3nuiRwKCWXYxl5FkdUfU5k5XPntHWICJ/c3gV3W9lfydVJq3lz3Zv0De/Lw2GXG81Z7j5w10JjMT5N0yynE4kTqOdTjzBXb/a6ZBFAFrG1ZLmUnIIi7vlyHccz8/h8dAwRIWXXODqUcYgnVjxBZEAkrzW9EZevbgDPOkZzVlD1bhWqadrF04nESUQHtmKzhwfd3PYRWwuat4qKS3jkm41sPZzO+zd3plPjwDLHswqyeGTpIwBMbnUnvt/eAj6hcNfPEFj7+og0zZnpROIkosOv4LCbjZ514px+SXmlFBPnbef3Xcd58bp29G9bt8zxElXC038+TUJGAm+1vINGs+8H/wbGnUgtnBWsac5OJxInEV2/KwCeHnvYfiSD7PxyZtY6iSkr9vHfNQe5v08zbi9n29wPNn7A8sTlPBU5nG4/P2dM8LpzobFXg6ZpDkcnEifROqg1NoTD6iiqpJjNh9KsDumi/LTxMG/+upvrohvwr4Gtzjr+c/zPfLr1U0aEdWPU8g+N1VFHLzCWqNA0zSHpROIkPG2etPauzzY3oZVLolMu4Lgy7gRPztpM96ZB/Htk1FmTDref3M7zK5+ns28Ez6z7Canbzlg4rxavUaRptYFOJE4kum5ntnm4MzAggXVOtoDjrqMZ3PfVeiJDfPjk9hg8bGX3VTmRe4KxS8cS5OrJ2ztX49ago7Gkt3eQNQFrmnbBdCJxIlHhV5Dr4kITn11sPJhGcYlzbJOclJ7LXdPW4e3hyrS7up61v0heUR7jlo4jMy+VyQl7CG7QxVhx1TPAoog1TauMKiUSERkpIttFpEREYs449rSIxInIbhEZaJZ5i8hCEdll1nu91PkeIvKdWWeNiESUOjZaRPaaj9GlyiPNc/eadS9i5xnncWpiYqbaT1Z+EbuPZlocUcUy8gq5a9o6MvOKmHZnVxrW8Spz/NQIra0ntvBaUhKt63c19hPx9LcoYk3TKquqdyTbgBuAP0oXikhbYBTQDhgEfCQip9oy/qOUag10AnqKyDVm+T1AqlKqOfAO8IZ5rSBgItAN6ApMFJFTkw7eAN5RSrUAUs1r1FoNfRsS7OrFbsmkDpkOP5+koKiEB75eT9zxLKbc1pm2Dc5ODm/Hvs2Sg0t4IiWNq+p1NXY29PAt52qapjmqKiUSpdROpdTucg4NA2YqpfKVUvuBOKCrUipHKbXMrFsAbADCS9WZbj6fBVwlIgIMBBYrpVKUUqnAYmCQeayfeS5m3eFVeT+OTkSIqtOSLR4e9PM94NAz3JVSTJi9hb/jTvL6iCh6tQg965yZu2Yyfcd0bs7I5vaAtjDqG3D3tiBaTdOqwl59JA2BQ6V+TjTLThOROsBQ4Pcz6yilioB0IPg81woG0sxzy32NM15vjIjEikhscnLyxb0rBxAd3pMEdzd6+O9z6ImJb/22hx83Hubx/i25scvZkwj/SPyD19a8St/cfJ5yb4jc8r2xhpamaU6nwkQiIktEZFs5j2Hnq1ZO2emeYRGxAd8Ck5VS8RXUqWx5uZRSU5VSMUqpmNDQs78dO4uoekZXlJvrTg6n5XIkLdfiiM72zZqDfLAsjlGXNeLhfmcvrLjj5A6eWD6eVgWFvFHkj+ttc3THuqY5sQr3I1FKXX0R100EGpX6ORw4UurnqcBepdS75dRJNBNNAJBilvc941rLgRNAHRGxmXclZ75GrdQuuB2uCAeLj+BKMbEHUrnujA5sKy3ddYxnf9pK31ahTBreHjljo5+j2Ud5ePH9BBTk8mGODe+75oFPiEXRappWHezVtDUPGGWOxIoEWgBrAURkEkaSeLScOqdGZN0ILFVKKWARMEBEAs1O9gHAIvPYMvNczLpz7fR+HIa3mzctveqyxV2Idj/CegeaT7IlMY2H/ruRtg38+fCWzthcy/56ZRZk8sCie8nNTeGj9GJCb59rrKGlaZpTq+rw3+tFJBG4HFgoIosAlFLbge+BHcCvwENKqWIRCQeeAdoCG0Rkk4jca17ucyBYROKA8cAE81opwMvAOvPxklkG8BQw3qwTbF6j1osK68RWDw8GBx1knYN0uB88mcPdX64j2NedL+68DB+Psje7hSWFPP77wyRkHODttFxa3DpHLwWvabVElbbaVUrNAeac49grwCtnlCVSft8GSqk8YOQ5jn0BfFFOeTzGkOBLSlR4T7478AuNPHay62BPMvMK8fN0q7iinaRmF3DntLUUFitmjulKmJ9nmeNKKV756zlWHd/AS2nZXP6PHyCsjUXRappW3fTMdicUHdYRgJTiOEoUbDyYZlkseYXF3DsjlsS0XD4bHXPWfusAn2/8kNn7FzImPZvrh38FDbtYEKmmafaiE4kTauzXmDouHuwiixDJsGwBx+ISxaMzN7HhYCrv3tSRyyLOXhfr5z1zeG/rJwzOzuHhgVMgoqcFkWqaZk86kTih/01MdGdI0GHWWzTDfdLCHfy6/SjPDG7D4A5n7xWy4cganl01kS55+bx8xWtIq4EWRKlpmr3pROKkosJ7sM/Njct949h4MI2i4pIaff3P/oxn2t8J3N0zknt7nd1pnpC6j7GL76NhQQHvdXoc96h/1Gh8mqbVHJ1InFRU3S4oERQ7yCkoZmdSzS3guHBLEpMW7uSa9vV49tqzO81Tck7w4IJRuBYX8FHL0QR0va/GYtM0rebpROKkOoR0QID4wkRzYmLNNG+t3Z/CY99vIqZJIO/c1PGszanyCnMZO+d6jhflMLnhYBr1ebpG4tI0zTo6kTgpX3dfmnmGsdXNhV5+x2pkAce445n8c0Ys4YFefHpHDJ5uZTenKlElPDNnBFsKU3kt8DKiB/zb7jFpmmY9nUicWHRYR7Z4uDM48CCxB1IwJvvbx/HMPEZ/sQ43V2H6XV0J9Dl765d359/Bb7mHeNyrGf2HTQMpd8qQpmm1jE4kTiy6YU8yXF2pZ9vOsYx8ElPts4Bjdn4Rd3+5jpTsAr648zIaBZ291Pv3vz3GtNTN3GQL5Y4bZ+skommXEJ1InFhUmLFjYnLBXgC79JMUFpfw4H83sDMpk49u7UxUeJ2zzvnzr9d49chieuHDhJELENcqLZigaZqT0YnEiUUGROLn4s4OlUljj+xq7ydRSvHsnG2s2JPMpOHtubJ12Fnn7NrwOU/s/ZqWuPOfGxdg0xtTadolRycSJ+YiLnQIaM5mDw+uDz1c7Rtdvb80ju9iD/FIv+bc3LXxWceP7prLQxvfwk9sfDDsB7z1cvCadknSicTJRTXswV53Ny7z3MvuY5mk5xZWy3V/iD3E24v3cEPnhozv3/Ks41kJf/LQXxPIdnXlwwGfERbYrFpeV9M056MTiZOLrteFEhEKi7ahFGw4WPW7kj/2JPP0j1u5onkIr98QddbmVIVJm3li0Rj22Wy8fcVrtGpwWZVfU9M056UTiZPrENIBgLj8Q3i4FLO+iv0k24+k8+B/N9A8zJcpt3XG3Vb2V0SdiOPVuaP429PGcx0fpkfzIVV6PU3TnJ9OJE4uwCOACI9gtri5MDjsJOuqsGPi4bRc7pq2Dj9PG1/e1fXsPU7SE5n2w3Bmedm4t9n1jOiolz7RNE0nklohOqwTWzw9uNrvAJsT0yi8iAUc03MKufOLteQWFvPlXV2pF1B2cyqykvn1myG84y1cU7c7j/R8oXqC1zTN6elEUgtENbycFFdX6rKNvMISth/JqFT9/KJixnwVS8LJbD65vQut6vmVPSE3jY3fDOUZryI6BzTn5f4f4CL6V0fTNIP+NKgFokONiYlJebsBiK1E81ZJieKJH7awZn8K/xkZTY9mZwzhLcjm4Dc3MNaWSX2vMN4bNA0PV49qi13TNOenE0kt0LxOc7zExtbiTKID8yo1MfGNRbuYv/kITw1qzbCODcseLMwj9dubeEAdAQ9fPrrmS+p41qne4DVNc3pVSiQiMlJEtotIiYjEnHHsaRGJE5HdInLW1ngiMk9EtpX62UNEvjPrrBGRiFLHRovIXvMxulR5pHnuXrPu2SsJXgJcXVzpENCcLZ7uDAs6fMELOM5YlcAnK+K5rXtj7u9zxuZUxUXkz7qLcXm7Oeruyfv9P6Gx/9mTEjVN06p6R7INuAH4o3ShiLQFRgHtgEHARyLiWur4DUDWGde6B0hVSjUH3gHeMM8NAiYC3YCuwEQRCTTrvAG8o5RqAaSa17gkRTe8nN3u7nR238OJrAIOnMw57/m/bT/KC/O2c3Wburx4Xfuyc0VKSij56UGeS1nDRk9PXu39Bh3DOtr3DWia5rSqlEiUUjuVUrvLOTQMmKmUyldK7QfiMJIAIuILjAcmlVNnuvl8FnCVGJ9uA4HFSqkUpVQqsBgYZB7rZ56LWXd4Vd6PM4uq25kiEXLytwIQe57lUjYcTGXszI10CK/D+zd3wrX05lRKwS9P8n7ir/zi68NjXR5jYITea13TtHOzVx9JQ+BQqZ8TzTKAl4G3gDO/Mp+uo5QqAtKB4PNcKxhIM8898zXOIiJjRCRWRGKTk5Mv5j05tFMTE3fnHiDI89wd7gknsrl3eix1/T35fHQMXu5lN6fi95eYtetbPqsTwMiWI7mr3V32Dl3TNCdXYSIRkSUisq2cx7DzVSunTIlIR6C5UmrOhda5iPJyKaWmKqVilFIxoaGh5zrNaQV7BdPII4gtbq4Mr5dS7h3Jyax8Rk9bC8CXd3UlxPeM0Vd/vcPK9R8xKSSEng168n/d/u+s5VE0TdPOVOHGEUqpqy/iuolAo1I/hwNHgMuBLiKSYL52mIgsV0r1LVUnUURsQACQYpb3PeNay4ETQB0RsZl3Jade45IVFRrN2uzjvOC2ny8SgkjNLji9k2FuQTF3T4/laHoe347pTmSIT9nKaz9l94pXGB/ekOaBzXmr71vYXPS+IpqmVcxeTVvzgFHmSKxIoAWwVik1RSnVQCkVAVwB7DGTyKk6p0Zk3QgsVcbQo0XAABEJNDvZBwCLzGPLzHMx68610/txClENupNssxFSYvSTnFpWvrhE8ci3G9mSmMbkmzvRuXFg2Yqbv+P4oqd4KLwRPt4hfHDVh/i4+Zx5eU3TtHJVdfjv9SKSiHGnsVBEFgEopbYD3wM7gF+Bh5RSxRVc7nMgWETiMDrjJ5jXSsHoV1lnPl4yywCeAsabdYLNa1yyos0dEw9k78TNVYg9kIpSihfmbWfJzmO8eF07BrarV7bSzgVkz32QhxpFkGlz56OrPqKeT71yrq5pmlY+uZD5BrVNTEyMio2NtTqMaldYUkiPr7syMi2FnXxAlnswV7Wpy+u/7OK+3k15enCbshX2LaPom38wNrwxK12Leb/f+/QK72VN8JqmOTwRWa+UijmzXDeC1yJuLm609W/KltxshnkfYsJOV9YlpDI0ugFPDWpd9uRDa1Ezb+G1+o3406WA57s/r5OIpmkXRS+RUstEN+jGDg93ol12U1yi6BYZxH9GRuFSeq7I0a3w3xuZHhzG926F3N3+bka2HGld0JqmOTWdSGqZqLqdKRQhJ28zz17bhql3xOBhKzVX5MRe+Op6fvP14y2vEgZGDGRc53HWBaxpmtPTTVu1TFRoFABbMxO49/JwsJXanCrtIMwYxiab8H8BnnQMbsuknpP0kvCaplWJ/gSpZcK8w6jvHsAWNxc4uuV/BzKPwYxhHCrOYWzdUOr61GNyv8l42jzPfTFN07QLoBNJLRQVGs0WDw84ZMxiJycFvrqe9KzjPBjRnBIXFz66+iMCPQPPfyFN07QLoBNJLRTdoDtH3GwkH/ob8jPhvyMpOLmXsW0u43BeCpOvnEwT/yZWh6lpWi2hE0ktdKqfZMuxjTDzFtSRjTzXaRAbMvbxyhWv0LluZ4sj1DStNtGJpBZqE9QGN3Fhc0k27P+DD7rdxM8nNzGu8ziuibzG6vA0TatldCKphdxd3WkT0IzNnh7M6XE3U4/9xYgWI7in/SW775emaXakh//WUlH1uzEzYz9bji6nR4MePNP9Gb0kvKZpdqHvSGqp6LBoikqKiKwTyVt93sLNxa3iSpqmaRdB35HUUr0a9uKW1rdwV/u78HX3tTocTdNqMZ1IaikfNx+e7va01WFomnYJ0E1bmqZpWpXoRKJpmqZViU4kmqZpWpXoRKJpmqZViU4kmqZpWpXoRKJpmqZViU4kmqZpWpXoRKJpmqZViSilrI6hxolIMnDgIquHACeqMRx7c6Z4daz240zxOlOs4FzxVjXWJkqp0DMLL8lEUhUiEquUirE6jgvlTPHqWO3HmeJ1pljBueK1V6y6aUvTNE2rEp1INE3TtCrRiaTyplodQCU5U7w6VvtxpnidKVZwrnjtEqvuI9E0TdOqRN+RaJqmaVWiE4mmaZpWJTqRXCAR+UJEjovINqtjqYiINBKRZSKyU0S2i8g4q2M6HxHxFJG1IrLZjPdFq2OqiIi4ishGEVlgdSwVEZEEEdkqIptEJNbqeM5HROqIyCwR2WX+/l5udUznIiKtzP+mpx4ZIvKo1XGdi4g8Zv59bRORb0XEs9qurftILoyI9AaygBlKqfZWx3M+IlIfqK+U2iAifsB6YLhSaofFoZVLRATwUUpliYgb8BcwTim12uLQzklExgMxgL9SaojV8ZyPiCQAMUoph580JyLTgT+VUp+JiDvgrZRKszisComIK3AY6KaUutjJznYjIg0x/q7aKqVyReR74Gel1JfVcX19R3KBlFJ/AClWx3EhlFJJSqkN5vNMYCfQ0Nqozk0Zsswf3cyHw37DEZFw4FrgM6tjqU1ExB/oDXwOoJQqcIYkYroK2OeISaQUG+AlIjbAGzhSXRfWiaSWE5EIoBOwxuJQzstsKtoEHAcWK6UcOd53gX8BJRbHcaEU8JuIrBeRMVYHcx5NgWRgmtls+JmI+Fgd1AUaBXxrdRDnopQ6DPwHOAgkAelKqd+q6/o6kdRiIuILzAYeVUplWB3P+SilipVSHYFwoKuIOGTzoYgMAY4rpdZbHUsl9FRKdQauAR4ym2kdkQ3oDExRSnUCsoEJ1oZUMbMJ7jrgB6tjORcRCQSGAZFAA8BHRG6rruvrRFJLmX0Ns4H/KqV+tDqeC2U2ZSwHBlkbyTn1BK4z+x1mAv1E5GtrQzo/pdQR89/jwBygq7URnVMikFjqbnQWRmJxdNcAG5RSx6wO5DyuBvYrpZKVUoXAj0CP6rq4TiS1kNl5/TmwUyn1ttXxVEREQkWkjvncC+OXfpelQZ2DUupppVS4UioCozljqVKq2r7ZVTcR8TEHXGA2Ew0AHHLkoVLqKHBIRFqZRVcBDjlA5Aw348DNWqaDQHcR8TY/H67C6DutFjqRXCAR+RZYBbQSkUQRucfqmM6jJ3A7xrflU0MTB1sd1HnUB5aJyBZgHUYficMPq3USdYG/RGQzsBZYqJT61eKYzucR4L/m70JH4FVrwzk/EfEG+mN8w3dY5l3eLGADsBXjs7/alkvRw381TdO0KtF3JJqmaVqV6ESiaZqmVYlOJJqmaVqV6ESiaZqmVYlOJJqmaVqV6ESiaZqmVYlOJJqmaVqV/D9ZTjXgZzAOLgAAAABJRU5ErkJggg==\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": [
      "6.747494497205551e-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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "u_weak = un.copy()\n",
    "n_domain = 10000\n",
    "x_size, t_size = 100, 100 # Maybe not optimal?\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)\n",
    "\n",
    "p = 4\n",
    "wx, wt = np.meshgrid((xsup**2-1)**p, (tsup**2-1)**p)\n",
    "W = wx*wt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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_dt = FinDiff(1, tsup[1]-tsup[0], 1)\n",
    "\n",
    "dA01 = d_dt(W)\n",
    "dA10 = d_dx(W)\n",
    "dA20 = d_dxx(W)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Version 2"
   ]
  },
  {
   "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%|███████████████████████████████████████████████████████████████████████████████████████| 15/15 [01:49<00:00,  7.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6350940845195792e-08 [-0.99958087  0.09959018]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.2258673869710598, 0.18395419612124153)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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([f1, f2])\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",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    \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?\n",
    "print(min_loss, best_coeff)\n",
    "ground_coeff = np.array([-1., 0.1])\n",
    "errs = 100*(np.abs(best_coeff-ground_coeff)/np.abs(ground_coeff))\n",
    "errs.mean(), errs.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████| 30/30 [05:49<00:00, 11.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.557869826104744e-09 [-1.00915948  0.10136563]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1.1407884317585522, 0.22484083929951992)"
      ]
     },
     "execution_count": 41,
     "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([f1, f2])\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",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    \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?\n",
    "print(min_loss, best_coeff)\n",
    "ground_coeff = np.array([-1., 0.1])\n",
    "errs = 100*(np.abs(best_coeff-ground_coeff)/np.abs(ground_coeff))\n",
    "errs.mean(), errs.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Version 1 (Faster) | Should use the same domain when comparing V1 and V2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████| 15/15 [00:46<00:00,  3.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6207713377510488e-08 [-0.99957044  0.09961067]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.21614138285874773, 0.17318499856788794)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min_loss = 1e6; best_coeff = None\n",
    "for ws in trange(3, 33, 2):\n",
    "    X_weak = []\n",
    "    y_weak = []\n",
    "    denoised_u_weak = savgol_filter(u_weak, ws, 2)\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 = denoised_u_weak[ix, :][:, it]\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([f1, f2])\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",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    \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?\n",
    "print(min_loss, best_coeff)\n",
    "ground_coeff = np.array([-1., 0.1])\n",
    "errs = 100*(np.abs(best_coeff-ground_coeff)/np.abs(ground_coeff))\n",
    "errs.mean(), errs.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████| 30/30 [01:25<00:00,  2.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.819925210190737e-09 [-1.00769294  0.10108767]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.9284813724056762, 0.15918786314291777)"
      ]
     },
     "execution_count": 44,
     "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",
    "    denoised_u_weak = wiener(u_weak, ws)\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 = denoised_u_weak[ix, :][:, it]\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([f1, f2])\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",
    "    coeff = np.linalg.lstsq(X_weak, y_weak, rcond=None)[0]\n",
    "    \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?\n",
    "print(min_loss, best_coeff)\n",
    "ground_coeff = np.array([-1., 0.1])\n",
    "errs = 100*(np.abs(best_coeff-ground_coeff)/np.abs(ground_coeff))\n",
    "errs.mean(), errs.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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
}