updated performance experiment notebook to use kerneldiff

Author: pavelkomarov

examples/4_performance_analysis.ipynb

@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "id": "5e5ea3c3-aed3-4b8d-a7c7-1db05fc73f3c",
    "metadata": {},
    "outputs": [],
@@ -31,7 +31,7 @@
     "from pynumdiff.utils.simulate import sine, triangle, pop_dyn, linear_autonomous, pi_cruise_control, lorenz_x\n",
     "from pynumdiff.utils.evaluate import rmse, error_correlation\n",
     "from pynumdiff.finite_difference import finitediff\n",
-    "from pynumdiff.smooth_finite_difference import mediandiff, meandiff, gaussiandiff, friedrichsdiff, butterdiff\n",
+    "from pynumdiff.smooth_finite_difference import kerneldiff, butterdiff\n",
     "from pynumdiff.polynomial_fit import splinediff, polydiff, savgoldiff\n",
     "from pynumdiff.basis_fit import spectraldiff, rbfdiff\n",
     "from pynumdiff.total_variation_regularization import tvrdiff, smooth_acceleration\n",
@@ -49,7 +49,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "ef461de3-e615-4c32-8931-51bf60d8e16c",
    "metadata": {},
    "outputs": [
@@ -74,15 +74,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 5,
    "id": "1eba51f1-bf31-4f84-b82b-176461319de6",
    "metadata": {},
    "outputs": [],
    "source": [
-    "methods = [(meandiff, 'MeanDiff'),\n",
-    "\t\t\t(mediandiff, 'MedianDiff'),\n",
-    "\t\t\t(gaussiandiff, 'GaussianDiff'),\n",
-    "\t\t\t(friedrichsdiff, 'FriedrichsDiff'),\n",
+    "methods = [(kerneldiff, 'KernelDiff'),\n",
     "\t\t\t(butterdiff, 'ButterDiff'),\n",
     "\t\t\t(splinediff, 'SplineDiff'),\n",
     "\t\t\t(polydiff, 'PolyDiff'),\n",
@@ -112,7 +109,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "275e4552-4479-40e3-b111-41c35d62ee9e",
    "metadata": {},
    "outputs": [],
@@ -121,14 +118,14 @@
     "\t\"\"\"Create and save a dataframe of results over all methods for all sims, given a certain\n",
     "\thyperparameterization. Each one of these takes about 11 minutes on my machine\"\"\"\t\n",
     "\ttry: # short circuit if the file already exists, just read in and display\n",
-    "\t\tres = pandas.read_csv(f\"~/Desktop/results2/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\",\n",
+    "\t\tres = pandas.read_csv(f\"~/Desktop/results/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\",\n",
     "\t\t\t\t\t\t\t index_col=0)\n",
     "\t\tprint(\".\", end='')\n",
     "\texcept FileNotFoundError:\n",
     "\t\ttvgamma = np.exp(-1.6*np.log(cutoff_frequency) -0.71*np.log(dt) - 5.1)\n",
-    "\t\t#res = pandas.DataFrame(index=[x[1] for x in methods], columns=[x[1] for x in sims])\n",
-    "\t\tres = pandas.read_csv(f\"~/Desktop/results/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\",\n",
-    "\t\t\t\t\t\t\t index_col=0)\n",
+    "\t\tres = pandas.DataFrame(index=[x[1] for x in methods], columns=[x[1] for x in sims])\n",
+    "\t\t#res = pandas.read_csv(f\"~/Desktop/results/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\",\n",
+    "\t\t#\t\t\t\t\t index_col=0)\n",
     "\n",
     "\t\tfor sim,sname in tqdm(sims):\n",
     "\t\t\tx, x_truth, dxdt_truth = sim(duration=4, dt=dt, noise_type=noise_type,\n",
@@ -137,7 +134,7 @@
     "\t\t\t#t = np.arange(0,dt*len(x), dt)\n",
     "\t\t\n",
     "\t\t\t#for method,mname in tqdm(methods):\n",
-    "\t\t\tmethod,mname = (robustdiff, 'RobustDiff') # ADDING A METHOD\n",
+    "\t\t\tmethod,mname = (robustdiff, 'KernelDiff') # ADDING A METHOD\n",
     "\t\t\t#best_params, best_rmse = optimize(method, x, dt, dxdt_truth=dxdt_truth, metric='rmse')\n",
     "\t\t\t#best_params, best_ec = optimize(method, x, dt, dxdt_truth=dxdt_truth, metric='error_correlation')\n",
     "\t\t\tbest_params, best_score = optimize(method, x, dt, tvgamma=tvgamma,\n",
@@ -148,7 +145,7 @@
     "\t\t\tec = error_correlation(dxdt_hat, dxdt_truth)\n",
     "\t\t\tres.loc[mname, sname] = f\"RMSE: {rms_dxdt:.5g}<br/>R^2: {ec:.5g}\"\n",
     "\t\n",
-    "\t\tres.to_csv(f\"~/Desktop/results2/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\")\n",
+    "\t\tres.to_csv(f\"~/Desktop/results/{cutoff_frequency}_{dt}_{noise_type}_{noise_scale}_{outliers}_{random_seed}.csv\")\n",
     "\n",
     "\t\tdisplay(HTML(res.style.set_caption(\n",
     "\t\t\tf\"cutoff_frequency={cutoff_frequency}, dt={dt}, noise_type={noise_type}, noise_scale={noise_scale}, outliers={outliers}, random_seed={random_seed}\").set_properties(\n",
@@ -169,36 +166,43 @@
    "execution_count": null,
    "id": "fac1f6c9-f657-492b-8b68-9bdc28298261",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                         | 0/6 [00:00<?, ?it/s]"
+     ]
+    }
+   ],
    "source": [
     "for random_seed in random_seeds:\n",
     "\t# Does dt matter? Vary dt, keeping everything else constant\n",
-    "\t# for dt in dts: # 4\n",
-    "\t# \tmain_loop(dt=dt, cutoff_frequency=3, noise_type='normal', noise_params=[0, 0.1], noise_scale=1,\n",
-    "\t# \t\t\t  outliers=False, random_seed=random_seed)\n",
+    "\tfor dt in dts: # 4\n",
+    "\t\tmain_loop(dt=dt, cutoff_frequency=3, noise_type='normal', noise_params=[0, 0.1], noise_scale=1,\n",
+    "\t\t\t\t  outliers=False, random_seed=random_seed)\n",
     "\n",
-    "\t# # Does noise type matter? Vary noise type, keeping everything else constant\n",
-    "\t# for noise_type,noise_params in noise_types: # 3\n",
-    "\t# \tmain_loop(dt=0.01, cutoff_frequency=3, noise_type=noise_type, noise_params=noise_params, noise_scale=1,\n",
-    "\t# \t\t\t  outliers=False, random_seed=random_seed)\n",
+    "\t# Does noise type matter? Vary noise type, keeping everything else constant\n",
+    "\tfor noise_type,noise_params in noise_types: # 3\n",
+    "\t\tmain_loop(dt=0.01, cutoff_frequency=3, noise_type=noise_type, noise_params=noise_params, noise_scale=1,\n",
+    "\t\t\t\t  outliers=False, random_seed=random_seed)\n",
     "\t\n",
-    "\t# # Does noise scale matter? Vary noise scale, keeping everything else constant\n",
-    "\t# for noise_scale in noise_scales: # 4\n",
-    "\t# \tmain_loop(dt=0.01, cutoff_frequency=3, noise_type='normal', noise_params=[0,0.1], noise_scale=noise_scale,\n",
-    "\t# \t\t\t  outliers=False, random_seed=random_seed)\n",
+    "\t# Does noise scale matter? Vary noise scale, keeping everything else constant\n",
+    "\tfor noise_scale in noise_scales: # 4\n",
+    "\t\tmain_loop(dt=0.01, cutoff_frequency=3, noise_type='normal', noise_params=[0,0.1], noise_scale=noise_scale,\n",
+    "\t\t\t\t  outliers=False, random_seed=random_seed)\n",
     "\t\n",
     "\t# Does the presence of outliers matter? Vary presence of outliers, keeping everything else constant\n",
     "\tfor outliers in [False, True]: # 2 Maybe try this one with more noise types too?\n",
     "\t\tmain_loop(dt=0.01, cutoff_frequency=3, noise_type='normal', noise_params=[0, 0.1], noise_scale=1,\n",
     "\t\t\t\t  outliers=outliers, random_seed=random_seed)\n",
     "\t\n",
-    "\t# #Does the cutoff frequency matter? Vary cutoff, keeping everything else constant\n",
-    "\t# for cutoff_frequency in cutoff_frequencies: # 5\n",
-    "\t# \tmain_loop(dt=0.01, cutoff_frequency=cutoff_frequency, noise_type='normal', noise_params=[0, 0.1], noise_scale=1,\n",
-    "\t# \t\t\t  outliers=False, random_seed=random_seed)\n",
+    "\t# Does the cutoff frequency matter? Vary cutoff, keeping everything else constant\n",
+    "\tfor cutoff_frequency in cutoff_frequencies: # 5\n",
+    "\t\tmain_loop(dt=0.01, cutoff_frequency=cutoff_frequency, noise_type='normal', noise_params=[0, 0.1], noise_scale=1,\n",
+    "\t\t\t\t  outliers=False, random_seed=random_seed)\n",
     "\t\n",
-    "\t# Because they all pass through the central point, the number of unique runs here is 4 + 3 + 2 + 1 + 2 = 12 * 11 minutes = 2 hours\n",
-    "\t# repeat for each random seed = 10 hours?"
+    "\t# Because they all pass through the central point, the number of unique runs here is 4 + 2 + 3 + 1 + 4 = 14"
    ]
   },
   {
@@ -224,9 +228,9 @@
     "\t\"\"\"\n",
     "\tfig, ax = plt.subplots(2, 1, figsize=(30, 12), sharex=True, gridspec_kw={'hspace': 0})\n",
     "\n",
-    "\tmarkers = ['^', 's', 'p', 'h', 'd', '2', '+', 'x', '*',  r'$\\rho$', 'o', r'$\\gamma$', r'$\\tilde{\\gamma}$', '.', r'$M$']\n",
-    "\tfacecolors = ['none' if i not in [5,6,7,13] else None for i in range(len(markers))] # 'none makes transparent'\n",
-    "\tsizes = [90, 70, 90, 90, 80, 120, 100, 70, 120, 90, 70, 90, 170, 70, 120]\n",
+    "\tmarkers = ['p', 'd', '*', '2', '+', 'x', 'o', '.', r'$\\gamma$', r'$\\tilde{\\gamma}$', '^', 's']\n",
+    "\tfacecolors = ['none' if i not in [3,4,5,7] else None for i in range(len(markers))] # 'none makes transparent'\n",
+    "\tsizes = [90, 80, 120, 120, 100, 70, 70, 70, 90, 170, 90, 70]\n",
     "\tcmap = plt.get_cmap('turbo', 6) # Assign a unique color for each simulation\n",
     "\tcolors = [cmap(i) for i in range(6)]; colors[0] = 'purple'; colors[-1] = 'red'\n",
     "\tcolors[2] = [x*0.8 for x in colors[2]]; colors[3] = mcolors.to_rgb('gold'); colors[3] = [x*0.9 for x in colors[3]]\n",

pynumdiff/smooth_finite_difference/_smooth_finite_difference.py

@@ -8,14 +8,11 @@
 from pynumdiff.utils import utility
 
 
-################################
-# Smoothing finite differences #
-################################
 def kerneldiff(x, dt, kernel='friedrichs', window_size=5, num_iterations=1):
     """Differentiate by applying a smoothing kernel to the signal, then performing 2nd-order finite difference.
     :code:`meandiff`, :code:`mediandiff`, :code:`gaussiandiff`, and :code:`friedrichsdiff` call this function.
 
-    :param np.ndarray[float] x: data to differentiate
+    :param np.array[float] x: data to differentiate
     :param float dt: step size
     :param str kernel: prefilter data, {:code:`'mean'`, :code:`'median'`, :code:`'gaussian'`,
         :code:`'friedrichs'`}
@@ -45,7 +42,7 @@ def meandiff(x, dt, params=None, options={}, window_size=5, num_iterations=1):
     """Perform mean smoothing by convolving mean kernel with x followed by second order finite difference\n
     **Deprecated**, prefer :code:`kerneldiff` with kernel :code:`'mean'` instead.
 
-    :param np.ndarray[float] x: data to differentiate
+    :param np.array[float] x: data to differentiate
     :param float dt: step size
     :param list[int] params: (**deprecated**, prefer :code:`window_size` and :code:`num_iterations`)
         :code:`[window_size]` or, :code:`if 'iterate' in options`, :code:`[window_size, num_iterations]`