holobench 1.15.0__tar.gz → 1.16.0__tar.gz

{holobench-1.15.0 → holobench-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.15.0
+Version: 1.16.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Description-Content-Type: text/markdown

{holobench-1.15.0 → holobench-1.16.0}/bencher/bench_cfg.py

@@ -344,9 +344,13 @@ class BenchCfg(BenchRunCfg):
     def inputs_as_str(self) -> List[str]:
         return [i.name for i in self.input_vars]
 
-    def describe_sweep(self, width: int = 800) -> pn.pane.Markdown:
+    def describe_sweep(self, width: int = 800, accordion=True) -> pn.pane.Markdown:
         """Produce a markdown summary of the sweep settings"""
-        return pn.pane.Markdown(self.describe_benchmark(), width=width)
+
+        desc = pn.pane.Markdown(self.describe_benchmark(), width=width)
+        if accordion:
+            return pn.Accordion(("Data Collection Parameters", desc))
+        return desc
 
     def describe_benchmark(self) -> str:
         """Generate a string summary of the inputs and results from a BenchCfg
@@ -427,7 +431,7 @@ class BenchCfg(BenchRunCfg):
         if self.description is not None and description:
             col.append(self.to_description())
         if describe_sweep:
-            col.append(pn.Accordion(("Data Collection Parameters", self.describe_sweep())))
+            col.append(self.describe_sweep())
         if results_suffix:
             col.append(pn.pane.Markdown("## Results:"))
         return col

{holobench-1.15.0 → holobench-1.16.0}/bencher/example/example_image.py

@@ -19,7 +19,7 @@ class BenchPolygons(bch.ParametrizedSweep):
     color = bch.StringSweep(["red", "green", "blue"])
     polygon = bch.ResultImage()
     area = bch.ResultVar()
-    # hmap = bch.ResultHmap()
+    side_length = bch.ResultVar()
 
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
@@ -27,6 +27,9 @@ class BenchPolygons(bch.ParametrizedSweep):
         # self.hmap = hv.Curve(points)
         self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"))
         self.area = self.radius * self.sides
+
+        self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
+        self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
         return super().__call__()
 
     def points_to_polygon_png(self, points: list[float], filename: str):
@@ -74,6 +77,8 @@ def example_image(
             f"Polygons Sweeping {len(s)} Parameters",
             input_vars=s,
         )
+        bench.report.append(bench.get_result().to_panes())
+
     return bench
 
 
@@ -92,6 +97,24 @@ def example_image_vid(
 
 if __name__ == "__main__":
 
+    def simple():
+        bench = BenchPolygons().to_bench(bch.BenchRunCfg(level=4))
+
+        # bench.plot_sweep(input_vars=["sides","color","radius"])
+
+        # res = bench.sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_heatmap(target_dimension=3))
+
+        bench.plot_sweep(input_vars=["sides"])
+        bench.plot_sweep(input_vars=["sides", "color"])
+
+        bench.plot_sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_line(target_dimension=1))
+
+        return bench
+
     def example_image_vid_sequential(
         run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
     ) -> bch.Bench:
@@ -108,6 +131,8 @@ if __name__ == "__main__":
     # ex_run_cfg.debug = True
     # ex_run_cfg.repeats = 2
     ex_run_cfg.level = 4
-    example_image_vid(ex_run_cfg).report.show()
+    # example_image_vid(ex_run_cfg).report.show()
+    simple().report.show()
+
     # example_image_vid_sequential(ex_run_cfg).report.show()
     # example_image(ex_run_cfg).report.show()

{holobench-1.15.0 → holobench-1.16.0}/bencher/example/example_video.py

@@ -16,6 +16,7 @@ class TuringPattern(bch.ParametrizedSweep):
 
     video = bch.ResultVideo()
     score = bch.ResultVar()
+    img = bch.ResultImage()
 
     def laplacian(self, Z, dx):
         Ztop = Z[0:-2, 1:-1]
@@ -66,6 +67,8 @@ class TuringPattern(bch.ParametrizedSweep):
                 rgb = np.array(fig.canvas.renderer.buffer_rgba())
                 vid_writer.append(rgb)
 
+        self.img = bch.add_image(rgb)
+
         self.video = vid_writer.write()
 
         self.score = self.alpha + self.beta
@@ -92,12 +95,25 @@ def example_video(
 def example_video_tap(
     run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
 ) -> bch.Bench:  # pragma: no cover
-    bench = TuringPattern().to_bench(run_cfg=run_cfg, report=report)
-    bench.plot_sweep(
+    tp = TuringPattern()
+
+    # run_cfg.use_sample_cache = False
+    # run_cfg.use_optuna = True
+    run_cfg.auto_plot = False
+    run_cfg.run_tag = "3"
+    bench = tp.to_bench(run_cfg=run_cfg, report=report)
+
+    res = bench.plot_sweep(
+        "phase",
         input_vars=["alpha", "beta"],
         # result_vars=["video","score"],
+        # result_vars=["score"],
+        run_cfg=run_cfg,
     )
 
+    bench.report.append(res.describe_sweep())
+    bench.report.append(res.to_heatmap())
+
     return bench
 
 
@@ -105,6 +121,7 @@ if __name__ == "__main__":
     run_cfg_ex = bch.BenchRunCfg()
     run_cfg_ex.level = 2
     run_cfg_ex.use_sample_cache = True
+    run_cfg_ex.only_hash_tag = True
 
     # example_video(run_cfg_ex).report.show()
     example_video_tap(run_cfg_ex).report.show()

{holobench-1.15.0 → holobench-1.16.0}/bencher/results/bench_result_base.py

@@ -17,13 +17,13 @@ from copy import deepcopy
 from bencher.results.optuna_result import OptunaResult
 from bencher.variables.results import ResultVar
 from bencher.plotting.plot_filter import VarRange, PlotFilter
+from bencher.utils import listify
 
 from bencher.variables.results import (
     ResultReference,
 )
 
 from bencher.results.composable_container.composable_container_panel import ComposableContainerPanel
-from bencher.utils import listify
 
 # todo add plugins
 # https://gist.github.com/dorneanu/cce1cd6711969d581873a88e0257e312
@@ -228,7 +228,7 @@ class BenchResultBase(OptunaResult):
         return " vs ".join(tit)
 
     def get_results_var_list(self, result_var: ParametrizedSweep = None) -> List[ResultVar]:
-        return self.bench_cfg.result_vars if result_var is None else [result_var]
+        return self.bench_cfg.result_vars if result_var is None else listify(result_var)
 
     def map_plots(
         self,

{holobench-1.15.0 → holobench-1.16.0}/bencher/results/holoview_result.py

@@ -8,12 +8,12 @@ from functools import partial
 import hvplot.xarray  # noqa pylint: disable=duplicate-code,unused-import
 import xarray as xr
 
-from bencher.utils import hmap_canonical_input, get_nearest_coords, get_nearest_coords1D
+from bencher.utils import hmap_canonical_input, get_nearest_coords, get_nearest_coords1D, listify
 from bencher.results.panel_result import PanelResult
 from bencher.results.bench_result_base import ReduceType
 
 from bencher.plotting.plot_filter import PlotFilter, VarRange
-from bencher.variables.results import ResultVar
+from bencher.variables.results import ResultVar, ResultImage, ResultVideo
 
 
 hv.extension("bokeh", "plotly")
@@ -85,6 +85,7 @@ class HoloviewResult(PanelResult):
             float_range=VarRange(0, 0),
             cat_range=VarRange(0, None),
             repeats_range=VarRange(1, 1),
+            panel_range=VarRange(0, None),
             reduce=ReduceType.SQUEEZE,
             target_dimension=2,
             result_var=result_var,
@@ -124,15 +125,34 @@ class HoloviewResult(PanelResult):
             **kwargs,
         )
 
-    def to_line(self, result_var: Parameter = None, **kwargs) -> Optional[pn.panel]:
+    def to_line(
+        self,
+        result_var: Parameter = None,
+        tap_var=None,
+        tap_container: pn.pane.panel = None,
+        target_dimension=2,
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        if tap_var is None:
+            tap_var = self.plt_cnt_cfg.panel_vars
+        elif not isinstance(tap_var, list):
+            tap_var = [tap_var]
+
+        if len(tap_var) == 0 or self.plt_cnt_cfg.inputs_cnt > 1:
+            heatmap_cb = self.to_line_ds
+        else:
+            heatmap_cb = partial(
+                self.to_line_tap_ds, result_var_plots=tap_var, container=tap_container
+            )
+
         return self.filter(
-            self.to_line_ds,
+            heatmap_cb,
             float_range=VarRange(1, 1),
             cat_range=VarRange(0, None),
             repeats_range=VarRange(1, 1),
             panel_range=VarRange(0, None),
             reduce=ReduceType.SQUEEZE,
-            target_dimension=2,
+            target_dimension=target_dimension,
             result_var=result_var,
             result_types=(ResultVar),
             **kwargs,
@@ -140,7 +160,6 @@ class HoloviewResult(PanelResult):
 
     def to_line_ds(self, dataset: xr.Dataset, result_var: Parameter, **kwargs):
         x = self.plt_cnt_cfg.float_vars[0].name
-        # y = self.plt_cnt_cfg.result_vars[0].name
         by = None
         if self.plt_cnt_cfg.cat_cnt >= 1:
             by = self.plt_cnt_cfg.cat_vars[0].name
@@ -178,22 +197,28 @@ class HoloviewResult(PanelResult):
         self,
         result_var: Parameter = None,
         tap_var=None,
-        tap_container=None,
+        tap_container: pn.pane.panel = None,
         target_dimension=2,
         **kwargs,
     ) -> Optional[pn.panel]:
         if tap_var is None:
+            tap_var = self.plt_cnt_cfg.panel_vars
+        elif not isinstance(tap_var, list):
+            tap_var = [tap_var]
+
+        if len(tap_var) == 0:
             heatmap_cb = self.to_heatmap_ds
         else:
             heatmap_cb = partial(
-                self.to_heatmap_container_tap_ds, result_var_plot=tap_var, container=tap_container
+                self.to_heatmap_container_tap_ds, result_var_plots=tap_var, container=tap_container
             )
 
         return self.filter(
             heatmap_cb,
-            float_range=VarRange(2, None),
+            float_range=VarRange(0, None),
             cat_range=VarRange(0, None),
-            input_range=VarRange(1, None),
+            input_range=VarRange(2, None),
+            panel_range=VarRange(0, None),
             target_dimension=target_dimension,
             result_var=result_var,
             result_types=(ResultVar),
@@ -204,56 +229,180 @@ class HoloviewResult(PanelResult):
         self, dataset: xr.Dataset, result_var: Parameter, **kwargs
     ) -> Optional[hv.HeatMap]:
         if len(dataset.dims) >= 2:
-            x = self.plt_cnt_cfg.float_vars[0].name
-            y = self.plt_cnt_cfg.float_vars[1].name
+            x = self.bench_cfg.input_vars[0].name
+            y = self.bench_cfg.input_vars[1].name
             C = result_var.name
             title = f"Heatmap of {result_var.name}"
             time_args = self.time_widget(title)
             return dataset.hvplot.heatmap(x=x, y=y, C=C, cmap="plasma", **time_args, **kwargs)
         return None
 
+    def result_var_to_container(self, result_var):
+        if isinstance(result_var, ResultImage):
+            return pn.pane.PNG
+        return pn.pane.Video if isinstance(result_var, ResultVideo) else pn.pane.panel
+
+    def setup_results_and_containers(self, result_var_plots, container, **kwargs):
+        result_var_plots = listify(result_var_plots)
+        if container is None:
+            containers = [self.result_var_to_container(rv) for rv in result_var_plots]
+        else:
+            containers = listify(container)
+
+        cont_instances = [c(**kwargs) for c in containers]
+        return result_var_plots, cont_instances
+
     def to_heatmap_container_tap_ds(
         self,
         dataset: xr.Dataset,
         result_var: Parameter,
-        result_var_plot: Parameter,
-        container: pn.pane.panel = pn.pane.panel,
+        result_var_plots: List[Parameter] = None,
+        container: pn.pane.panel = None,
         **kwargs,
     ) -> pn.Row:
-        htmap = self.to_heatmap_ds(dataset, result_var).opts(tools=["hover", "tap"], **kwargs)
-        htmap_posxy = hv.streams.Tap(source=htmap, x=0, y=0)
-
-        container_instance = container(**kwargs)
+        htmap = self.to_heatmap_ds(dataset, result_var).opts(tools=["hover"], **kwargs)
+        result_var_plots, cont_instances = self.setup_results_and_containers(
+            result_var_plots, container
+        )
         title = pn.pane.Markdown("Selected: None")
 
-        def tap_plot(x, y):  # pragma: no cover
-            x_nearest = get_nearest_coords1D(
+        state = dict(x=None, y=None, update=False)
+
+        def tap_plot_heatmap(x, y):  # pragma: no cover
+            # print(f"moved {x}{y}")
+            x_nearest_new = get_nearest_coords1D(
                 x, dataset.coords[self.bench_cfg.input_vars[0].name].data
             )
-            y_nearest = get_nearest_coords1D(
+            y_nearest_new = get_nearest_coords1D(
                 y, dataset.coords[self.bench_cfg.input_vars[1].name].data
             )
-            kdims = {}
-            kdims[self.bench_cfg.input_vars[0].name] = x_nearest
-            kdims[self.bench_cfg.input_vars[1].name] = y_nearest
-
-            if hasattr(htmap, "current_key"):
-                for d, k in zip(htmap.kdims, htmap.current_key):
-                    kdims[d.name] = k
-
-            ds = dataset[result_var_plot.name]
-            val = ds.sel(**kdims)
-            item = self.zero_dim_da_to_val(val)
-            title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
-            container_instance.object = item
-            if hasattr(container, "autoplay"):  # container is a video, set to autoplay
-                container_instance.paused = False
-                container_instance.time = 0
-                container_instance.loop = True
-                container_instance.autoplay = True
-
-        htmap_posxy.add_subscriber(tap_plot)
-        bound_plot = pn.Column(title, container_instance)
+
+            # xv = self.bench_cfg.input_vars[0].name
+            # yv = self.bench_cfg.input_vars[1].name
+            # nearest = get_nearest_coords(dataset, **{xv: x, yv: y})
+            # print(nearest)
+            # print(x_nearest_new,y_nearest_new)
+
+            if x_nearest_new != state["x"]:
+                state["x"] = x_nearest_new
+                state["update"] = True
+            if y_nearest_new != state["y"]:
+                state["y"] = y_nearest_new
+                state["update"] = True
+
+            if state["update"]:
+                kdims = {}
+                kdims[self.bench_cfg.input_vars[0].name] = state["x"]
+                kdims[self.bench_cfg.input_vars[1].name] = state["y"]
+
+                if hasattr(htmap, "current_key"):
+                    for d, k in zip(htmap.kdims, htmap.current_key):
+                        kdims[d.name] = k
+                for rv, cont in zip(result_var_plots, cont_instances):
+                    ds = dataset[rv.name]
+                    val = ds.sel(**kdims)
+                    item = self.zero_dim_da_to_val(val)
+                    title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
+                    cont.object = item
+                    if hasattr(cont, "autoplay"):  # container is a video, set to autoplay
+                        cont.paused = False
+                        cont.time = 0
+                        cont.loop = True
+                        cont.autoplay = True
+                state["update"] = False
+
+        def on_exit(x, y):  # pragma: no cover # pylint: disable=unused-argument
+            state["update"] = True
+
+        htmap_posxy = hv.streams.PointerXY(source=htmap)
+        htmap_posxy.add_subscriber(tap_plot_heatmap)
+        ls = hv.streams.MouseLeave(source=htmap)
+        ls.add_subscriber(on_exit)
+
+        bound_plot = pn.Column(title, *cont_instances)
+        return pn.Row(htmap, bound_plot)
+
+    def to_line_tap_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        result_var_plots: List[Parameter] = None,
+        container: pn.pane.panel = pn.pane.panel,
+        **kwargs,
+    ) -> pn.Row:
+        htmap = self.to_line_ds(dataset, result_var).opts(tools=["hover"], **kwargs)
+        result_var_plots, cont_instances = self.setup_results_and_containers(
+            result_var_plots, container
+        )
+        title = pn.pane.Markdown("Selected: None")
+
+        state = dict(x=None, y=None, update=False)
+
+        def tap_plot_line(x, y):  # pragma: no cover
+            # print(f"{x},{y}")
+            # print(dataset)
+
+            # xv = self.bench_cfg.input_vars[0].name
+            # yv = self.bench_cfg.input_vars[1].name
+
+            # x_nearest_new = get_nearest_coords1D(
+            #     x, dataset.coords[self.bench_cfg.input_vars[0].name].data
+            # )
+            # y_nearest_new = get_nearest_coords1D(
+            #     y, dataset.coords[self.bench_cfg.input_vars[1].name].data
+            # )
+
+            # kwargs = {xv: x, yv: y}
+
+            # nearest = get_nearest_coords(dataset, **kwargs)
+            # print(nearest)
+
+            x_nearest_new = get_nearest_coords1D(
+                x, dataset.coords[self.bench_cfg.input_vars[0].name].data
+            )
+
+            if x_nearest_new != state["x"]:
+                state["x"] = x_nearest_new
+                state["update"] = True
+
+            if self.plt_cnt_cfg.inputs_cnt > 1:
+                y_nearest_new = get_nearest_coords1D(
+                    y, dataset.coords[self.bench_cfg.input_vars[1].name].data
+                )
+                if y_nearest_new != state["y"]:
+                    state["y"] = y_nearest_new
+                    state["update"] = True
+
+            if state["update"]:
+                kdims = {}
+                kdims[self.bench_cfg.input_vars[0].name] = state["x"]
+                if self.plt_cnt_cfg.inputs_cnt > 1:
+                    kdims[self.bench_cfg.input_vars[1].name] = state["y"]
+
+                if hasattr(htmap, "current_key"):
+                    for d, k in zip(htmap.kdims, htmap.current_key):
+                        kdims[d.name] = k
+                for rv, cont in zip(result_var_plots, cont_instances):
+                    ds = dataset[rv.name]
+                    val = ds.sel(**kdims)
+                    item = self.zero_dim_da_to_val(val)
+                    title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
+                    cont.object = item
+                    if hasattr(cont, "autoplay"):  # container is a video, set to autoplay
+                        cont.paused = False
+                        cont.time = 0
+                        cont.loop = True
+                        cont.autoplay = True
+                state["update"] = False
+
+        def on_exit(x, y):  # pragma: no cover # pylint: disable=unused-argument
+            state["update"] = True
+
+        htmap_posxy = hv.streams.PointerXY(source=htmap)
+        htmap_posxy.add_subscriber(tap_plot_line)
+        ls = hv.streams.MouseLeave(source=htmap)
+        ls.add_subscriber(on_exit)
+        bound_plot = pn.Column(title, *cont_instances)
         return pn.Row(htmap, bound_plot)
 
     def to_error_bar(self) -> hv.Bars:

{holobench-1.15.0 → holobench-1.16.0}/bencher/utils.py

@@ -61,6 +61,9 @@ def get_nearest_coords(dataset: xr.Dataset, collapse_list=False, **kwargs) -> di
 def get_nearest_coords1D(val: Any, coords) -> Any:
     if isinstance(val, (int, float)):
         return min(coords, key=lambda x_: abs(x_ - val))
+    for i in coords:
+        if val == i:
+            return i
     return val
 
 

{holobench-1.15.0 → holobench-1.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.15.0"
+version = "1.16.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"