holobench 1.3.6__py2.py3-none-any.whl

bencher/example/example_floats.py

@@ -0,0 +1,89 @@
+# 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 ExampleBenchCfgIn, ExampleBenchCfgOut, ExampleBenchCfg
+
+
+def example_floats(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a parameter sweep for floating point variables
+
+    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", ExampleBenchCfg(), report=report, run_cfg=run_cfg)
+
+    with open("README.md", "r", encoding="utf-8") as file:
+        readme = file.read()
+
+    bench.report.append(readme, "Intro")
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Float 1D 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.
+
+        def bench_function(cfg: ExampleBenchCfgIn) -> ExampleBenchCfgOut:
+            "Takes an ExampleBenchCfgIn and returns a ExampleBenchCfgOut output"
+            out = ExampleBenchCfgOut()
+            noise = calculate_noise(cfg)
+            offset = 0.0
+
+            postprocess_fn = abs if cfg.postprocess_fn == PostprocessFn.absolute else negate_fn
+
+            out.out_sin = postprocess_fn(offset + math.sin(cfg.theta) + noise)
+            out.out_cos = postprocess_fn(offset + math.cos(cfg.theta) + noise)
+            return out
+
+    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.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.noisy],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Float 1D and Bool Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We pass the boolean  'noisy' and keep the other parameters the same""",
+        post_description="Now the plot has two lines, one for each of the boolean values where noisy=true and noisy=false.",
+    )
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.noisy],
+        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
+        title="Float 1D and Bool Example with multiple outputs",
+        description="""Following from the previous example here the second output is added to the result variables""",
+        post_description="Another column is added for the result variable that shows cos(theta)",
+    )
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.theta,
+            ExampleBenchCfgIn.param.noisy,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        result_vars=[
+            ExampleBenchCfgOut.param.out_sin,
+            ExampleBenchCfgOut.param.out_cos,
+        ],
+        title="Float 1D, Bool and Categorical Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We add the 'postprocess_fn' categorical enum value which either takes the absolute value or negates the output of the function.""",
+        post_description="This generates two rows of results, one for each of the category options.",
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    bench_ex = example_floats(bch.BenchRunCfg(repeats=2))
+    bench_ex.report.save_index()
+    bench_ex.report.show()

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,104 @@
+# 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.ResultReference()
+    hmap1 = 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.hmap1 = self.plot_holo(plot)
+        self.hmap = bch.ResultReference(self.hmap1)
+
+        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:
+    wv = PlotFunctions()
+
+    # run_cfg.use_optuna = True
+
+    bench = bch.Bench("waves", wv, run_cfg=run_cfg, report=report)
+
+    bench.plot_sweep(
+        "phase",
+        input_vars=[PlotFunctions.param.theta, PlotFunctions.param.freq],
+        result_vars=[PlotFunctions.param.fn_output, PlotFunctions.param.hmap],
+        # result_vars=[PlotFunctions.param.hmap],
+    )
+
+    # 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__":
+    bench_run = bch.BenchRunner("bench_runner_test")
+    bench_run.add_run(example_holosweep)
+    bench_run.run(level=3, 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(run_cfg.debug)
+
+    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,82 @@
+import bencher as bch
+import numpy as np
+import math
+import holoviews as hv
+import matplotlib.pyplot as plt
+
+
+def polygon_points(radius: float, sides: int):
+    points = []
+    for ang in np.linspace(0, math.pi * 2, sides + 1):
+        points.append(([math.sin(ang) * radius, math.cos(ang) * radius]))
+    return points
+
+
+class BenchPolygons(bch.ParametrizedSweep):
+    sides = bch.IntSweep(default=3, bounds=(3, 5))
+    radius = bch.FloatSweep(default=1, bounds=(1, 2))
+    linewidth = bch.FloatSweep(default=1, bounds=(1, 10))
+    linestyle = bch.StringSweep(["solid", "dashed", "dotted"])
+    color = bch.StringSweep(["red", "green", "blue"])
+    polygon = bch.ResultImage()
+    hmap = bch.ResultHmap()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        points = polygon_points(self.radius, self.sides)
+        self.hmap = hv.Curve(points)
+        self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"))
+        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_aspect("equal")
+        fig.add_axes(ax)
+        fig.savefig(filename, dpi=50)
+        return filename
+
+
+def example_image(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = bch.Bench("polygons", BenchPolygons(), run_cfg=run_cfg, report=report)
+
+    for s in [
+        [BenchPolygons.param.sides],
+        [BenchPolygons.param.sides, BenchPolygons.param.linewidth],
+        [BenchPolygons.param.sides, BenchPolygons.param.linewidth, BenchPolygons.param.linestyle],
+        [
+            BenchPolygons.param.sides,
+            BenchPolygons.param.linewidth,
+            BenchPolygons.param.linestyle,
+            BenchPolygons.param.color,
+        ],
+        [
+            BenchPolygons.param.sides,
+            BenchPolygons.param.linewidth,
+            BenchPolygons.param.linestyle,
+            BenchPolygons.param.color,
+            BenchPolygons.param.radius,
+        ],
+    ]:
+        bench.plot_sweep(
+            f"Polygons Sweeping {len(s)} Parameters",
+            input_vars=s,
+            result_vars=[BenchPolygons.param.polygon],
+        )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_image(bch.BenchRunCfg(level=2)).report.show()