holobench 1.41.0__py3-none-any.whl → 1.43.0__py3-none-any.whl

bencher/results/holoview_results/surface_result.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+import logging
+from typing import Optional
+import panel as pn
+import holoviews as hv
+from param import Parameter
+import hvplot.xarray  # noqa pylint: disable=duplicate-code,unused-import
+import xarray as xr
+
+from bencher.results.bench_result_base import ReduceType
+from bencher.plotting.plot_filter import PlotFilter, VarRange
+from bencher.variables.results import ResultVar
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+
+class SurfaceResult(HoloviewResult):
+    """A class for creating 3D surface plots from benchmark results.
+
+    This class provides methods to visualize benchmark data as 3D surface plots,
+    which are useful for showing relationships between two input variables and
+    a result variable. Surface plots can also display standard deviation bounds
+    when benchmark runs include multiple repetitions.
+    """
+
+    def to_plot(
+        self, result_var: Parameter = None, override: bool = True, **kwargs
+    ) -> Optional[pn.pane.Pane]:
+        """Generates a 3D surface plot from benchmark data.
+
+        This is a convenience method that calls to_surface() with the same parameters.
+
+        Args:
+            result_var (Parameter, optional): The result variable to plot. If None, uses the default.
+            override (bool, optional): Whether to override filter restrictions. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the plot rendering.
+
+        Returns:
+            Optional[pn.pane.Pane]: A panel containing the surface plot if data is appropriate,
+                                   otherwise returns filter match results.
+        """
+        return self.to_surface(result_var=result_var, override=override, **kwargs)
+
+    def to_surface(
+        self, result_var: Parameter = None, override: bool = True, **kwargs
+    ) -> Optional[pn.pane.Pane]:
+        """Generates a 3D surface plot from benchmark data.
+
+        This method applies filters to ensure the data is appropriate for a surface plot
+        and then passes the filtered data to to_surface_ds for rendering.
+
+        Args:
+            result_var (Parameter, optional): The result variable to plot. If None, uses the default.
+            override (bool, optional): Whether to override filter restrictions. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the plot rendering.
+
+        Returns:
+            Optional[pn.pane.Pane]: A panel containing the surface plot if data is appropriate,
+                                   otherwise returns filter match results.
+        """
+        return self.filter(
+            self.to_surface_ds,
+            float_range=VarRange(2, None),
+            cat_range=VarRange(0, None),
+            input_range=VarRange(1, None),
+            reduce=ReduceType.REDUCE,
+            target_dimension=2,
+            result_var=result_var,
+            result_types=(ResultVar),
+            override=override,
+            **kwargs,
+        )
+
+    def to_surface_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        override: bool = True,
+        alpha: float = 0.3,
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        """Creates a 3D surface plot from the provided dataset.
+
+        Given a filtered dataset, this method generates a 3D surface visualization showing
+        the relationship between two input variables and the result variable. When multiple
+        benchmark repetitions are available, standard deviation bounds can also be displayed.
+
+        Args:
+            dataset (xr.Dataset): The dataset containing benchmark results.
+            result_var (Parameter): The result variable to plot.
+            override (bool, optional): Whether to override filter restrictions. Defaults to True.
+            alpha (float, optional): The transparency level for standard deviation surfaces. Defaults to 0.3.
+            **kwargs: Additional keyword arguments passed to the surface plot options.
+
+        Returns:
+            Optional[pn.panel]: A panel containing the surface plot if data matches criteria,
+                               otherwise returns filter match results.
+        """
+        matches_res = PlotFilter(
+            float_range=VarRange(2, 2),
+            cat_range=VarRange(0, None),
+            vector_len=VarRange(1, 1),
+            result_vars=VarRange(1, 1),
+        ).matches_result(self.plt_cnt_cfg, "to_surface_hv", override)
+        if matches_res.overall:
+            # xr_cfg = plot_float_cnt_2(self.plt_cnt_cfg, result_var)
+
+            # TODO a warning suggests setting this parameter, but it does not seem to help as expected, leaving here to fix in the future
+            # hv.config.image_rtol = 1.0
+
+            mean = dataset[result_var.name]
+
+            hvds = hv.Dataset(dataset[result_var.name])
+
+            x = self.plt_cnt_cfg.float_vars[0]
+            y = self.plt_cnt_cfg.float_vars[1]
+
+            try:
+                surface = hvds.to(hv.Surface, vdims=[result_var.name])
+                surface = surface.opts(colorbar=True)
+            except Exception as e:  # pylint: disable=broad-except
+                logging.warning(e)
+
+            if self.bench_cfg.repeats > 1:
+                std_dev = dataset[f"{result_var.name}_std"]
+
+                upper = mean + std_dev
+                upper.name = result_var.name
+
+                lower = mean - std_dev
+                lower.name = result_var.name
+
+                surface *= (
+                    hv.Dataset(upper)
+                    .to(hv.Surface)
+                    .opts(alpha=alpha, colorbar=False, backend="plotly")
+                )
+                surface *= (
+                    hv.Dataset(lower)
+                    .to(hv.Surface)
+                    .opts(alpha=alpha, colorbar=False, backend="plotly")
+                )
+
+            surface = surface.opts(
+                zlabel=f"{result_var.name} [{result_var.units}]",
+                title=f"{result_var.name} vs ({x.name} and {y.name})",
+                backend="plotly",
+                **kwargs,
+            )
+
+            if self.bench_cfg.render_plotly:
+                hv.extension("plotly")
+                out = surface
+            else:
+                # using render disabled the holoviews sliders :(
+                out = hv.render(surface, backend="plotly")
+            return pn.Column(out, name="surface_hv")
+
+        return matches_res.to_panel()

bencher/results/holoview_results/table_result.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+import holoviews as hv
+from bencher.results.bench_result_base import ReduceType
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+
+class TableResult(HoloviewResult):
+    def to_plot(self, **kwargs) -> hv.Table:  # pylint:disable=unused-argument
+        """Convert the dataset to a Table visualization.
+
+        Returns:
+            hv.Table: A HoloViews Table object.
+        """
+        return self.to_hv_type(hv.Table, ReduceType.SQUEEZE)

bencher/results/holoview_results/tabulator_result.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+import panel as pn
+
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+
+class TabulatorResult(HoloviewResult):
+    def to_plot(self, **kwargs) -> pn.widgets.Tabulator:  # pylint:disable=unused-argument
+        """Create an interactive table visualization of the data.
+
+        Passes the data to the panel Tabulator type to display an interactive table.
+        See https://panel.holoviz.org/reference/widgets/Tabulator.html for extra options.
+
+        Args:
+            **kwargs: Additional parameters to pass to the Tabulator constructor.
+
+        Returns:
+            pn.widgets.Tabulator: An interactive table widget.
+        """
+        return pn.widgets.Tabulator(self.to_pandas())

bencher/results/optuna_result.py

@@ -5,11 +5,6 @@ from copy import deepcopy
 import numpy as np
 import optuna
 import panel as pn
-from collections import defaultdict
-from textwrap import wrap
-
-import pandas as pd
-import xarray as xr
 
 
 from optuna.visualization import (
@@ -18,9 +13,7 @@ from optuna.visualization import (
 )
 from bencher.utils import hmap_canonical_input
 from bencher.variables.time import TimeSnapshot, TimeEvent
-from bencher.bench_cfg import BenchCfg
-from bencher.plotting.plt_cnt_cfg import PltCntCfg
-
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
 
 # from bencher.results.bench_result_base import BenchResultBase
 from bencher.optuna_conversions import (
@@ -33,97 +26,15 @@ from bencher.optuna_conversions import (
 )
 
 
-def convert_dataset_bool_dims_to_str(dataset: xr.Dataset) -> xr.Dataset:
-    """Given a dataarray that contains boolean coordinates, convert them to strings so that holoviews loads the data properly
-
-    Args:
-        dataarray (xr.DataArray): dataarray with boolean coordinates
-
-    Returns:
-        xr.DataArray: dataarray with boolean coordinates converted to strings
-    """
-    bool_coords = {}
-    for c in dataset.coords:
-        if dataset.coords[c].dtype == bool:
-            bool_coords[c] = [str(vals) for vals in dataset.coords[c].values]
-
-    if len(bool_coords) > 0:
-        return dataset.assign_coords(bool_coords)
-    return dataset
-
-
-class OptunaResult:
-    def __init__(self, bench_cfg: BenchCfg) -> None:
-        self.bench_cfg = bench_cfg
-        # self.wrap_long_time_labels(bench_cfg)  # todo remove
-        self.ds = xr.Dataset()
-        self.object_index = []
-        self.hmaps = defaultdict(dict)
-        self.result_hmaps = bench_cfg.result_hmaps
-        self.studies = []
-        self.plt_cnt_cfg = PltCntCfg()
-        self.plot_inputs = []
-        self.dataset_list = []
-
-        # self.width=600/
-        # self.height=600
-
-        #   bench_res.objects.append(rv)
-        # bench_res.reference_index = len(bench_res.objects)
-
-    def post_setup(self):
-        self.plt_cnt_cfg = PltCntCfg.generate_plt_cnt_cfg(self.bench_cfg)
-        self.bench_cfg = self.wrap_long_time_labels(self.bench_cfg)
-        self.ds = convert_dataset_bool_dims_to_str(self.ds)
-
-    def to_xarray(self) -> xr.Dataset:
-        return self.ds
-
-    def setup_object_index(self):
-        self.object_index = []
-
-    def to_pandas(self, reset_index=True) -> pd.DataFrame:
-        """Get the xarray results as a pandas dataframe
-
-        Returns:
-            pd.DataFrame: The xarray results array as a pandas dataframe
-        """
-        ds = self.to_xarray().to_dataframe()
-        if reset_index:
-            return ds.reset_index()
-        return ds
-
-    def wrap_long_time_labels(self, bench_cfg):
-        """Takes a benchCfg and wraps any index labels that are too long to be plotted easily
-
-        Args:
-            bench_cfg (BenchCfg):
-
-        Returns:
-            BenchCfg: updated config with wrapped labels
-        """
-        if bench_cfg.over_time:
-            if self.ds.coords["over_time"].dtype == np.datetime64:
-                # plotly catastrophically fails to plot anything with the default long string representation of time, so convert to a shorter time representation
-                self.ds.coords["over_time"] = [
-                    pd.to_datetime(t).strftime("%d-%m-%y %H-%M-%S")
-                    for t in self.ds.coords["over_time"].values
-                ]
-                # wrap very long time event labels because otherwise the graphs are unreadable
-            if bench_cfg.time_event is not None:
-                self.ds.coords["over_time"] = [
-                    "\n".join(wrap(t, 20)) for t in self.ds.coords["over_time"].values
-                ]
-        return bench_cfg
-
-    def to_optuna_plots(self) -> List[pn.pane.panel]:
+class OptunaResult(BenchResultBase):
+    def to_optuna_plots(self, **kwargs) -> List[pn.pane.panel]:
         """Create an optuna summary from the benchmark results
 
         Returns:
             List[pn.pane.panel]: A list of optuna plot summarising the benchmark process
         """
 
-        return self.collect_optuna_plots()
+        return self.collect_optuna_plots(**kwargs)
 
     def to_optuna_from_sweep(self, bench, n_trials=30):
         optu = self.to_optuna_from_results(
@@ -175,7 +86,8 @@ class OptunaResult:
             optuna.Study: optuna description of the study
         """
         if include_meta:
-            df = self.to_pandas()
+            # df = self.to_pandas()
+            df = self.to_dataset(reduce=ReduceType.NONE).to_dataframe().reset_index()
             all_vars = []
             for v in self.bench_cfg.all_vars:
                 if type(v) is not TimeEvent:
@@ -189,11 +101,15 @@ class OptunaResult:
             # if self.bench_cfg.repeats>1:
             # df = self.bench_cfg.ds.mean("repeat").to_dataframe().reset_index()
             # else:
-            df = self.to_pandas().reset_index()
+            # df = self.to_pandas().reset_index()
+            df = self.to_dataset(reduce=ReduceType.AUTO).to_dataframe().reset_index()
         # df = self.bench_cfg.ds.mean("repeat").to_dataframe.reset_index()
         # self.bench_cfg.all_vars
         # del self.bench_cfg.meta_vars[1]
 
+        # optuna does not like the nan values so remove them.
+        df.dropna(inplace=True)
+
         trials = []
         distributions = {}
         for i in all_vars:
@@ -210,6 +126,9 @@ class OptunaResult:
                     params[i.name] = row[1][i.name]
 
             for r in self.bench_cfg.optuna_targets():
+                # print(row[1][r])
+                # print(np.isnan(row[1][r]))
+                # if not np.isnan(row[1][r]):
                 values.append(row[1][r])
 
             trials.append(
@@ -245,7 +164,9 @@ class OptunaResult:
     def get_pareto_front_params(self):
         return [p.params for p in self.studies[0].trials]
 
-    def collect_optuna_plots(self) -> List[pn.pane.panel]:
+    def collect_optuna_plots(
+        self, pareto_width: float = None, pareto_height: float = None
+    ) -> List[pn.pane.panel]:
         """Use optuna to plot various summaries of the optimisation
 
         Args:
@@ -292,11 +213,18 @@ class OptunaResult:
                             include_dominated_trials=False,
                         )
                     )
+                    if pareto_width is not None:
+                        study_pane[-1].width = pareto_width
+                    if pareto_height is not None:
+                        study_pane[-1].height = pareto_height
+                try:
+                    study_pane.append(param_importance(self.bench_cfg, study))
+                    param_str.append(
+                        f"    Number of trials on the Pareto front: {len(study.best_trials)}"
+                    )
+                except RuntimeError as e:
+                    study_pane.append(f"Error generating parameter importance: {str(e)}")
 
-                study_pane.append(param_importance(self.bench_cfg, study))
-                param_str.append(
-                    f"    Number of trials on the Pareto front: {len(study.best_trials)}"
-                )
                 for t in study.best_trials:
                     param_str.extend(summarise_trial(t, self.bench_cfg))
 
@@ -343,18 +271,5 @@ class OptunaResult:
         """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 overrides 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 overrides general size
-            if self.bench_cfg.plot_height is not None:
-                kwargs["height"] = self.bench_cfg.plot_height
-        return kwargs
+    def get_best_holomap(self, name: str = None):
+        return self.get_hmap(name)[self.get_best_trial_params(True)]

bencher/results/video_controls.py

@@ -0,0 +1,38 @@
+from typing import Optional
+from pathlib import Path
+import panel as pn
+
+
+class VideoControls:
+    def __init__(self) -> None:
+        self.vid_p = []
+
+    def video_container(self, path, **kwargs):
+        if path is not None and Path(path).exists():
+            vid = pn.pane.Video(path, autoplay=True, **kwargs)
+            vid.loop = True
+            self.vid_p.append(vid)
+            return vid
+        return pn.pane.Markdown(f"video does not exist {path}")
+
+    def video_controls(self) -> Optional[pn.Column]:
+        def play_vid(_):  # pragma: no cover
+            for r in self.vid_p:
+                r.paused = False
+
+        def reset_vid(_):  # pragma: no cover
+            for r in self.vid_p:
+                r.paused = False
+                r.time = 0
+
+        button_names = ["Play Videos", "Pause Videos", "Loop Videos", "Reset Videos"]
+        buttom_cb = [play_vid, reset_vid]
+
+        buttons = pn.Row()
+
+        for name, cb in zip(button_names, buttom_cb):
+            button = pn.widgets.Button(name=name)
+            pn.bind(cb, button, watch=True)
+            buttons.append(button)
+
+        return pn.Column(buttons)

bencher/results/video_result.py

@@ -1,38 +1,41 @@
 from typing import Optional
-from pathlib import Path
+from functools import partial
 import panel as pn
-
-
-class VideoControls:
-    def __init__(self) -> None:
-        self.vid_p = []
-
-    def video_container(self, path, **kwargs):
-        if path is not None and Path(path).exists():
-            vid = pn.pane.Video(path, autoplay=True, **kwargs)
-            vid.loop = True
-            self.vid_p.append(vid)
-            return vid
-        return pn.pane.Markdown(f"video does not exist {path}")
-
-    def video_controls(self) -> Optional[pn.Column]:
-        def play_vid(_):  # pragma: no cover
-            for r in self.vid_p:
-                r.paused = False
-
-        def reset_vid(_):  # pragma: no cover
-            for r in self.vid_p:
-                r.paused = False
-                r.time = 0
-
-        button_names = ["Play Videos", "Pause Videos", "Loop Videos", "Reset Videos"]
-        buttom_cb = [play_vid, reset_vid]
-
-        buttons = pn.Row()
-
-        for name, cb in zip(button_names, buttom_cb):
-            button = pn.widgets.Button(name=name)
-            pn.bind(cb, button, watch=True)
-            buttons.append(button)
-
-        return pn.Column(buttons)
+from param import Parameter
+import holoviews as hv
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
+from bencher.results.video_controls import VideoControls
+from bencher.variables.results import (
+    PANEL_TYPES,
+)
+
+
+class VideoResult(BenchResultBase):
+    def to_video(self, result_var: Parameter = None, **kwargs):
+        vc = VideoControls()
+        return pn.Column(
+            vc.video_controls(),
+            self.to_panes(result_var=result_var, container=vc.video_container, **kwargs),
+        )
+
+    def to_panes(
+        self,
+        result_var: Parameter = None,
+        hv_dataset=None,
+        target_dimension: int = 0,
+        container=None,
+        level: int = None,
+        **kwargs,
+    ) -> Optional[pn.pane.panel]:
+        if hv_dataset is None:
+            hv_dataset = self.to_hv_dataset(ReduceType.SQUEEZE, level=level)
+        elif not isinstance(hv_dataset, hv.Dataset):
+            hv_dataset = hv.Dataset(hv_dataset)
+        return self.map_plot_panes(
+            partial(self.ds_to_container, container=container),
+            hv_dataset=hv_dataset,
+            target_dimension=target_dimension,
+            result_var=result_var,
+            result_types=PANEL_TYPES,
+            **kwargs,
+        )

bencher/results/video_summary.py

@@ -8,7 +8,7 @@ from bencher.variables.results import ResultImage
 from bencher.plotting.plot_filter import VarRange, PlotFilter
 from bencher.utils import callable_name, int_to_col, color_tuple_to_255
 from bencher.video_writer import VideoWriter
-from bencher.results.video_result import VideoControls
+from bencher.results.video_controls import VideoControls
 from bencher.results.composable_container.composable_container_video import (
     ComposableContainerVideo,
     ComposeType,
@@ -60,7 +60,7 @@ class VideoSummaryResult(BenchResultBase):
             input_range=VarRange(1, None),
         )
         matches_res = plot_filter.matches_result(
-            self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
+            self.plt_cnt_cfg, callable_name(self.to_video_grid_ds), override=False
         )
 
         if pane_collection is None:

bencher/results/{plotly_result.py → volume_result.py}

@@ -1,29 +1,50 @@
-import panel as pn
-import plotly.graph_objs as go
-from typing import Optional
-import xarray as xr
+from typing import Optional, Any
 
+import xarray as xr
 from param import Parameter
+import panel as pn
+import plotly.graph_objs as go
 
 from bencher.plotting.plot_filter import VarRange
 from bencher.results.bench_result_base import BenchResultBase, ReduceType
 from bencher.variables.results import ResultVar
 
 
-class PlotlyResult(BenchResultBase):
-    def to_volume(self, result_var: Parameter = None, **kwargs):
+class VolumeResult(BenchResultBase):
+    def to_plot(
+        self, result_var: Optional[Parameter] = None, override: bool = True, **kwargs: Any
+    ) -> Optional[pn.panel]:
+        """Generates a 3d volume plot from benchmark data.
+
+        Args:
+            result_var (Optional[Parameter]): The result variable to plot. If None, uses the default.
+            override (bool): Whether to override filter restrictions. Defaults to True.
+            **kwargs (Any): Additional keyword arguments passed to the plot rendering.
+
+        Returns:
+            Optional[pn.panel]: A panel containing the volume plot if data is appropriate,
+            otherwise returns filter match results.
+        """
+        return self.to_volume(
+            result_var=result_var,
+            override=override,
+            **kwargs,
+        )
+
+    def to_volume(self, result_var: Parameter = None, override: bool = True, **kwargs):
         return self.filter(
-            self.to_volume_da,
+            self.to_volume_ds,
             float_range=VarRange(3, 3),
             cat_range=VarRange(-1, 0),
             reduce=ReduceType.REDUCE,
             target_dimension=3,
             result_var=result_var,
             result_types=(ResultVar),
+            override=override,
             **kwargs,
         )
 
-    def to_volume_da(
+    def to_volume_ds(
         self, dataset: xr.Dataset, result_var: Parameter, width=600, height=600
     ) -> Optional[pn.pane.Plotly]:
         """Given a benchCfg generate a 3D surface plot