Merge pull request #6 from greinerth/feature/computational_gain

print computational gains in visualize_results.py

.devcontainer/devcontainer.json

@@ -26,7 +26,7 @@
 	],
 
 	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "pip3 install --user -e . &&  pip3 install --user -e git+https://github.com/greinerth/PyDMD.git@feature/varpro#egg=pydmd && sudo apt update && sudo apt upgrade -y && sudo apt install texlive-xetex cm-super dvipng -y",
+	"postCreateCommand": "pip3 install --user -e .[dev] &&  pip3 install --user -e git+https://github.com/greinerth/PyDMD.git@feature/varpro#egg=pydmd && sudo apt update && sudo apt upgrade -y && sudo apt install texlive-xetex cm-super dvipng -y",
 	"customizations": {
 		"vscode": {
 			"extensions": [

.vscode/settings.json

@@ -3,5 +3,9 @@
         "tests"
     ],
     "python.testing.unittestEnabled": false,
-    "python.testing.pytestEnabled": true
+    "python.testing.pytestEnabled": true,
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.autopep8"
+    },
+    "python.formatting.provider": "none"
 }

varprodmdstatspy/visualize_results.py

@@ -3,7 +3,7 @@
 import argparse
 import os
 import pickle
-
+import numpy as np
 import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn as sns
@@ -29,15 +29,59 @@ def visualize_stats():
     with open(__args.path, 'rb') as handle:
         data = pickle.load(handle)
         df = pd.DataFrame(data)
+        runtimes = np.array(df.loc[:, "E[t]"].to_list())
+        compression = np.array(df.loc[:, "c"].to_list())
+
+        noise_levels = np.array(sorted(set(df.loc[:, "STD_NOISE"].to_list())))
+        msk = df.loc[:, "Method"].to_numpy() == "BOPDMD"
+        idx = np.arange(msk.size)
+        bopdmd_idx = idx[msk]
+        varpro_idx = idx[~msk]
+
+        for noise in noise_levels:
+            __varpro_idx = np.where(
+                df.loc[varpro_idx, "STD_NOISE"].to_numpy() == noise)[0]
+            __varpro_idx = varpro_idx[__varpro_idx]
+            __bopdmd_idx = np.where(
+                df.loc[bopdmd_idx, "STD_NOISE"].to_numpy() == noise)[0]
+            __bopdmd_idx = bopdmd_idx[__bopdmd_idx]
+            __compressions = compression[__varpro_idx]
+
+            varpro_runtime_idx = np.argsort(runtimes[__varpro_idx])
+            bopdmd_runtime_idx = np.argsort(runtimes[__bopdmd_idx])
+
+            fastest_varpro = varpro_runtime_idx[0]
+            slowest_varpro = varpro_runtime_idx[-1]
+            fastest_bopdmd = bopdmd_runtime_idx[0]
+            slowest_bopdmd = bopdmd_runtime_idx[-1]
+
+            min_gain = runtimes[__bopdmd_idx[fastest_bopdmd]
+                                ] / runtimes[__varpro_idx[slowest_varpro]]
+            max_gain = runtimes[__bopdmd_idx[slowest_bopdmd]
+                                ] / runtimes[__varpro_idx[fastest_varpro]]
+
+            print(f"\nNoise level: {noise}")
+            min_gain_str = "Minimum gain: {:.4f}, VarPro Compression: {}"
+            max_gain_str = "Maximum gain: {:.4f}, VarPro Compression: {}"
+            min_gain_str = min_gain_str.format(min_gain, __compressions[slowest_varpro])
+            max_gain_str = max_gain_str.format(max_gain, __compressions[fastest_varpro])
+            str_len = max(len(min_gain_str), len(max_gain_str))
+
+            print(str_len * "=")
+            print(min_gain_str)
+            print(max_gain_str)
+
+        print("\n")
         print(df)
+
         # df.rename(columns={"E[t]": r"$E\left[t\right]$ in $s$"})
         if "E[SSIM]" in df.columns:
             df.rename({"E[SSIM]": r"$E\left[\overline{SSIM}\right]$",
                        "E[t]": r"$E\left[t\right]$ in $s$",
                        "STD_NOISE": r"$\sigma_{std}$",
                        "c": r"$c_{comp}$"},
-                       axis="columns",
-                       inplace=True)
+                      axis="columns",
+                      inplace=True)
             g0 = sns.FacetGrid(df, col=r"$\sigma_{std}$")
             g0.map_dataframe(sns.scatterplot,
                              r"$E\left[\overline{SSIM}\right]$",
@@ -52,8 +96,8 @@ def visualize_stats():
                        "E[t]": r"$E\left[t\right]$ in $s$",
                        "STD_NOISE": r"$\sigma_{std}$",
                        "c": r"$c_{comp}$"},
-                       axis="columns",
-                       inplace=True)
+                      axis="columns",
+                      inplace=True)
             g0 = sns.FacetGrid(df, col="$\\sigma_{std}$")
             g0.map_dataframe(sns.scatterplot,
                              r"$E\left[d\right]$ in $m$",
@@ -62,7 +106,7 @@ def visualize_stats():
                              legend="full",
                              hue="Method",
                              alpha=0.5)
-            
+
         else:
             raise ValueError("Unsupported Experiment!")