holobench 1.3.4__tar.gz → 1.3.5__tar.gz

{holobench-1.3.4 → holobench-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.3.4
+Version: 1.3.5
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Requires-Python: >=3.10
@@ -21,7 +21,6 @@ Requires-Dist: strenum>=0.4.0,<=0.4.15
 Requires-Dist: scikit-learn>=1.2,<=1.3.2
 Requires-Dist: str2bool>=1.1,<=1.1
 Requires-Dist: scoop>=0.7.0,<=0.7.2.0
-Requires-Dist: ffmpeg-downloader>=0.3.0,<=0.3.0
 Requires-Dist: moviepy>=1.0.3,<=1.0.3
 Requires-Dist: black>=23,<=23.12.1 ; extra == "test"
 Requires-Dist: pylint>=2.16,<=3.0.3 ; extra == "test"

{holobench-1.3.4 → holobench-1.3.5}/bencher/__init__.py

@@ -38,4 +38,4 @@ from .results.panel_result import PanelResult
 from .results.holoview_result import ReduceType, HoloviewResult
 from .bench_report import BenchReport
 from .job import Executors
-from .video_writer import VideoWriter
+from .video_writer import VideoWriter, add_image

{holobench-1.3.4 → holobench-1.3.5}/bencher/bench_cfg.py

@@ -164,7 +164,14 @@ class BenchRunCfg(BenchPlotSrvCfg):
         doc="The function can be run serially or in parallel with different futures executors",
     )
 
-    plot_size = param.Integer(default=None)
+    plot_size = param.Integer(default=None, doc="Sets the width and height of the plot")
+    plot_width = param.Integer(
+        default=None,
+        doc="Sets with width of the plots, this will ovverride the plot_size parameter",
+    )
+    plot_height = param.Integer(
+        default=None, doc="Sets the height of the plot, this will ovverride the plot_size parameter"
+    )
 
     @staticmethod
     def from_cmd_line() -> BenchRunCfg:  # pragma: no cover

{holobench-1.3.4 → holobench-1.3.5}/bencher/bencher.py

@@ -200,7 +200,7 @@ class Bench(BenchPlotServer):
         run_cfg: BenchRunCfg = None,
         plot: bool = False,
     ) -> BenchResult:
-        title = "Sweeping " + " vs ".join([i.name for i in input_vars])
+        title = "Sweeping " + " vs ".join([self.get_name(i) for i in input_vars])
         return self.plot_sweep(
             title,
             input_vars=input_vars,
@@ -217,6 +217,7 @@ class Bench(BenchPlotServer):
 
     def sweep_sequential(
         self,
+        title="",
         input_vars: List[ParametrizedSweep] = None,
         result_vars: List[ParametrizedSweep] = None,
         const_vars: List[ParametrizedSweep] = None,
@@ -231,12 +232,14 @@ class Bench(BenchPlotServer):
             relationship_cb = combinations
         for it in range(iterations):
             for input_group in relationship_cb(input_vars, group_size):
-                title = "Sweeping " + " vs ".join([i.name for i in input_vars])
+                title_gen = (
+                    title + "Sweeping " + " vs ".join([self.get_name(i) for i in input_group])
+                )
                 if iterations > 1:
-                    title += f" iteration:{it}"
+                    title_gen += f" iteration:{it}"
                 res = self.plot_sweep(
-                    title=title,
-                    input_vars=input_group,
+                    title=title_gen,
+                    input_vars=list(input_group),
                     result_vars=result_vars,
                     const_vars=const_vars,
                     run_cfg=run_cfg,
@@ -313,6 +316,10 @@ class Bench(BenchPlotServer):
             input_vars[i] = self.convert_vars_to_params(input_vars[i], "input")
         for i in range(len(result_vars)):
             result_vars[i] = self.convert_vars_to_params(result_vars[i], "result")
+
+        if isinstance(const_vars, dict):
+            const_vars = list(const_vars.items())
+
         for i in range(len(const_vars)):
             # consts come as tuple pairs
             cv_list = list(const_vars[i])
@@ -338,8 +345,8 @@ class Bench(BenchPlotServer):
             elif len(const_vars) > 0:
                 title = "Constant Value"
                 if len(const_vars) > 1:
-                    title += "es"
-                title += ": " + " ".join([f"{c[0].name}={c[1]}" for c in const_vars])
+                    title += "s"
+                title += ": " + ", ".join([f"{c[0].name}={c[1]}" for c in const_vars])
             else:
                 raise RuntimeError("you must pass a title, or define inputs or consts")
 
@@ -444,6 +451,11 @@ class Bench(BenchPlotServer):
         self.results.append(bench_res)
         return bench_res
 
+    def get_name(self, var):
+        if isinstance(var, param.Parameter):
+            return var.name
+        return var
+
     def convert_vars_to_params(self, variable: param.Parameter, var_type: str):
         """check that a variable is a subclass of param
 

{holobench-1.3.4 → holobench-1.3.5}/bencher/example/example_video.py

@@ -1,7 +1,7 @@
 import bencher as bch
 import numpy as np
 import matplotlib.pyplot as plt
-from matplotlib.animation import ArtistAnimation
+import panel as pn
 
 
 # code from https://ipython-books.github.io/124-simulating-a-partial-differential-equation-reaction-diffusion-systems-and-turing-patterns/
@@ -11,11 +11,12 @@ class TuringPattern(bch.ParametrizedSweep):
     tau = bch.FloatSweep(default=0.1, bounds=(0.01, 0.5))
     k = bch.FloatSweep(default=-0.005, bounds=(-0.01, 0.01))
 
-    size = bch.IntSweep(default=50, bounds=(30, 200), doc="size of the 2D grid")
+    size = bch.IntSweep(default=30, bounds=(30, 200), doc="size of the 2D grid")
     time = bch.FloatSweep(default=20.0, bounds=(1, 100), doc="total time of simulation")
     dt = bch.FloatSweep(default=0.001, doc="simulation time step")
 
     video = bch.ResultVideo()
+    score = bch.ResultVar()
 
     def laplacian(self, Z, dx):
         Ztop = Z[0:-2, 1:-1]
@@ -57,20 +58,18 @@ class TuringPattern(bch.ParametrizedSweep):
         fig, ax = plt.subplots(frameon=False, figsize=(2, 2))
         fig.set_tight_layout(True)
         ax.set_axis_off()
-
-        artists = []
-
+        vid_writer = bch.VideoWriter()
         for i in range(n):
             self.update(U, V, dx)
             if i % 500 == 0:
-                artists.append([ax.imshow(U)])
-
-        ani = ArtistAnimation(fig=fig, artists=artists, interval=60, blit=True)
-        path = bch.gen_video_path("turing", ".mp4")
-        # path = self.gen_path("turing", "vid", ".gif")
-        print(f"saving {len(artists)} frames")
-        ani.save(path)
-        self.video = path
+                ax.imshow(U)
+                fig.canvas.draw()
+                rgb = np.array(fig.canvas.renderer.buffer_rgba())
+                vid_writer.append(rgb)
+
+        self.video = vid_writer.write()
+
+        self.score = self.alpha + self.beta
         return super().__call__()
 
 
@@ -91,8 +90,35 @@ def example_video(
     return bench
 
 
+def example_video_tap(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:  # pragma: no cover
+    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"],
+        run_cfg=run_cfg,
+    )
+
+    bench.report.append(res.describe_sweep())
+    bench.report.append(
+        res.to_heatmap(tp.param.score, tap_var=tp.param.video, tap_container=pn.pane.Video)
+    )
+
+    return bench
+
+
 if __name__ == "__main__":
     run_cfg_ex = bch.BenchRunCfg()
     run_cfg_ex.level = 2
 
-    example_video(run_cfg_ex).report.show()
+    # example_video(run_cfg_ex).report.show()
+    example_video_tap(run_cfg_ex).report.show()

{holobench-1.3.4 → holobench-1.3.5}/bencher/results/bench_result.py

@@ -47,6 +47,8 @@ class BenchResult(PlotlyResult, HoloviewResult):
             for p in remove_plots:
                 plot_list.remove(p)
 
+        kwargs = self.set_plot_size(**kwargs)
+
         row = EmptyContainer(pn.Row())
         for plot_callback in plot_list:
             if self.plt_cnt_cfg.print_debug:
@@ -61,9 +63,6 @@ class BenchResult(PlotlyResult, HoloviewResult):
             )
         return row.pane
 
-    def to_auto_da(self):
-        pass
-
     def to_auto_plots(self, **kwargs) -> List[pn.panel]:
         """Given the dataset result of a benchmark run, automatically dedeuce how to plot the data based on the types of variables that were sampled
 
@@ -73,9 +72,7 @@ class BenchResult(PlotlyResult, HoloviewResult):
         Returns:
             pn.pane: A panel containing plot results
         """
-        if self.bench_cfg.plot_size is not None:
-            kwargs["width"] = self.bench_cfg.plot_size
-            kwargs["height"] = self.bench_cfg.plot_size
+
         plot_cols = pn.Column()
         plot_cols.append(self.to_sweep_summary(name="Plots View"))
         plot_cols.append(self.to_auto(**kwargs))

{holobench-1.3.4 → holobench-1.3.5}/bencher/results/bench_result_base.py

@@ -5,7 +5,7 @@ import xarray as xr
 from param import Parameter
 import holoviews as hv
 from functools import partial
-from bencher.utils import int_to_col, color_tuple_to_css
+from bencher.utils import int_to_col, color_tuple_to_css, callable_name
 
 from bencher.variables.parametrised_sweep import ParametrizedSweep
 from bencher.variables.results import OptDir
@@ -241,6 +241,8 @@ class BenchResultBase(OptunaResult):
         if hv_dataset is None:
             hv_dataset = self.to_hv_dataset()
         row = EmptyContainer(pn.Row())
+
+        # kwargs= self.set_plot_size(**kwargs)
         for rv in self.get_results_var_list(result_var):
             if result_types is None or isinstance(rv, result_types):
                 row.append(
@@ -279,7 +281,7 @@ class BenchResultBase(OptunaResult):
             repeats_range=repeats_range,
             input_range=input_range,
         )
-        matches_res = plot_filter.matches_result(self.plt_cnt_cfg, plot_callback.__name__)
+        matches_res = plot_filter.matches_result(self.plt_cnt_cfg, callable_name(plot_callback))
         if matches_res.overall:
             return self.map_plot_panes(
                 plot_callback=plot_callback,
@@ -300,6 +302,8 @@ class BenchResultBase(OptunaResult):
         **kwargs,
     ):
         dims = len(hv_dataset.dimensions())
+        if target_dimension is None:
+            target_dimension = dims
         return self._to_panes_da(
             hv_dataset.data,
             plot_callback=plot_callback,

{holobench-1.3.4 → holobench-1.3.5}/bencher/results/holoview_result.py

@@ -8,7 +8,7 @@ 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
+from bencher.utils import hmap_canonical_input, get_nearest_coords, get_nearest_coords1D
 from bencher.results.panel_result import PanelResult
 from bencher.results.bench_result_base import ReduceType
 
@@ -173,13 +173,27 @@ class HoloviewResult(PanelResult):
             return pt.opts(legend_position="right").overlay()
         return pt.opts(legend_position="right")
 
-    def to_heatmap(self, result_var: Parameter = None, **kwargs) -> Optional[pn.panel]:
+    def to_heatmap(
+        self,
+        result_var: Parameter = None,
+        tap_var=None,
+        tap_container=None,
+        target_dimension=2,
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        if tap_var is None:
+            heatmap_cb = self.to_heatmap_ds
+        else:
+            heatmap_cb = partial(
+                self.to_heatmap_container_tap_ds, result_var_plot=tap_var, container=tap_container
+            )
+
         return self.filter(
-            self.to_heatmap_ds,
+            heatmap_cb,
             float_range=VarRange(2, None),
             cat_range=VarRange(0, None),
             input_range=VarRange(1, None),
-            target_dimension=2,
+            target_dimension=target_dimension,
             result_var=result_var,
             result_types=(ResultVar),
             **kwargs,
@@ -189,9 +203,6 @@ class HoloviewResult(PanelResult):
         self, dataset: xr.Dataset, result_var: Parameter, **kwargs
     ) -> Optional[hv.HeatMap]:
         if len(dataset.dims) >= 2:
-            # dims = [d for d in da.sizes]
-            # x = dims[0]
-            # y = dims[1]
             x = self.plt_cnt_cfg.float_vars[0].name
             y = self.plt_cnt_cfg.float_vars[1].name
             C = result_var.name
@@ -200,6 +211,50 @@ class HoloviewResult(PanelResult):
             return dataset.hvplot.heatmap(x=x, y=y, C=C, cmap="plasma", **time_args, **kwargs)
         return None
 
+    def to_heatmap_container_tap_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        result_var_plot: Parameter,
+        container: pn.pane.panel = pn.pane.panel,
+        **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)
+        title = pn.pane.Markdown("Selected: None")
+
+        def tap_plot(x, y):  # pragma: no cover
+            x_nearest = get_nearest_coords1D(
+                x, dataset.coords[self.bench_cfg.input_vars[0].name].data
+            )
+            y_nearest = 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)
+        return pn.Row(htmap, bound_plot)
+
     def to_error_bar(self) -> hv.Bars:
         return self.to_hv_dataset(ReduceType.REDUCE).to(hv.ErrorBars)
 
@@ -312,7 +367,9 @@ class HoloviewResult(PanelResult):
     #     return matches.to_panel()
 
     def to_scatter_jitter(
-        self, result_var: Parameter = None, **kwargs  # pylint: disable=unused-argument
+        self,
+        result_var: Parameter = None,
+        **kwargs,  # pylint: disable=unused-argument
     ) -> List[hv.Scatter]:
         return self.overlay_plots(partial(self.to_scatter_jitter_single, **kwargs))
 

{holobench-1.3.4 → holobench-1.3.5}/bencher/results/optuna_result.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 from typing import List
+from copy import deepcopy
+
 import numpy as np
 import optuna
 import panel as pn
@@ -330,3 +332,23 @@ class OptunaResult:
     #         for it, rv in enumerate(bench_cfg.result_vars):
     #             bench_cfg.ds[rv.name].loc[t.params] = t.values[it]
     #     return bench_cfg
+
+    def deep(self) -> OptunaResult:  # pragma: no cover
+        """Return a deep copy of these results"""
+        return deepcopy(self)
+
+    def set_plot_size(self, **kwargs) -> dict:
+        if "width" not in kwargs:
+            if self.bench_cfg.plot_size is not None:
+                kwargs["width"] = self.bench_cfg.plot_size
+            # specific width overrrides general size
+            if self.bench_cfg.plot_width is not None:
+                kwargs["width"] = self.bench_cfg.plot_width
+
+        if "height" not in kwargs:
+            if self.bench_cfg.plot_size is not None:
+                kwargs["height"] = self.bench_cfg.plot_size
+            # specific height overrrides general size
+            if self.bench_cfg.plot_height is not None:
+                kwargs["height"] = self.bench_cfg.plot_height
+        return kwargs

{holobench-1.3.4 → holobench-1.3.5}/bencher/utils.py

@@ -7,6 +7,8 @@ import math
 from colorsys import hsv_to_rgb
 from pathlib import Path
 from uuid import uuid4
+from functools import partial
+from typing import Callable, Any
 
 
 def hmap_canonical_input(dic: dict) -> tuple:
@@ -55,6 +57,12 @@ def get_nearest_coords(dataset: xr.Dataset, collapse_list=False, **kwargs) -> di
     return cd2
 
 
+def get_nearest_coords1D(val: Any, coords) -> Any:
+    if isinstance(val, (int, float)):
+        return min(coords, key=lambda x_: abs(x_ - val))
+    return val
+
+
 def hash_sha1(var: any) -> str:
     """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
     return hashlib.sha1(str(var).encode("ASCII")).hexdigest()
@@ -129,3 +137,12 @@ def gen_video_path(video_name: str, extension: str = ".webm") -> str:
 
 def gen_image_path(image_name: str, filetype=".png") -> str:
     return gen_path(image_name, "img", filetype)
+
+
+def callable_name(any_callable: Callable[..., Any]) -> str:
+    if isinstance(any_callable, partial):
+        return any_callable.func.__name__
+    try:
+        return any_callable.__name__
+    except AttributeError:
+        return str(any_callable)

{holobench-1.3.4 → holobench-1.3.5}/bencher/variables/inputs.py

@@ -72,7 +72,7 @@ class EnumSweep(SweepSelector):
     __slots__ = shared_slots
 
     def __init__(
-        self, enum_type: Enum | List[Enum], units="", samples=None, samples_debug=2, **params
+        self, enum_type: Enum | List[Enum], units=" ", samples=None, samples_debug=2, **params
     ):
         # The enum can either be an Enum type or a list of enums
         list_of_enums = isinstance(enum_type, list)

holobench-1.3.5/bencher/video_writer.py

@@ -0,0 +1,30 @@
+from bencher import gen_video_path, gen_image_path
+from PIL import Image
+import numpy as np
+
+
+class VideoWriter:
+    def __init__(self, filename: str = "vid") -> None:
+        self.images = []
+        self.filename = gen_video_path(filename)
+
+    def append(self, img):
+        self.images.append(img)
+
+    def write(self, bitrate: int = 1500) -> str:
+        import moviepy.video.io.ImageSequenceClip
+
+        # todo
+        # if len(self.images[0.shape) == 2:
+        #     for i in range(len(self.images)):
+        #         self.images[i] = np.expand_dims(self.images[i], 2)
+
+        clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(self.images, fps=30)
+        clip.write_videofile(self.filename, bitrate=f"{bitrate}k", logger=None)
+        return self.filename
+
+
+def add_image(np_array: np.ndarray, name: str = "img"):
+    filename = gen_image_path(name)
+    Image.fromarray(np_array).save(filename)
+    return filename

{holobench-1.3.4 → holobench-1.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.3.4"
+version = "1.3.5"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"
@@ -26,7 +26,6 @@ dependencies = [
   "scikit-learn>=1.2,<=1.3.2",
   "str2bool>=1.1,<=1.1",
   "scoop>=0.7.0,<=0.7.2.0",
-  "ffmpeg-downloader>=0.3.0,<=0.3.0",
   "moviepy>=1.0.3,<=1.0.3",
 ]
 

holobench-1.3.4/bencher/video_writer.py

@@ -1,17 +0,0 @@
-from bencher import gen_video_path
-
-
-class VideoWriter:
-    def __init__(self, filename: str) -> None:
-        self.images = []
-        self.filename = gen_video_path(filename)
-
-    def append(self, img):
-        self.images.append(img)
-
-    def write(self, bitrate: int = 1500) -> str:
-        import moviepy.video.io.ImageSequenceClip
-
-        clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(self.images, fps=30)
-        clip.write_videofile(self.filename, bitrate=f"{bitrate}k")
-        return self.filename