holobench 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

bencher/__init__.py

@@ -5,6 +5,8 @@ from .bench_plot_server import BenchPlotServer
 from .variables.sweep_base import hash_sha1
 from .variables.inputs import IntSweep, FloatSweep, StringSweep, EnumSweep, BoolSweep, SweepBase
 from .variables.time import TimeSnapshot
+
+from .variables.inputs import box
 from .variables.results import (
     ResultVar,
     ResultVec,
@@ -14,9 +16,11 @@ from .variables.results import (
     ResultString,
     ResultContainer,
     ResultReference,
+    ResultVolume,
     OptDir,
     curve,
 )
+
 from .plotting.plot_filter import VarRange, PlotFilter
 from .utils import (
     hmap_canonical_input,
@@ -25,6 +29,7 @@ from .utils import (
     gen_path,
     gen_image_path,
     gen_video_path,
+    lerp,
 )
 from .variables.parametrised_sweep import ParametrizedSweep
 from .caching import CachedParams
@@ -33,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

bencher/bench_cfg.py

@@ -164,6 +164,15 @@ class BenchRunCfg(BenchPlotSrvCfg):
         doc="The function can be run serially or in parallel with different futures executors",
     )
 
+    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
         """create a BenchRunCfg by parsing command line arguments
@@ -424,12 +433,15 @@ class BenchCfg(BenchRunCfg):
             col.append(pn.pane.Markdown("## Results:"))
         return col
 
-    def optuna_targets(self) -> List[str]:
-        target_names = []
+    def optuna_targets(self, as_var=False) -> List[str]:
+        targets = []
         for rv in self.result_vars:
-            if rv.direction != OptDir.none:
-                target_names.append(rv.name)
-        return target_names
+            if hasattr(rv, "direction") and rv.direction != OptDir.none:
+                if as_var:
+                    targets.append(rv)
+                else:
+                    targets.append(rv.name)
+        return targets
 
 
 class DimsCfg:

bencher/bencher.py

@@ -1,6 +1,7 @@
 import logging
 from datetime import datetime
-from itertools import product
+from itertools import product, combinations
+
 from typing import Callable, List
 from copy import deepcopy
 import numpy as np
@@ -186,9 +187,72 @@ class Bench(BenchPlotServer):
             logging.info(f"setting worker {worker}")
         self.worker_input_cfg = worker_input_cfg
 
+    def sweep(
+        self,
+        input_vars: List[ParametrizedSweep] = None,
+        result_vars: List[ParametrizedSweep] = None,
+        const_vars: List[ParametrizedSweep] = None,
+        time_src: datetime = None,
+        description: str = None,
+        post_description: str = None,
+        pass_repeat: bool = False,
+        tag: str = "",
+        run_cfg: BenchRunCfg = None,
+        plot: bool = False,
+    ) -> BenchResult:
+        title = "Sweeping " + " vs ".join([self.get_name(i) for i in input_vars])
+        return self.plot_sweep(
+            title,
+            input_vars=input_vars,
+            result_vars=result_vars,
+            const_vars=const_vars,
+            time_src=time_src,
+            description=description,
+            post_description=post_description,
+            pass_repeat=pass_repeat,
+            tag=tag,
+            run_cfg=run_cfg,
+            plot=plot,
+        )
+
+    def sweep_sequential(
+        self,
+        title="",
+        input_vars: List[ParametrizedSweep] = None,
+        result_vars: List[ParametrizedSweep] = None,
+        const_vars: List[ParametrizedSweep] = None,
+        optimise_var: ParametrizedSweep = None,
+        run_cfg: BenchRunCfg = None,
+        group_size: int = 1,
+        iterations: int = 1,
+        relationship_cb=None,
+    ) -> List[BenchResult]:
+        results = []
+        if relationship_cb is None:
+            relationship_cb = combinations
+        for it in range(iterations):
+            for input_group in relationship_cb(input_vars, group_size):
+                title_gen = (
+                    title + "Sweeping " + " vs ".join([self.get_name(i) for i in input_group])
+                )
+                if iterations > 1:
+                    title_gen += f" iteration:{it}"
+                res = self.plot_sweep(
+                    title=title_gen,
+                    input_vars=list(input_group),
+                    result_vars=result_vars,
+                    const_vars=const_vars,
+                    run_cfg=run_cfg,
+                    plot=True,
+                )
+                if optimise_var is not None:
+                    const_vars = res.get_optimal_inputs(optimise_var, True)
+                results.append(res)
+        return results
+
     def plot_sweep(
         self,
-        title: str,
+        title: str = None,
         input_vars: List[ParametrizedSweep] = None,
         result_vars: List[ParametrizedSweep] = None,
         const_vars: List[ParametrizedSweep] = None,
@@ -248,6 +312,20 @@ class Bench(BenchPlotServer):
             else:
                 const_vars = deepcopy(const_vars)
 
+        for i in range(len(input_vars)):
+            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])
+            cv_list[0] = self.convert_vars_to_params(cv_list[0], "const")
+            const_vars[i] = cv_list
+
         if run_cfg is None:
             if self.run_cfg is None:
                 run_cfg = BenchRunCfg()
@@ -261,11 +339,24 @@ class Bench(BenchPlotServer):
 
         self.last_run_cfg = run_cfg
 
+        if title is None:
+            if len(input_vars) > 0:
+                title = "Sweeping " + " vs ".join([i.name for i in input_vars])
+            elif len(const_vars) > 0:
+                title = "Constant Value"
+                if len(const_vars) > 1:
+                    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")
+
         if run_cfg.level > 0:
             inputs = []
-            for i in input_vars:
-                inputs.append(i.with_level(run_cfg.level))
-            input_vars = inputs
+            print(input_vars)
+            if len(input_vars) > 0:
+                for i in input_vars:
+                    inputs.append(i.with_level(run_cfg.level))
+                input_vars = inputs
 
         # if any of the inputs have been include as constants, remove those variables from the list of constants
         with suppress(ValueError, AttributeError):
@@ -276,14 +367,6 @@ class Bench(BenchPlotServer):
                         const_vars.remove(c)
                         logging.info(f"removing {i.name} from constants")
 
-        for i in input_vars:
-            self.check_var_is_a_param(i, "input")
-        for i in result_vars:
-            self.check_var_is_a_param(i, "result")
-        for i in const_vars:
-            # consts come as tuple pairs
-            self.check_var_is_a_param(i[0], "const")
-
         result_hmaps = []
         result_vars_only = []
         for i in result_vars:
@@ -368,7 +451,12 @@ class Bench(BenchPlotServer):
         self.results.append(bench_res)
         return bench_res
 
-    def check_var_is_a_param(self, variable: param.Parameter, var_type: str):
+    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
 
         Args:
@@ -378,10 +466,13 @@ class Bench(BenchPlotServer):
         Raises:
             TypeError: the input variable type is not a param.
         """
+        if isinstance(variable, str):
+            variable = self.worker_class_instance.param.objects(instance=False)[variable]
         if not isinstance(variable, param.Parameter):
             raise TypeError(
                 f"You need to use {var_type}_vars =[{self.worker_input_cfg}.param.your_variable], instead of {var_type}_vars =[{self.worker_input_cfg}.your_variable]"
             )
+        return variable
 
     def cache_results(self, bench_res: BenchResult, bench_cfg_hash: int) -> None:
         with Cache("cachedir/benchmark_inputs", size_limit=self.cache_size) as c:

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()

bencher/example/meta/example_meta.py

@@ -100,20 +100,21 @@ class BenchMeta(bch.ParametrizedSweep):
         run_cfg.level = self.level
         run_cfg.repeats = self.sample_with_repeats
         run_cfg.over_time = self.sample_over_time
+        run_cfg.plot_size = 500
 
         bench = bch.Bench("benchable", BenchableObject(), run_cfg=run_cfg)
 
         inputs_vars_float = [
-            BenchableObject.param.float1,
-            BenchableObject.param.float2,
-            BenchableObject.param.float3,
-            BenchableObject.param.sigma,
+            "float1",
+            "float2",
+            "float3",
+            "sigma",
         ]
 
         inputs_vars_cat = [
-            BenchableObject.param.noisy,
-            BenchableObject.param.noise_distribution,
-            BenchableObject.param.negate_output,
+            "noisy",
+            "noise_distribution",
+            "negate_output",
         ]
 
         input_vars = (
@@ -131,7 +132,7 @@ class BenchMeta(bch.ParametrizedSweep):
         )
 
         self.plots = bch.ResultReference()
-        self.plots.obj = res.to_auto(width=500, height=300)
+        self.plots.obj = res.to_auto()
 
         # self.plots.obj = res.to_heatmap_multi()
 

bencher/example/optuna/example_optuna.py

@@ -25,7 +25,7 @@ class ToyOptimisationProblem(bch.ParametrizedSweep):
     bump_scale = bch.FloatSweep(default=1.5, bounds=[1, 10])
 
     # RESULTS
-    output = bch.ResultVar(bch.OptDir.minimize)
+    output = bch.ResultVar("ul", bch.OptDir.minimize)
 
     def rastrigin(self, **kwargs) -> dict:
         """A modified version of the rastrigin function which is very difficult to find the global optimum
@@ -58,7 +58,7 @@ def optuna_rastrigin(
     #     n_trials=30
     # )
 
-    run_cfg.use_optuna = True
+    # run_cfg.use_optuna = True
     res = bench.plot_sweep(
         "Rastrigin",
         input_vars=[explorer.param.input1, explorer.param.input2],
@@ -67,7 +67,7 @@ def optuna_rastrigin(
     )
 
     bench.report.append(res.to_optuna_plots())
-    bench.report.append(res.to_optuna_from_sweep(bench.worker))
+    bench.report.append(res.to_optuna_from_sweep(bench))
     bench.report.append_markdown(
         f"The optimal value should be input1:{-optimal_value},input2:{-optimal_value} with a value of 0"
     )

bencher/optuna_conversions.py

@@ -14,7 +14,6 @@ from bencher.bench_cfg import BenchCfg
 
 from bencher.variables.inputs import IntSweep, FloatSweep, StringSweep, EnumSweep, BoolSweep
 from bencher.variables.time import TimeSnapshot, TimeEvent
-from bencher.variables.results import OptDir
 
 from bencher.variables.parametrised_sweep import ParametrizedSweep
 
@@ -33,9 +32,8 @@ def optuna_grid_search(bench_cfg: BenchCfg) -> optuna.Study:
     for iv in bench_cfg.all_vars:
         search_space[iv.name] = iv.values(bench_cfg.debug)
     directions = []
-    for rv in bench_cfg.result_vars:
-        if rv.direction != OptDir.none:
-            directions.append(rv.direction)
+    for rv in bench_cfg.optuna_targets(True):
+        directions.append(rv.direction)
 
     study = optuna.create_study(
         sampler=optuna.samplers.GridSampler(search_space),
@@ -76,9 +74,8 @@ def summarise_trial(trial: optuna.trial, bench_cfg: BenchCfg) -> List[str]:
     for k, v in trial.params.items():
         output.append(f"{sep}{sep}{k}:{v}")
     output.append(f"{sep}Results:")
-    for it, rv in enumerate(bench_cfg.result_vars):
-        if rv.direction != OptDir.none:
-            output.append(f"{sep}{sep}{rv.name}:{trial.values[it]}")
+    for it, rv in enumerate(bench_cfg.optuna_targets()):
+        output.append(f"{sep}{sep}{rv}:{trial.values[it]}")
     return output
 
 

bencher/results/bench_result.py

@@ -7,10 +7,6 @@ from bencher.results.plotly_result import PlotlyResult
 from bencher.results.holoview_result import HoloviewResult
 from bencher.results.bench_result_base import EmptyContainer
 
-# from bencher.results.heatmap_result import HeatMapResult
-
-# from bencher.results.seaborn_result import SeabornResult
-
 
 class BenchResult(PlotlyResult, HoloviewResult):
 
@@ -40,12 +36,18 @@ class BenchResult(PlotlyResult, HoloviewResult):
     def to_auto(
         self,
         plot_list: List[callable] = None,
+        remove_plots: List[callable] = None,
         **kwargs,
     ) -> List[pn.panel]:
         self.plt_cnt_cfg.print_debug = False
 
         if plot_list is None:
             plot_list = BenchResult.default_plot_callbacks()
+        if remove_plots is not None:
+            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:
@@ -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,6 +72,7 @@ class BenchResult(PlotlyResult, HoloviewResult):
         Returns:
             pn.pane: A panel containing plot results
         """
+
         plot_cols = pn.Column()
         plot_cols.append(self.to_sweep_summary(name="Plots View"))
         plot_cols.append(self.to_auto(**kwargs))

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
@@ -141,16 +141,20 @@ class BenchResultBase(OptunaResult):
         return indicies
 
     def get_optimal_inputs(
-        self, result_var: ParametrizedSweep, keep_existing_consts: bool = True
-    ) -> Tuple[ParametrizedSweep, Any]:
+        self,
+        result_var: ParametrizedSweep,
+        keep_existing_consts: bool = True,
+        as_dict: bool = False,
+    ) -> Tuple[ParametrizedSweep, Any] | dict[ParametrizedSweep, Any]:
         """Get a list of tuples of optimal variable names and value pairs, that can be fed in as constant values to subsequent parameter sweeps
 
         Args:
             result_var (bch.ParametrizedSweep): Optimal values of this result variable
             keep_existing_consts (bool): Include any const values that were defined as part of the parameter sweep
+            as_dict (bool): return value as a dictionary
 
         Returns:
-            Tuple[bch.ParametrizedSweep, Any]: Tuples of variable name and optimal values
+            Tuple[bch.ParametrizedSweep, Any]|[ParametrizedSweep, Any]: Tuples of variable name and optimal values
         """
         da = self.get_optimal_value_indices(result_var)
         if keep_existing_consts:
@@ -169,6 +173,8 @@ class BenchResultBase(OptunaResult):
                 output.append((iv, max(da.coords[iv.name].values[()])))
 
             logging.info(f"Maximum value of {iv.name}: {output[-1][1]}")
+        if as_dict:
+            return dict(output)
         return output
 
     def describe_sweep(self):
@@ -235,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(
@@ -273,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,
@@ -294,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,

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))
 

bencher/results/optuna_result.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
 from typing import List
+from copy import deepcopy
+
 import numpy as np
 import optuna
 import panel as pn
@@ -15,7 +18,6 @@ from optuna.visualization import (
 )
 from bencher.utils import hmap_canonical_input
 from bencher.variables.time import TimeSnapshot, TimeEvent
-from bencher.variables.results import OptDir
 from bencher.bench_cfg import BenchCfg
 from bencher.plotting.plt_cnt_cfg import PltCntCfg
 
@@ -122,25 +124,34 @@ class OptunaResult:
 
         return self.collect_optuna_plots()
 
-    def to_optuna_from_sweep(self, worker, n_trials=30):
-        optu = self.to_optuna_from_results(worker, n_trials=n_trials)
+    def to_optuna_from_sweep(self, bench, n_trials=30):
+        optu = self.to_optuna_from_results(
+            bench.worker, n_trials=n_trials, extra_results=bench.results
+        )
         return summarise_optuna_study(optu)
 
-    def to_optuna_from_results(self, worker, n_trials=100, sampler=optuna.samplers.TPESampler()):
+    def to_optuna_from_results(
+        self,
+        worker,
+        n_trials=100,
+        extra_results: List[OptunaResult] = None,
+        sampler=optuna.samplers.TPESampler(),
+    ):
         directions = []
-        for rv in self.bench_cfg.result_vars:
-            if rv.direction != OptDir.none:
-                directions.append(rv.direction)
+        for rv in self.bench_cfg.optuna_targets(True):
+            directions.append(rv.direction)
 
         study = optuna.create_study(
             sampler=sampler, directions=directions, study_name=self.bench_cfg.title
         )
 
         # add already calculated results
-        if len(self.ds.sizes) > 0:
-            study.add_trials(self.bench_results_to_optuna_trials(True))
+        results_list = extra_results if extra_results is not None else [self]
+        for res in results_list:
+            if len(res.ds.sizes) > 0:
+                study.add_trials(res.bench_results_to_optuna_trials(True))
 
-        def wrapped(trial):
+        def wrapped(trial) -> tuple:
             kwargs = {}
             for iv in self.bench_cfg.input_vars:
                 kwargs[iv.name] = sweep_var_to_suggest(iv, trial)
@@ -197,9 +208,8 @@ class OptunaResult:
                 else:
                     params[i.name] = row[1][i.name]
 
-            for r in self.bench_cfg.result_vars:
-                if r.direction != OptDir.none:
-                    values.append(row[1][r.name])
+            for r in self.bench_cfg.optuna_targets():
+                values.append(row[1][r])
 
             trials.append(
                 optuna.trial.create_trial(
@@ -322,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

bencher/results/panel_result.py

@@ -71,14 +71,18 @@ class PanelResult(BenchResultBase):
 
     def zero_dim_da_to_val(self, da_ds: xr.DataArray | xr.Dataset) -> Any:
         # todo this is really horrible, need to improve
+        dim = None
         if isinstance(da_ds, xr.Dataset):
             dim = list(da_ds.keys())[0]
             da = da_ds[dim]
         else:
             da = da_ds
+
         for k in da.coords.keys():
             dim = k
             break
+        if dim is None:
+            return da_ds.values.squeeze().item()
         return da.expand_dims(dim).values[0]
 
     def ds_to_container(
@@ -86,16 +90,21 @@ class PanelResult(BenchResultBase):
     ) -> Any:
         val = self.zero_dim_da_to_val(dataset[result_var.name])
         if isinstance(result_var, ResultReference):
-            val = self.object_index[val].obj
+            ref = self.object_index[val]
+            val = ref.obj
+            if ref.container is not None:
+                return ref.container(val, **kwargs)
         if container is not None:
             return container(val, styles={"background": "white"}, **kwargs)
         return val
 
     def to_panes(
-        self, result_var: Parameter = None, target_dimension: int = 0, **kwargs
+        self, result_var: Parameter = None, target_dimension: int = 0, container=None, **kwargs
     ) -> Optional[pn.pane.panel]:
+        if container is None:
+            container = pn.pane.panel
         return self.map_plot_panes(
-            partial(self.ds_to_container, container=pn.pane.panel),
+            partial(self.ds_to_container, container=container),
             hv_dataset=self.to_hv_dataset(ReduceType.SQUEEZE),
             target_dimension=target_dimension,
             result_var=result_var,

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()
@@ -106,6 +114,13 @@ def int_to_col(int_val, sat=0.5, val=0.95, alpha=-1) -> tuple[float, float, floa
     return rgb
 
 
+def lerp(value, input_low: float, input_high: float, output_low: float, output_high: float):
+    input_low = float(input_low)
+    return output_low + ((float(value) - input_low) / (float(input_high) - input_low)) * (
+        float(output_high) - output_low
+    )
+
+
 def color_tuple_to_css(color: tuple[float, float, float]) -> str:
     return f"rgb{(color[0] * 255, color[1] * 255, color[2] * 255)}"
 
@@ -122,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)

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)

bencher/variables/parametrised_sweep.py

@@ -132,7 +132,7 @@ class ParametrizedSweep(Parameterized):
         assert isinstance(override_defaults, list)
         for p in override_defaults:
             inp = filter(partial(ParametrizedSweep.filter_fn, p_name=p[0].name), inp)
-        return override_defaults + [(i, i.default) for i in inp]
+        return override_defaults + [[i, i.default] for i in inp]
 
     @classmethod
     def get_results_only(cls) -> List[Parameter]:

bencher/variables/results.py

@@ -1,6 +1,7 @@
 from enum import auto
-from typing import List
+from typing import List, Callable, Any
 
+import panel as pn
 import param
 from param import Number
 from strenum import StrEnum
@@ -23,6 +24,7 @@ class ResultVar(Number):
 
     def __init__(self, units="ul", direction: OptDir = OptDir.minimize, **params):
         Number.__init__(self, **params)
+        assert isinstance(units, str)
         self.units = units
         self.default = 0  # json is terrible and does not support nan values
         self.direction = direction
@@ -136,6 +138,29 @@ class ResultContainer(param.Parameter):
 
 
 class ResultReference(param.Parameter):
+    """Use this class to save arbitrary objects that are not picklable or native to panel.  You can pass a container callback that takes the object and returns a panel pane to be displayed"""
+
+    __slots__ = ["units", "obj", "container"]
+
+    def __init__(
+        self,
+        obj: Any = None,
+        container: Callable[Any, pn.pane.panel] = None,
+        default: Any = None,
+        units: str = "container",
+        **params,
+    ):
+        super().__init__(default=default, **params)
+        self.units = units
+        self.obj = obj
+        self.container = container
+
+    def hash_persistent(self) -> str:
+        """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
+        return hash_sha1(self)
+
+
+class ResultVolume(param.Parameter):
     __slots__ = ["units", "obj"]
 
     def __init__(self, obj=None, default=None, units="container", **params):

bencher/video_writer.py

@@ -1,8 +1,10 @@
-from bencher import gen_video_path
+from bencher import gen_video_path, gen_image_path
+from PIL import Image
+import numpy as np
 
 
 class VideoWriter:
-    def __init__(self, filename: str) -> None:
+    def __init__(self, filename: str = "vid") -> None:
         self.images = []
         self.filename = gen_video_path(filename)
 
@@ -12,6 +14,17 @@ class VideoWriter:
     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")
+        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.3.dist-info → holobench-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.3.3
+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.3.dist-info → holobench-1.3.5.dist-info}/RECORD

@@ -1,14 +1,14 @@
-bencher/__init__.py,sha256=l3s3a3hf7E6RciydXdHNuzzXPUUrqCs-imMnBrWqerU,1161
-bencher/bench_cfg.py,sha256=EMoANsz0bj4lioOCO_hlJNHH9-ciK042YAXvj2pk_dE,18244
+bencher/__init__.py,sha256=lw9moEkY3rb3kQVS3_SM9L0LsOAXRSM1JUJ_mm16tMQ,1236
+bencher/bench_cfg.py,sha256=g7gMQhzMEHBZzVfpBXhn5f0juCGLqK-nEBoSFKXAS2I,18743
 bencher/bench_plot_server.py,sha256=HnW6XpmARweMCd-koqzu1lxuj0gA4_fP-72D3Yfy-0M,4087
 bencher/bench_report.py,sha256=b9jLksrXzBhSmvI7KetO1i0hsHknE7qk4b4k0MGGtNw,10484
 bencher/bench_runner.py,sha256=TLJGn-NO4BBBZMG8W5E6u7IPyij67Yk3S4B29ONClnk,6049
-bencher/bencher.py,sha256=ACP0OjkYi4vGO3lfBTzV5RAMqci_-ErNuEyIlnO_48o,28609
+bencher/bencher.py,sha256=jYOkqs5F6vIL9_KLygVgi0O_vj-xspBVlipduNMtt1Y,32012
 bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
 bencher/job.py,sha256=Q2zpia95Ibukk8EeFq5IBbpo2PMRe7o5keelJCJlGnI,5927
-bencher/optuna_conversions.py,sha256=XwRUQjFZs_zCZo0iT4cudstorSSXThLKOv4o75IxBrw,5427
-bencher/utils.py,sha256=ddhTAXp9ciBhZBK5gLAJgpE6rUrMpnt4g7Wug1sSc_Q,4291
-bencher/video_writer.py,sha256=PlYLm6IBYG5MrK1J6U0ti2rvBzeMW2iXE4Pge7RsVII,523
+bencher/optuna_conversions.py,sha256=9nLVPAydSQ8PyJlyhzs__Em6_Rx8l8Ld94UNJZxy6cY,5303
+bencher/utils.py,sha256=oKUtD3Uw76n82ZeyWRBleneYKrZuuNE8pb7Gswlhwjc,5034
+bencher/video_writer.py,sha256=L_RVrHU4C6hj9BhbEPelgPgtGZeHH4PYYW4CHjGXgJ0,937
 bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
 bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bencher/example/benchmark_data.py,sha256=D9yUg_KKtqqEkAiLceodDwsv6sh7xEFWZNp6P6Y3pj4,6989
@@ -34,7 +34,7 @@ bencher/example/example_simple_cat.py,sha256=YFccE84g37U2M3ByWYIcGNLXWdW_ktJbbZv
 bencher/example/example_simple_float.py,sha256=X4vsH0F4fZAoO0EKB1xIzFMY0f0Wyk8LV2plPlSEsbI,1323
 bencher/example/example_strings.py,sha256=BdsEZgLT9mOxLkBKNHz2XpPwwe4SzNTdjnY1WVlOmNM,1570
 bencher/example/example_time_event.py,sha256=y1vpK7UDrObEu0Z1x3e4OQzvGCQ7pF5GZvpKLegMbYk,2158
-bencher/example/example_video.py,sha256=uI8tjF8BTTD9NsrBhK5rluBujLAaOaRAB5uXAvM1fZU,3387
+bencher/example/example_video.py,sha256=w2NtsDL-afZWGlScrrHxr9vdCrxTvyzqOUhIeDOHjvU,4079
 bencher/example/example_workflow.py,sha256=00QnUuViMfX_PqzqkXmg1wPX6yAq7IS7mCL_RFKwrMM,6806
 bencher/example/experimental/example_bokeh_plotly.py,sha256=3jUKh8eKIAlpklKnp8UopIHhUDw1A0_5CwjeyTzbi7o,846
 bencher/example/experimental/example_hover_ex.py,sha256=qszw4FkIfqQkVviPSpmUoFOoi6PGotGbsc7Ojyx8EtU,1052
@@ -45,11 +45,11 @@ bencher/example/experimental/example_streams.py,sha256=rrTmcmxDlirGoyTbJ4LT4fBIA
 bencher/example/experimental/example_template.py,sha256=XdIVS9RtLdE5GNnerWiZMXvP7n17lzuc_YTLqJTwb6Q,1172
 bencher/example/experimental/example_updates.py,sha256=rF4UgWY-CW6ohNtOpQklTuwbwVRvEM5j6edZOiMkspQ,1835
 bencher/example/experimental/example_vector.py,sha256=3o_1dA4dc2HL6uIEvDAcvLPVJB8jgkq1QZ3BQIL-LEo,3118
-bencher/example/meta/example_meta.py,sha256=OpresXooPvkSVI3mfExqiATyGvd3o5x-dmIjhTH5Zf4,5734
+bencher/example/meta/example_meta.py,sha256=P71Q-3G8B44DYaZQe5eFmFxUsjbViSat3DcUvgdSSuw,5605
 bencher/example/meta/example_meta_cat.py,sha256=YKVUiZ7M1tFFYgUTVQZeOe-1bnmxOjLdWy3nmCoyEe0,693
 bencher/example/meta/example_meta_float.py,sha256=f3OcORsRUt9Bnd1M1hOjmgxulxcalwdQHSQ0Psx1rY8,650
 bencher/example/meta/example_meta_levels.py,sha256=O77D4gAGYf7uZo7-Kj2ZwyNmpnc4paoQXE_DQtKKWKo,1488
-bencher/example/optuna/example_optuna.py,sha256=EYxRMHCRvy0vB-ObQlyi6ZJHoZ8QvnQQrDJWyuS_lvc,2369
+bencher/example/optuna/example_optuna.py,sha256=-RIuDrdPjfXz1c1hOAmWeJNdmGICiWnyJfAavRsiMuk,2370
 bencher/example/shelved/example_float2D_scatter.py,sha256=z8ranMq8IcJ1yoVSFDncp3gw-yWG7X9lXLimXKpy5Ks,3372
 bencher/example/shelved/example_float3D_cone.py,sha256=T3-IapccLYX3BM9sGDyOTLhZVEmzkeMsXzQMT5msnNQ,2966
 bencher/example/shelved/example_kwargs.py,sha256=Bgxkd7qeHdySBE24amdP-VNFRRgK_enyzprlxBwY9Ko,2461
@@ -57,18 +57,18 @@ bencher/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 bencher/plotting/plot_filter.py,sha256=Zff02hEcRffiqDEoXUHVZQJK5kW4HbMxe2GYCrxI8jg,4688
 bencher/plotting/plt_cnt_cfg.py,sha256=BkiAsgHm35Mqb5OsjULGVK0Q6pGZ0WSsJxxwSOrbaQs,3124
 bencher/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bencher/results/bench_result.py,sha256=O0RxxUoudT43zukIKEmwaj8Q156UrEfwyj8NGFFwI0c,2797
-bencher/results/bench_result_base.py,sha256=LILzZ5R5p0xEcGXsWN3ohRKhpC45OHLD9-K635J4kRQ,15412
+bencher/results/bench_result.py,sha256=NiJ8UIYrw5QBksltIHAOh-4CaIMYI8YA-cEcWgfwZ70,2838
+bencher/results/bench_result_base.py,sha256=-c46om4Gulzxn3PPvQAsQF9qzT7rQLtX6hsO65f9N2A,15767
 bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
-bencher/results/holoview_result.py,sha256=dsXZiTlQ6U9U6pSBiLAMUdYXzsW-VLEpZ2bLDrdfvZU,20158
-bencher/results/optuna_result.py,sha256=704l1eFJUQGTmnTaj2pIJ9ocRehLgu4PwMYmJU2rY9w,12399
-bencher/results/panel_result.py,sha256=5oMY0KDRoGK_3LoUJB-pRy9b0QMowVvu7hR6f2-0P8c,3647
+bencher/results/holoview_result.py,sha256=nfXYTaGQkXwLqJ_gEB3TYJxHfKAQCN1E60D9Tfbkxos,22254
+bencher/results/optuna_result.py,sha256=jtsWJGdCS0L98EzxTxXU_AyarCL5CkXRLOVuSvs048M,13437
+bencher/results/panel_result.py,sha256=SpVHHdTdlNHh1pGcK3DYLw6BClDRJ_37TNTkicnErTU,3936
 bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
-bencher/variables/inputs.py,sha256=HYWEK75qfzk86dWvZbb6TeZr6yEvXgXILdddAqGuvEs,6392
-bencher/variables/parametrised_sweep.py,sha256=96fLNjq1x7tGSwGCVshR3_LK9PRHhLipj8pbJ5umbnA,7029
-bencher/variables/results.py,sha256=yXdLjfGPSerWhipw_GDZJpBB8KQgCqcdreb8WjIeah8,5119
+bencher/variables/inputs.py,sha256=XtUko3qNYB1xk7fwM9teVGRU0MNCW673n2teGtoyFGU,6393
+bencher/variables/parametrised_sweep.py,sha256=3ioxqm8xg9WYIH-eRFRhDSn_YphGD-269gZ_FaxuEv8,7029
+bencher/variables/results.py,sha256=omENIr_Y3RxRG8sr4RQKD1Y_vTyMJUoA7P-fV1uSX5Y,6015
 bencher/variables/sweep_base.py,sha256=I1LEeG1y5Jsw0a-Ik03t0tSzcfENht2GmBECJ3KNs28,6559
 bencher/variables/time.py,sha256=Le7s8_oUYJD4wCqwQw-a_FRDpYQOi8CqMbGYsBF07jg,2860
-holobench-1.3.3.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-holobench-1.3.3.dist-info/METADATA,sha256=0J2iK-aBJK3NvwuyrHVyQaElPTfzZbwDCnsRZzJOGKE,4994
-holobench-1.3.3.dist-info/RECORD,,
+holobench-1.3.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+holobench-1.3.5.dist-info/METADATA,sha256=yzGpIvCdTY9riHJHhC9OGAKymmg0LbbQ7AwheTwBhXo,4946
+holobench-1.3.5.dist-info/RECORD,,