holobench 1.25.2__py3-none-any.whl → 1.27.0__py3-none-any.whl

bencher/example/example_floats2D.py

@@ -0,0 +1,93 @@
+# pylint: disable=duplicate-code
+import bencher as bch
+
+# All the examples will be using the data structures and benchmark function defined in this file
+from bencher.example.benchmark_data import (
+    ExampleBenchCfgOut,
+    NoiseDistribution,
+    ExampleBenchCfg,
+    call,
+)
+
+
+def example_floats2D(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a 2D floating point parameter sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+    bench = bch.Bench(
+        "Bencher_Example_Floats",
+        call,
+        run_cfg=run_cfg,
+        report=report,
+    )
+    run_cfg.use_optuna = True
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfg.param.theta, ExampleBenchCfg.param.offset],
+        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
+        const_vars=[
+            ExampleBenchCfg.param.sigma.with_const(0.1),
+            ExampleBenchCfg.param.noise_distribution.with_const(NoiseDistribution.gaussian),
+            ExampleBenchCfg.param.noisy.with_const(True),
+        ],
+        title="Float 2D Example",
+        description="""Bencher is a tool to make it easy to explore how input parameter affect a range of output metrics.  In these examples we are going to benchmark an example function which has been selected to show the features of bencher.
+        The example function takes an input theta and returns the absolute value of sin(theta) and cos(theta) +- various types of noise.
+
+    The following examples will show how to perform parameter sweeps to characterise the behavior of the function.  The idea is that the benchmarking can be used to gain understanding of an unknown function.
+        """,
+        post_description="Here you can see the output plot of sin theta between 0 and pi.  In the tabs at the top you can also view 3 tabular representations of the data",
+    )
+
+    bench.report.append(bench.get_result().to_surface())
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfg.param.theta,
+            ExampleBenchCfg.param.offset,
+            ExampleBenchCfg.param.postprocess_fn,
+        ],
+        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
+        const_vars=[
+            (ExampleBenchCfg.param.sigma, 0.1),
+            (ExampleBenchCfg.param.noise_distribution, NoiseDistribution.gaussian),
+            (ExampleBenchCfg.param.noisy, True),
+        ],
+        title="Float 2D with categorical Example",
+        description="""Here we add plot a 2d surface and facet over a categorical variable
+        """,
+    )
+    bench.report.append(bench.get_result().to_surface())
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfg.param.theta,
+            ExampleBenchCfg.param.offset,
+            ExampleBenchCfg.param.postprocess_fn,
+            ExampleBenchCfg.param.noise_distribution,
+        ],
+        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
+        const_vars=[
+            (ExampleBenchCfg.param.sigma, 0.1),
+            (ExampleBenchCfg.param.noise_distribution, NoiseDistribution.gaussian),
+            (ExampleBenchCfg.param.noisy, True),
+        ],
+        title="Float 2D with categorical x2 Example",
+        description="""Here we add plot a 2d surface and facet over two categorical variable
+        """,
+    )
+
+    bench.report.append(bench.get_result().to_surface())
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_floats2D(bch.BenchRunCfg(repeats=2, level=3)).report.show()

bencher/example/example_holosweep.py

@@ -0,0 +1,98 @@
+# THIS IS NOT A WORKING EXAMPLE YET
+
+# pylint: disable=duplicate-code,unused-argument
+
+
+import bencher as bch
+import math
+import random
+import numpy as np
+import holoviews as hv
+
+from strenum import StrEnum
+from enum import auto
+
+
+class Function(StrEnum):
+    fn_cos = auto()
+    fn_sin = auto()
+    fn_log = auto()
+    fn_arctan = auto()
+
+    def call(self, arg) -> float:
+        """Calls the function defined by the name of the enum
+
+        Returns:
+            float: The result of calling the function defined by the enum
+        """
+        return getattr(np, self.removeprefix("fn_"))(arg)
+
+
+class PlotFunctions(bch.ParametrizedSweep):
+    phase = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5
+    )
+
+    freq = bch.FloatSweep(default=1, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5)
+
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=10
+    )
+
+    compute_fn = bch.EnumSweep(Function)
+
+    # RESULT VARS
+    fn_output = bch.ResultVar(units="v", doc="sin of theta with some noise")
+    out_sum = bch.ResultVar(units="v", doc="The sum")
+    ref = bch.ResultReference()
+    holomap = bch.ResultHmap()
+
+    def __call__(self, plot=True, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        noise = 0.1
+
+        self.fn_output = self.compute_fn.call(self.phase + self.freq * self.theta) + random.uniform(
+            0, noise
+        )
+
+        self.holomap = self.plot_holo(plot)
+        self.ref = bch.ResultReference(self.ref)
+
+        return self.get_results_values_as_dict()
+
+    def plot_holo(self, plot=True) -> hv.core.ViewableElement:
+        """Plots a generic representation of the object that is not a basic hv datatype. In this case its an image of the values of the object, but it could be any representation of the object, e.g. a screenshot of the object state"""
+        if plot:
+            pt = hv.Text(0, 0, f"{self.phase}\n{self.freq}\n {self.theta}")
+            pt *= hv.Ellipse(0, 0, 1)
+            return pt
+        return None
+
+
+def example_holosweep(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = PlotFunctions().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        input_vars=["theta", "freq"],
+        result_vars=["fn_output", "holomap"],
+    )
+
+    # print("best", res.get_best_trial_params(True))
+    # print(res.hmap_kdims)
+    # bench.report.append(res.describe_sweep())
+    # bench.report.append(res.to_optuna_plots())
+    # bench.report.append(res.get_best_holomap())
+    # bench.report.append(res.to_curve(), "Slider view")
+    # bench.report.append(res.to_holomap())
+
+    # bench.report.append(res.to_holomap().layout())
+    return bench
+
+
+if __name__ == "__main__":
+    PlotFunctions().to_gui()
+    bench_run = bch.BenchRunner("bench_runner_test")
+    bench_run.add_run(example_holosweep)
+    bench_run.run(level=6, show=True, use_cache=False)

bencher/example/example_holosweep_objects.py

@@ -0,0 +1,111 @@
+# THIS IS NOT A WORKING EXAMPLE YET
+
+# pylint: disable=duplicate-code,unused-argument
+
+
+import bencher as bch
+import math
+import random
+import numpy as np
+import holoviews as hv
+
+from strenum import StrEnum
+from enum import auto
+
+
+class Function(StrEnum):
+    fn_cos = auto()
+    fn_sin = auto()
+    fn_log = auto()
+    fn_arctan = auto()
+
+    def call(self, arg) -> float:
+        """Calls the function defined by the name of the enum
+
+        Returns:
+            float: The result of calling the function defined by the enum
+        """
+        return getattr(np, self.removeprefix("fn_"))(arg)
+
+
+class FunctionInputs(bch.ParametrizedSweep):
+    phase = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5
+    )
+
+    freq = bch.FloatSweep(default=1, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5)
+
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=10
+    )
+
+    compute_fn = bch.EnumSweep(Function)
+
+
+class FunctionOutputs(bch.ParametrizedSweep):
+    fn_output = bch.ResultVar(units="v", doc="sin of theta with some noise")
+
+    out_sum = bch.ResultVar(units="v", doc="The sum")
+
+    hmap = bch.ResultHmap()
+
+    hmap2 = bch.ResultHmap()
+
+
+def bench_fn(self, **kwargs) -> dict:
+    fin = FunctionInputs()
+    fin.update_params_from_kwargs(**kwargs)
+
+    output = FunctionOutputs()
+
+    output.fn_output = fin.compute_fn.call(fin.phase + fin.freq * fin.theta) + random.uniform(0, 0)
+    output.hmap = hv.Text(0, 0, f"{fin.phase}\n{fin.freq}\n {fin.theta}")
+    output.hmap2 = hv.Ellipse(0, 0, 1)
+    return output
+
+
+def plot_holo(self, plot=True) -> hv.core.ViewableElement:
+    """Plots a generic representation of the object that is not a basic hv datatype. In this case its an image of the values of the object, but it could be any representation of the object, e.g. a screenshot of the object state"""
+    if plot:
+        pt = hv.Text(0, 0, f"{self.phase}\n{self.freq}\n {self.theta}")
+        pt *= hv.Ellipse(0, 0, 1)
+        return pt
+    return None
+
+
+def example_holosweep(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    # wv = PlotFunctions()
+
+    bench = bch.Bench(
+        "waves", bench_fn, worker_input_cfg=FunctionInputs, run_cfg=run_cfg, report=report
+    )
+
+    res = bench.plot_sweep(
+        "phase",
+        input_vars=[FunctionInputs.param.theta, FunctionInputs.param.freq],
+        result_vars=[
+            FunctionOutputs.param.fn_output,
+            FunctionOutputs.param.hmap,
+            FunctionOutputs.param.hmap2,
+        ],
+    )
+
+    # bench.report.append(res.summarise_sweep())
+    # bench.report.append(res.to_optuna())
+    # bench.report.append(res.get_best_holomap())
+    # bench.report.append(res.to_curve(), "Slider view")
+    # bench.report.append(res.to_holomap().layout())
+    # print(res.to_holomap())
+    bench.report.append(res.to_holomap())
+    # bench.report.append(res.to_holomap())
+
+    return bench
+
+
+if __name__ == "__main__":
+    bench_run = bch.BenchRunner("bench_runner_test", run_cfg=bch.BenchRunCfg())
+
+    bench_run.add_run(example_holosweep)
+    bench_run.run(level=4, show=True)

bencher/example/example_holosweep_tap.py

@@ -0,0 +1,144 @@
+# THIS IS NOT A WORKING EXAMPLE YET
+
+# pylint: disable=duplicate-code,unused-argument
+
+
+import bencher as bch
+import math
+import random
+import numpy as np
+import holoviews as hv
+
+from strenum import StrEnum
+from enum import auto
+
+
+class Function(StrEnum):
+    fn_cos = auto()
+    fn_sin = auto()
+    fn_log = auto()
+    fn_arctan = auto()
+
+    def call(self, arg) -> float:
+        """Calls the function defined by the name of the enum
+
+        Returns:
+            float: The result of calling the function defined by the enum
+        """
+        return getattr(np, self.removeprefix("fn_"))(arg)
+
+
+class PlotFunctions(bch.ParametrizedSweep):
+    phase = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5
+    )
+
+    freq = bch.FloatSweep(default=1, bounds=[0, math.pi], doc="Input angle", units="rad", samples=5)
+
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=10
+    )
+
+    compute_fn = bch.EnumSweep(Function)
+
+    fn_output = bch.ResultVar(units="v", doc="sin of theta with some noise")
+
+    out_sum = bch.ResultVar(units="v", doc="The sum")
+
+    hmap = bch.ResultHmap()
+
+    def __call__(self, plot=True, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        noise = 0.1
+
+        self.fn_output = self.compute_fn.call(self.phase + self.freq * self.theta) + random.uniform(
+            0, noise
+        )
+        self.hmap = self.plot_holo(plot)
+
+        return self.get_results_values_as_dict()
+
+    def plot_holo(self, plot=True) -> hv.core.ViewableElement:
+        """Plots a generic representation of the object that is not a basic hv datatype. In this case its an image of the values of the object, but it could be any representation of the object, e.g. a screenshot of the object state"""
+        if plot:
+            pt = hv.Text(0, 0, f"phase:{self.phase}\nfreq:{self.freq}\ntheta:{self.theta}")
+            pt *= hv.Ellipse(0, 0, 1)
+            return pt
+        return None
+
+    def calc_vec(self, **kwargs) -> dict:
+        theta = self.param.theta.values()
+        kwargs.pop("theta", 0)
+        dat = [self.__call__(plot=False, theta=i, **kwargs)["fn_output"] for i in theta]
+        # print(dat)
+        self.out_sum = sum(dat)
+        self.hmap = hv.Curve((theta, dat), "theta", "voltage")
+        # pt = hv.Text(0, 0, f"{self.compute_fn}\n{self.phase}\n{self.freq}")
+        # pt *= hv.Ellipse(0, 0, 1)
+        return self.get_results_values_as_dict()
+
+
+def example_holosweep_tap(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    wv = PlotFunctions()
+
+    run_cfg.use_optuna = True
+    run_cfg.auto_plot = False
+    bench = bch.Bench("waves", wv, run_cfg=run_cfg, report=report)
+
+    res = bench.plot_sweep(
+        "phase",
+        input_vars=[PlotFunctions.param.theta, PlotFunctions.param.freq],
+        result_vars=[PlotFunctions.param.fn_output, PlotFunctions.param.hmap],
+        run_cfg=run_cfg,
+    )
+
+    bench.report.append(res.describe_sweep())
+    bench.report.append(res.to_heatmap_tap(PlotFunctions.param.fn_output))
+
+    return bench
+
+
+def example_holosweep_tap_slider(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:  # pragma: no cover
+    wv = PlotFunctions()
+
+    run_cfg.use_optuna = True
+    bench = bch.Bench("waves", wv, run_cfg=run_cfg, report=report)
+
+    res = bench.plot_sweep(
+        "phase",
+        input_vars=[PlotFunctions.param.theta, PlotFunctions.param.freq, PlotFunctions.param.phase],
+        result_vars=[PlotFunctions.param.fn_output],
+        run_cfg=run_cfg,
+    )
+
+    print(res.get_best_trial_params())
+    bench.report.append(res.get_best_holomap())
+
+    heatmap = res.to_heatmap().opts(tools=["hover", "tap"])
+    posxy = hv.streams.Tap(source=heatmap, x=0, y=0)
+    sld1 = wv.param.phase.as_slider()
+
+    def tap_plot(x, y):
+        print(x, y)
+        selres = bch.get_nearest_coords(res.ds, theta=x, freq=y, phase=sld1.value, repeat=1)
+        return res.hmaps[bch.hmap_canonical_input(selres)]
+
+    tap_dmap = hv.DynamicMap(tap_plot, streams=[posxy])
+
+    bench.report.append_tab(heatmap + tap_dmap, "Interactive Heatmap")
+    bench.report.append(sld1)
+
+    bench.report.append_tab(res.to_curve(), "Slider view")
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_holosweep_tap(bch.BenchRunCfg()).report.show()
+
+
+# todo  https://discourse.holoviz.org/t/pointdraw-as-parameterized-class/3539

bencher/example/example_image.py

@@ -0,0 +1,155 @@
+import bencher as bch
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+
+
+def polygon_points(radius: float, sides: int, start_angle: float):
+    points = []
+    for ang in np.linspace(0, 360, sides + 1):
+        angle = math.radians(start_angle + ang)
+        points.append(([math.sin(angle) * radius, math.cos(angle) * radius]))
+    return points
+
+
+class BenchPolygons(bch.ParametrizedSweep):
+    sides = bch.IntSweep(default=3, bounds=(3, 7))
+    radius = bch.FloatSweep(default=1, bounds=(0.2, 1))
+    linewidth = bch.FloatSweep(default=1, bounds=(1, 10))
+    linestyle = bch.StringSweep(["solid", "dashed", "dotted"])
+    color = bch.StringSweep(["red", "green", "blue"])
+    start_angle = bch.FloatSweep(default=0, bounds=[0, 360])
+    polygon = bch.ResultImage()
+    area = bch.ResultVar()
+    side_length = bch.ResultVar()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        points = polygon_points(self.radius, self.sides, self.start_angle)
+        # self.hmap = hv.Curve(points)
+        self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"))
+
+        self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
+        self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
+        return super().__call__()
+
+    def points_to_polygon_png(self, points: list[float], filename: str):
+        """Draw a closed polygon and save to png"""
+        fig = plt.figure(frameon=False)
+        ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0], frameon=False)
+        ax.set_axis_off()
+        ax.plot(
+            [p[0] for p in points],
+            [p[1] for p in points],
+            linewidth=self.linewidth,
+            linestyle=self.linestyle,
+            color=self.color,
+        )
+        ax.set_xlim(-1, 1)
+        ax.set_ylim(-1, 1)
+
+        ax.set_aspect("equal")
+        fig.add_axes(ax)
+        fig.savefig(filename, dpi=30)
+
+        return filename
+
+
+def example_image(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    run_cfg.use_cache = False
+    bench = bch.Bench("polygons", BenchPolygons(), run_cfg=run_cfg, report=report)
+
+    bench.result_vars = ["polygon", "area"]
+
+    bench.add_plot_callback(bch.BenchResult.to_sweep_summary)
+    # bench.add_plot_callback(bch.BenchResult.to_auto, level=2)
+    bench.add_plot_callback(bch.BenchResult.to_panes, level=3)
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+
+    sweep_vars = ["sides", "radius", "linewidth", "color"]
+
+    # sweep_vars = ["sides", "radius" ]
+
+    for i in range(1, len(sweep_vars)):
+        s = sweep_vars[:i]
+        bench.plot_sweep(
+            f"Polygons Sweeping {len(s)} Parameters",
+            input_vars=s,
+        )
+        bench.report.append(bench.get_result().to_panes())
+
+    return bench
+
+
+def example_image_vid(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchPolygons().to_bench(run_cfg, report)
+    bench.add_plot_callback(bch.BenchResult.to_sweep_summary)
+    bench.add_plot_callback(
+        bch.BenchResult.to_video_grid,
+        target_duration=0.06,
+        compose_method_list=[
+            bch.ComposeType.right,
+            bch.ComposeType.right,
+            bch.ComposeType.sequence,
+        ],
+    )
+    # from functools import partial
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=0)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=2)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=3)
+
+    bench.plot_sweep(input_vars=["radius"])
+    # res = bench.plot_sweep(input_vars=["radius"], plot=False)
+    # bench.report.append(res.to_video_grid(target_duration=0.06))
+    bench.plot_sweep(input_vars=["radius", "sides"])
+    # bench.plot_sweep(input_vars=["radius", "sides", "linewidth"])
+    # bench.plot_sweep(input_vars=["radius", "sides", "linewidth", "color"])
+
+    return bench
+
+
+if __name__ == "__main__":
+
+    def simple():
+        bench = BenchPolygons().to_bench(bch.BenchRunCfg(level=4))
+
+        # bench.plot_sweep(input_vars=["sides","color","radius"])
+
+        # res = bench.sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_heatmap(target_dimension=3))
+
+        bench.plot_sweep(input_vars=["sides"])
+        bench.plot_sweep(input_vars=["sides", "color"])
+
+        bench.plot_sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_line(target_dimension=1))
+
+        return bench
+
+    def example_image_vid_sequential(
+        run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+    ) -> bch.Bench:
+        bench = BenchPolygons().to_bench(run_cfg, report)
+        bench.add_plot_callback(bch.BenchResult.to_title)
+        bench.add_plot_callback(bch.BenchResult.to_video_grid)
+        bench.sweep_sequential(input_vars=["radius", "sides", "linewidth", "color"], group_size=4)
+        return bench
+
+    # def example_image_pairs()
+
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.use_sample_cache = True
+    # ex_run_cfg.debug = True
+    # ex_run_cfg.repeats = 2
+    ex_run_cfg.level = 4
+    example_image_vid(ex_run_cfg).report.show()
+    # simple().report.show()
+
+    # example_image_vid_sequential(ex_run_cfg).report.show()
+    # example_image(ex_run_cfg).report.show()