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

bencher/results/dataset_result.py

@@ -1,18 +1,16 @@
 from typing import Optional
+from functools import partial
+
 import panel as pn
 from param import Parameter
-from bencher.results.bench_result_base import BenchResultBase, ReduceType
-
-
-from functools import partial
 import holoviews as hv
-from bencher.variables.results import (
-    PANEL_TYPES,
-)
+
+from bencher.variables.results import PANEL_TYPES
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
 
 
 class DataSetResult(BenchResultBase):
-    def to_dataset1(
+    def to_plot(
         self,
         result_var: Parameter = None,
         hv_dataset=None,
@@ -33,195 +31,3 @@ class DataSetResult(BenchResultBase):
             result_types=PANEL_TYPES,
             **kwargs,
         )
-
-
-# class DataSetResult(BenchResultBase):
-
-#     def to_datatset(
-#         self,
-#         result_var: Parameter = None,
-#         result_types=(ResultDataSet,),
-#         pane_collection: pn.pane = None,
-#         time_sequence_dimension=0,
-#         target_duration: float = None,
-#         **kwargs,
-#     ) -> Optional[pn.panel]:
-#         """Returns the results compiled into a video
-
-#         Args:
-#             result_var (Parameter, optional): The result var to plot. Defaults to None.
-#             result_types (tuple, optional): The types of result var to convert to video. Defaults to (ResultDataSet,).
-#             collection (pn.pane, optional): If there are multiple results, use this collection to stack them. Defaults to pn.Row().
-
-#         Returns:
-#             Optional[pn.panel]: a panel pane with a video of all results concatenated together
-#         """
-#         plot_filter = PlotFilter(
-#             float_range=VarRange(0, None),
-#             cat_range=VarRange(0, None),
-#             panel_range=VarRange(1, None),
-#             input_range=VarRange(0, None),
-#         )
-#         matches_res = plot_filter.matches_result(
-#             self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
-#         )
-
-#         if pane_collection is None:
-#             pane_collection = pn.Row()
-
-#         if matches_res.overall:
-#             ds = self.to_dataset(ReduceType.SQUEEZE)
-#             for rv in self.get_results_var_list(result_var):
-#                 if isinstance(rv, result_types):
-#                     pane_collection.append(
-#                         self.to_video_grid_ds(
-#                             ds,
-#                             rv,
-#                             time_sequence_dimension=time_sequence_dimension,
-#                             target_duration=target_duration,
-#                             **kwargs,
-#                         )
-#                     )
-#             return pane_collection
-#         return matches_res.to_panel()
-
-#     def to_video_grid_ds(
-#         self,
-#         dataset: xr.Dataset,
-#         result_var: Parameter,
-#         reverse=True,
-#         time_sequence_dimension=0,
-#         video_controls: VideoControls = None,
-#         target_duration: float = None,
-#         **kwargs,
-#     ):
-#         cvc = self._to_video_panes_ds(
-#             dataset,
-#             self.plot_cb,
-#             target_dimension=0,
-#             horizontal=True,
-#             compose_method=ComposeType.right,
-#             time_sequence_dimension=time_sequence_dimension,
-#             result_var=result_var,
-#             final=True,
-#             reverse=reverse,
-#             target_duration=target_duration,
-#             **kwargs,
-#         )
-
-#         filename = VideoWriter().write_video_raw(cvc)
-
-#         if filename is not None:
-#             if video_controls is None:
-#                 video_controls = VideoControls()
-#             return video_controls.video_container(
-#                 filename, width=kwargs.get("width", None), height=kwargs.get("height", None)
-#             )
-#         return None
-
-#     def plot_cb(self, dataset, result_var, **kwargs):
-#         val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
-#         return val
-
-#     def dataset_to_compose_list(
-#         self,
-#         dataset: xr.Dataset,
-#         first_compose_method: ComposeType = ComposeType.down,
-#         time_sequence_dimension: int = 0,
-#     ) -> List[ComposeType]:
-#         """ "Given a dataset, chose an order for composing the results.  By default will flip between right and down and the last dimension will be a time sequence.
-
-#         Args:
-#             dataset (xr.Dataset): the dataset to render
-#             first_compose_method (ComposeType, optional): the direction of the first composition method. Defaults to ComposeType.right.
-#             time_sequence_dimension (int, optional): The dimension to start time sequencing instead of composing in space. Defaults to 0.
-
-#         Returns:
-#             List[ComposeType]: A list of composition methods for composing the dataset result
-#         """
-
-#         num_dims = len(dataset.sizes)
-#         if time_sequence_dimension == -1:  # use time sequence for everything
-#             compose_method_list = [ComposeType.sequence] * (num_dims + 1)
-#         else:
-#             compose_method_list = [first_compose_method]
-#             compose_method_list.extend(
-#                 ComposeType.flip(compose_method_list[-1]) for _ in range(num_dims - 1)
-#             )
-#             compose_method_list.append(ComposeType.sequence)
-
-#             for i in range(min(len(compose_method_list), time_sequence_dimension + 1)):
-#                 compose_method_list[i] = ComposeType.sequence
-
-#         return compose_method_list
-
-#     def _to_video_panes_ds(
-#         self,
-#         dataset: xr.Dataset,
-#         plot_callback: callable = None,
-#         target_dimension=0,
-#         compose_method=ComposeType.right,
-#         compose_method_list=None,
-#         result_var=None,
-#         time_sequence_dimension=0,
-#         root_dimensions=None,
-#         reverse=False,
-#         target_duration: float = None,
-#         **kwargs,
-#     ) -> pn.panel:
-#         num_dims = len(dataset.sizes)
-#         dims = list(d for d in dataset.sizes)
-#         if reverse:
-#             dims = list(reversed(dims))
-
-#         if root_dimensions is None:
-#             root_dimensions = num_dims
-
-#         if compose_method_list is None:
-#             compose_method_list = self.dataset_to_compose_list(
-#                 dataset, compose_method, time_sequence_dimension=time_sequence_dimension
-#             )
-
-#             # print(compose_method_list)
-
-#         compose_method_list_pop = deepcopy(compose_method_list)
-#         if len(compose_method_list_pop) > 1:
-#             compose_method = compose_method_list_pop.pop()
-
-#         if num_dims > (target_dimension) and num_dims != 0:
-#             selected_dim = dims[-1]
-#             outer_container = ComposableContainerVideo()
-#             for i in range(dataset.sizes[selected_dim]):
-#                 sliced = dataset.isel({selected_dim: i})
-#                 label_val = sliced.coords[selected_dim].values.item()
-#                 inner_container = ComposableContainerVideo()
-
-#                 panes = self._to_video_panes_ds(
-#                     sliced,
-#                     plot_callback=plot_callback,
-#                     target_dimension=target_dimension,
-#                     compose_method_list=compose_method_list_pop,
-#                     result_var=result_var,
-#                     root_dimensions=root_dimensions,
-#                     time_sequence_dimension=time_sequence_dimension,
-#                 )
-#                 inner_container.append(panes)
-
-#                 rendered = inner_container.render(
-#                     RenderCfg(
-#                         var_name=selected_dim,
-#                         var_value=label_val,
-#                         compose_method=compose_method,
-#                         duration=target_duration,
-#                     )
-#                 )
-#                 outer_container.append(rendered)
-#             return outer_container.render(
-#                 RenderCfg(
-#                     compose_method=compose_method,
-#                     duration=target_duration,
-#                     background_col=color_tuple_to_255(int_to_col(num_dims - 2, 0.05, 1.0)),
-#                     # background_col= (255,0,0),
-#                 )
-#             )
-#         return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

bencher/results/explorer_result.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+import panel as pn
+import hvplot.xarray  # noqa pylint: disable=duplicate-code,unused-import
+import hvplot.pandas  # noqa pylint: disable=duplicate-code,unused-import
+
+from bencher.results.video_result import VideoResult
+
+
+class ExplorerResult(VideoResult):
+    def to_plot(self, **kwargs) -> pn.pane.Pane:  # noqa pylint: disable=unused-argument
+        """Produces a hvplot explorer instance to explore the generated dataset
+        see: https://hvplot.holoviz.org/getting_started/explorer.html
+
+        Returns:
+            pn.pane.Pane: A dynamic pane for exploring a dataset
+        """
+
+        if len(self.bench_cfg.input_vars) > 0:
+            return self.to_xarray().hvplot.explorer()
+
+        # For some reason hvplot doesn't like 1D datasets in xarray, so convert to pandas which it has no problem with
+        # TODO look into why this is, its probably due to how I am setting up the indexing in xarray.
+        return self.to_pandas().hvplot.explorer()

bencher/results/{hvplot_result.py → histogram_result.py}

@@ -6,30 +6,15 @@ import hvplot.xarray  # noqa pylint: disable=duplicate-code,unused-import
 import hvplot.pandas  # noqa pylint: disable=duplicate-code,unused-import
 import xarray as xr
 
-from bencher.results.panel_result import PanelResult
+from bencher.results.video_result import VideoResult
 from bencher.results.bench_result_base import ReduceType
 
 from bencher.plotting.plot_filter import VarRange
 from bencher.variables.results import ResultVar
 
 
-class HvplotResult(PanelResult):
-    def to_explorer(self) -> pn.pane.Pane:
-        """Produces a hvplot explorer instance to explore the generated dataset
-        see: https://hvplot.holoviz.org/getting_started/explorer.html
-
-        Returns:
-            pn.pane.Pane: A dynamic pane for exploring a dataset
-        """
-
-        if len(self.bench_cfg.input_vars) > 0:
-            return self.to_xarray().hvplot.explorer()
-
-        # For some reason hvplot doesn't like 1D datasets in xarray, so convert to pandas which it has no problem with
-        # TODO look into why this is, its probably due to how I am setting up the indexing in xarray.
-        return self.to_pandas().hvplot.explorer()
-
-    def to_histogram(self, result_var: Parameter = None, **kwargs) -> Optional[pn.pane.Pane]:
+class HistogramResult(VideoResult):
+    def to_plot(self, result_var: Parameter = None, **kwargs) -> Optional[pn.pane.Pane]:
         return self.filter(
             self.to_histogram_ds,
             float_range=VarRange(0, 0),

bencher/results/holoview_results/bar_result.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from typing import Optional
+import panel as pn
+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 VarRange
+from bencher.variables.results import ResultVar
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+
+class BarResult(HoloviewResult):
+    """A class for creating bar chart visualizations from benchmark results.
+
+    Bar charts are effective for comparing values across categorical variables or
+    discrete data points. This class provides methods to generate bar charts that
+    display benchmark results, particularly useful for comparing performance metrics
+    between different configurations or categories.
+    """
+
+    def to_plot(
+        self, result_var: Parameter = None, override: bool = True, **kwargs
+    ) -> Optional[pn.panel]:
+        return self.to_bar(result_var, override, **kwargs)
+
+    def to_bar(
+        self, result_var: Parameter = None, override: bool = True, **kwargs
+    ) -> Optional[pn.panel]:
+        """Generates a bar chart from benchmark data.
+
+        This method applies filters to ensure the data is appropriate for a bar chart
+        and then passes the filtered data to to_bar_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.panel]: A panel containing the bar chart if data is appropriate,
+                              otherwise returns filter match results.
+        """
+        return self.filter(
+            self.to_bar_ds,
+            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,
+            result_types=(ResultVar),
+            override=override,
+            **kwargs,
+        )
+
+    def to_bar_ds(self, dataset: xr.Dataset, result_var: Parameter = None, **kwargs):
+        """Creates a bar chart from the provided dataset.
+
+        Given a filtered dataset, this method generates a bar chart visualization showing
+        values of the result variable, potentially grouped by categorical variables.
+
+        Args:
+            dataset (xr.Dataset): The dataset containing benchmark results.
+            result_var (Parameter, optional): The result variable to plot. If None, uses the default.
+            **kwargs: Additional keyword arguments passed to the bar chart options.
+
+        Returns:
+            hvplot.element.Bars: A bar chart visualization of the benchmark data.
+        """
+        by = None
+        if self.plt_cnt_cfg.cat_cnt >= 2:
+            by = self.plt_cnt_cfg.cat_vars[1].name
+        da_plot = dataset[result_var.name]
+        title = self.title_from_ds(da_plot, result_var, **kwargs)
+        time_widget_args = self.time_widget(title)
+        return da_plot.hvplot.bar(by=by, **time_widget_args, **kwargs)

bencher/results/holoview_results/curve_result.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+from typing import Optional
+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 VarRange
+from bencher.variables.results import ResultVar
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+
+class CurveResult(HoloviewResult):
+    """A class for creating curve plots from benchmark results.
+
+    Curve plots are useful for visualizing the relationship between a continuous
+    input variable and a result variable. This class provides methods to generate
+    line plots that 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[hv.Curve]:
+        """Generates a curve plot from benchmark data.
+
+        This is a convenience method that calls to_curve() 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[hv.Curve]: A curve plot if data is appropriate,
+                              otherwise returns filter match results.
+        """
+        return self.to_curve(result_var=result_var, override=override, **kwargs)
+
+    def to_curve(self, result_var: Parameter = None, override: bool = True, **kwargs):
+        """Generates a curve plot from benchmark data.
+
+        This method applies filters to ensure the data is appropriate for a curve plot
+        and then passes the filtered data to to_curve_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[hv.Curve]: A curve plot if data is appropriate,
+                              otherwise returns filter match results.
+        """
+        return self.filter(
+            self.to_curve_ds,
+            float_range=VarRange(1, 1),
+            cat_range=VarRange(0, None),
+            repeats_range=VarRange(2, None),
+            reduce=ReduceType.REDUCE,
+            # reduce=ReduceType.MINMAX,
+            target_dimension=2,
+            result_var=result_var,
+            result_types=(ResultVar),
+            override=override,
+            **kwargs,
+        )
+
+    def to_curve_ds(
+        self, dataset: xr.Dataset, result_var: Parameter, **kwargs
+    ) -> Optional[hv.Curve]:
+        """Creates a curve plot from the provided dataset.
+
+        Given a filtered dataset, this method generates a curve visualization showing
+        the relationship between a continuous input variable and the result variable.
+        When multiple benchmark repetitions are available, standard deviation bounds
+        can also be displayed using a spread plot.
+
+        Args:
+            dataset (xr.Dataset): The dataset containing benchmark results.
+            result_var (Parameter): The result variable to plot.
+            **kwargs: Additional keyword arguments passed to the curve plot options.
+
+        Returns:
+            Optional[hv.Curve]: A curve plot with optional standard deviation spread.
+        """
+        hvds = hv.Dataset(dataset)
+        title = self.title_from_ds(dataset, result_var, **kwargs)
+        # print(result_var.name)
+        # print( dataset)
+        pt = hv.Overlay()
+        # find pairs of {var_name} {var_name}_std to plot the line and their spreads.
+        var = result_var.name
+        std_var = f"{var}_std"
+        pt *= hvds.to(hv.Curve, vdims=var, label=var).opts(title=title, **kwargs)
+        # Only create a Spread if the matching _std variable exists
+        if std_var in dataset.data_vars:
+            pt *= hvds.to(hv.Spread, vdims=[var, std_var])
+
+        # for var in dataset.data_vars:
+        #     print(var)
+        #     if not var.endswith("_std"):
+        #         std_var = f"{var}_std"
+        #         pt *= hvds.to(hv.Curve, vdims=var, label=var).opts(title=title, **kwargs)
+        #         #Only create a Spread if the matching _std variable exists
+        #         if std_var in dataset.data_vars:
+        #             pt *= hvds.to(hv.Spread, vdims=[var, std_var])
+
+        return pt.opts(legend_position="right")

bencher/results/holoview_results/distribution_result/box_whisker_result.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from typing import Optional, Any
+import panel as pn
+import holoviews as hv
+from param import Parameter
+import xarray as xr
+
+from bencher.results.holoview_results.distribution_result.distribution_result import (
+    DistributionResult,
+)
+
+
+class BoxWhiskerResult(DistributionResult):
+    """A class for creating box and whisker plots from benchmark results.
+
+    Box and whisker plots are useful for visualizing the distribution of data,
+    including the median, quartiles, and potential outliers. This class provides
+    methods to generate these plots from benchmark data, particularly useful for
+    comparing distributions across different categorical variables or between
+    different repetitions of the same benchmark.
+
+    Box plots show:
+    - The median (middle line in the box)
+    - The interquartile range (IQR) as a box (25th to 75th percentile)
+    - Whiskers extending to the furthest data points within 1.5*IQR
+    - Outliers as individual points beyond the whiskers
+    """
+
+    def to_plot(
+        self, result_var: Optional[Parameter] = None, override: bool = True, **kwargs: Any
+    ) -> Optional[pn.panel]:
+        """Generates a box and whisker plot from benchmark data.
+
+        This method applies filters to ensure the data is appropriate for a box plot
+        and then passes the filtered data to to_boxplot_ds for rendering.
+
+        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 box plot if data is appropriate,
+            otherwise returns filter match results.
+        """
+        return self.to_distribution_plot(
+            self.to_boxplot_ds,
+            result_var=result_var,
+            override=override,
+            **kwargs,
+        )
+
+    def to_boxplot_ds(
+        self, dataset: xr.Dataset, result_var: Parameter, **kwargs: Any
+    ) -> hv.BoxWhisker:
+        """Creates a box and whisker plot from the provided dataset.
+
+        Given a filtered dataset, this method generates a box and whisker visualization showing
+        the distribution of values for a result variable, potentially grouped by a categorical variable.
+
+        Args:
+            dataset (xr.Dataset): The dataset containing benchmark results.
+            result_var (Parameter): The result variable to plot.
+            **kwargs (Any): Additional keyword arguments for plot customization such as:
+                      - box_fill_color: Color for the box
+                      - whisker_color: Color for the whiskers
+                      - outlier_color: Color for outlier points
+                      - line_width: Width of lines in the plot
+
+        Returns:
+            hv.BoxWhisker: A HoloViews BoxWhisker plot of the benchmark data.
+        """
+        return self._plot_distribution(dataset, result_var, hv.BoxWhisker, **kwargs)

bencher/results/holoview_results/distribution_result/distribution_result.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+from typing import Optional, Callable, Any, Type
+import panel as pn
+import holoviews as hv
+from param import Parameter
+import xarray as xr
+
+from bencher.results.bench_result_base import ReduceType
+from bencher.plotting.plot_filter import VarRange
+from bencher.variables.results import ResultVar
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+from bencher.utils import params_to_str
+
+
+class DistributionResult(HoloviewResult):
+    """A base class for creating distribution plots (violin, box-whisker) from benchmark results.
+
+    This class provides common functionality for various distribution plot types that show
+    the distribution shape of the data. Child classes implement specific plot types
+    (e.g., violin plots, box and whisker plots) but share filtering and data preparation logic.
+
+    Distribution plots are particularly useful for visualizing the statistical spread of
+    benchmark metrics across different configurations, allowing for better understanding
+    of performance variability.
+    """
+
+    def to_distribution_plot(
+        self,
+        plot_method: Callable[[xr.Dataset, Parameter, Any], hv.Element],
+        result_var: Optional[Parameter] = None,
+        override: bool = True,
+        **kwargs: Any,
+    ) -> Optional[pn.panel]:
+        """Generates a distribution plot from benchmark data.
+
+        This method applies filters to ensure the data is appropriate for distribution plots
+        and then passes the filtered data to the specified plot method for rendering.
+
+        Args:
+            plot_method: The method to use for creating the specific plot type (e.g., violin, box-whisker)
+            result_var: The result variable to plot. If None, uses the default.
+            override: Whether to override filter restrictions. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the plot rendering.
+
+        Returns:
+            A panel containing the plot if data is appropriate,
+            otherwise returns filter match results.
+        """
+        return self.filter(
+            plot_method,
+            float_range=VarRange(0, 0),
+            cat_range=VarRange(0, None),
+            repeats_range=VarRange(2, None),
+            reduce=ReduceType.NONE,
+            target_dimension=self.plt_cnt_cfg.cat_cnt + 1,  # +1 cos we have a repeats dimension
+            result_var=result_var,
+            result_types=(ResultVar),
+            override=override,
+            **kwargs,
+        )
+
+    def _plot_distribution(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        plot_class: Type[hv.Selection1DExpr],
+        **kwargs: Any,
+    ) -> hv.Element:
+        """Prepares data for distribution plots and creates the plot.
+
+        This method handles common operations needed for all distribution plot types,
+        including converting data formats, setting up dimensions, and configuring
+        plot aesthetics.
+
+        Args:
+            dataset: The dataset containing benchmark results.
+            result_var: The result variable to plot.
+            plot_class: The HoloViews plot class to use (e.g., hv.Violin, hv.BoxWhisker)
+            **kwargs: Additional keyword arguments for plot customization.
+
+        Returns:
+            A HoloViews Element representing the distribution plot.
+        """
+        # Get the name of the result variable (which is the data we want to plot)
+        var_name = result_var.name
+
+        # Create plot title
+        title = self.title_from_ds(dataset[var_name], result_var, **kwargs)
+
+        # Convert dataset to dataframe for HoloViews
+        df = dataset[var_name].to_dataframe().reset_index()
+        kdims = params_to_str(self.plt_cnt_cfg.cat_vars)
+
+        if not isinstance(plot_class, list):
+            plot_class = [plot_class]
+
+        overlay = hv.Overlay()
+        for plot in plot_class:
+            overlay *= plot(
+                df,
+                kdims=kdims,
+                vdims=[var_name],
+            ).opts(
+                title=title,
+                ylabel=f"{var_name} [{result_var.units}]",
+                xrotation=30,  # Rotate x-axis labels by 30 degrees
+                **kwargs,
+            )
+        return overlay