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

bencher/example/example_simple_cat.py

@@ -0,0 +1,48 @@
+"""This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
+# 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, bench_function
+
+
+def example_1D_cat(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional categorical variable and plot the result of passing that parameter sweep to the benchmarking function
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    explorer = ExampleBenchCfgIn()
+    bench = bch.Bench(
+        "benchmarking_example_categorical1D",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
+    bench.plot_sweep(
+        title="Example 1D Categorical",
+        description="""This example shows how to sample a 1 dimensional categorical variable and plot the result of passing that parameter sweep to the benchmarking function""",
+        input_vars=[ExampleBenchCfgIn.param.postprocess_fn],
+        result_vars=[ExampleBenchCfgOut.param.out_cos, ExampleBenchCfgOut.param.out_sin],
+        const_vars=explorer.get_input_defaults(),
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.repeats = 10
+
+    srv1 = example_1D_cat(ex_run_cfg).report.show()

bencher/example/example_simple_float.py

@@ -0,0 +1,28 @@
+"""This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
+import math
+import bencher as bch
+
+
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta)
+        return super().__call__(**kwargs)
+
+
+def example_1D_float(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    bench.plot_sweep()
+    return bench
+
+
+if __name__ == "__main__":
+    example_1D_float().report.show()

bencher/example/example_simple_float2d.py

@@ -0,0 +1,29 @@
+"""This file contains examples for how to perform basic 2D benchmarking parameter sweeps"""
+
+import math
+import bencher as bch
+
+
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    offset = bch.FloatSweep(default=0, bounds=[0, 1], doc="Input angle", units="rad")
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta) + self.offset
+        return super().__call__(**kwargs)
+
+
+def example_2D_float(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    bench.plot_sweep()
+    return bench
+
+
+if __name__ == "__main__":
+    example_2D_float().report.show()

bencher/example/example_strings.py

@@ -0,0 +1,47 @@
+import bencher as bch
+
+
+class TestPrinting(bch.ParametrizedSweep):
+    # INPUTS
+    a = bch.StringSweep(default=None, string_list=["a1", "a2"], allow_None=True)
+    b = bch.StringSweep(default=None, string_list=["b1", "b2"], allow_None=True)
+    c = bch.StringSweep(default=None, string_list=["c1", "c2"], allow_None=True)
+    d = bch.StringSweep(default=None, string_list=["d1", "d2"], allow_None=True)
+
+    # RESULTS
+    result = bch.ResultString()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        self.result = self.a
+        if self.b is not None:
+            self.result += f",{self.b}"
+        if self.c is not None:
+            self.result += f",{self.c}"
+        if self.d is not None:
+            self.result += f",{self.d}"
+        self.result += "\n\ttab\n\t\ttab2"
+
+        self.result = bch.tabs_in_markdown(self.result)
+        return super().__call__()
+
+
+def example_strings(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = bch.Bench("strings", TestPrinting(), run_cfg=run_cfg, report=report)
+
+    for s in [
+        [TestPrinting.param.a],
+        [TestPrinting.param.a, TestPrinting.param.b],
+        [TestPrinting.param.a, TestPrinting.param.b, TestPrinting.param.c],
+        [TestPrinting.param.a, TestPrinting.param.b, TestPrinting.param.c, TestPrinting.param.d],
+    ]:
+        bench.plot_sweep(f"String Panes {[v.name for v in s]}", input_vars=s)
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_strings().report.show()

bencher/example/example_time_event.py

@@ -0,0 +1,63 @@
+"""This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
+# 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, bench_function
+
+
+def example_time_event(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """This example shows how to manually set time events as a string so that progress can be monitored over time"""
+
+    bencher = bch.Bench(
+        "benchmarking_example_categorical1D",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    ExampleBenchCfgIn.param.offset.bounds = [0, 100]
+
+    # manually override the default value based on the time event string so that the graphs are not all just straight lines
+    ExampleBenchCfgIn.param.offset.default = int(str(hash(run_cfg.time_event))[-1])
+
+    # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
+    bencher.plot_sweep(
+        title="Example 1D Categorical",
+        input_vars=[ExampleBenchCfgIn.param.postprocess_fn],
+        result_vars=[ExampleBenchCfgOut.param.out_cos],
+        description=example_time_event.__doc__,
+        run_cfg=run_cfg,
+    )
+    return bencher
+
+
+def run_example_time_event(ex_run_cfg):
+    ex_run_cfg.repeats = 1
+    ex_run_cfg.print_pandas = True
+    ex_run_cfg.over_time = True
+
+    ex_run_cfg.clear_cache = True
+    ex_run_cfg.clear_history = True
+
+    ex_run_cfg.time_event = "-first_event"
+    example_time_event(ex_run_cfg)
+
+    ex_run_cfg.clear_cache = False
+    ex_run_cfg.clear_history = False
+    ex_run_cfg.time_event = "_second_event"
+    example_time_event(ex_run_cfg)
+
+    ex_run_cfg.time_event = (
+        "*third_event has a very very long label to demonstrate automatic text wrapping"
+    )
+    return example_time_event(ex_run_cfg)
+
+
+if __name__ == "__main__":
+    run_example_time_event(bch.BenchRunCfg()).report.show()

bencher/example/example_video.py

@@ -0,0 +1,118 @@
+import bencher as bch
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+# code from https://ipython-books.github.io/124-simulating-a-partial-differential-equation-reaction-diffusion-systems-and-turing-patterns/
+class TuringPattern(bch.ParametrizedSweep):
+    alpha = bch.FloatSweep(default=2.8e-4, bounds=(2e-4, 5e-3))
+    beta = bch.FloatSweep(default=5e-3, bounds=(1e-3, 9e-3))
+    tau = bch.FloatSweep(default=0.1, bounds=(0.01, 0.5))
+    k = bch.FloatSweep(default=-0.005, bounds=(-0.01, 0.01))
+
+    size = bch.IntSweep(default=30, bounds=(30, 200), doc="size of the 2D grid")
+    time = bch.FloatSweep(default=20.0, bounds=(1, 100), doc="total time of simulation")
+    dt = bch.FloatSweep(default=0.001, doc="simulation time step")
+
+    video = bch.ResultVideo()
+    score = bch.ResultVar()
+    img = bch.ResultImage()
+
+    def laplacian(self, Z, dx):
+        Ztop = Z[0:-2, 1:-1]
+        Zleft = Z[1:-1, 0:-2]
+        Zbottom = Z[2:, 1:-1]
+        Zright = Z[1:-1, 2:]
+        Zcenter = Z[1:-1, 1:-1]
+        return (Ztop + Zleft + Zbottom + Zright - 4 * Zcenter) / dx**2
+
+    def update(self, U, V, dx):
+        # We compute the Laplacian of u and v.
+        deltaU = self.laplacian(U, dx)
+        deltaV = self.laplacian(V, dx)
+        # We take the values of u and v inside the grid.
+        Uc = U[1:-1, 1:-1]
+        Vc = V[1:-1, 1:-1]
+        # We update the variables.
+        U[1:-1, 1:-1], V[1:-1, 1:-1] = (
+            Uc + self.dt * (self.alpha * deltaU + Uc - Uc**3 - Vc + self.k),
+            Vc + self.dt * (self.beta * deltaV + Uc - Vc) / self.tau,
+        )
+        # Neumann conditions: derivatives at the edges
+        # are null.
+        for Z in (U, V):
+            Z[0, :] = Z[1, :]
+            Z[-1, :] = Z[-2, :]
+            Z[:, 0] = Z[:, 1]
+            Z[:, -1] = Z[:, -2]
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        n = int(self.time / self.dt)  # number of iterations
+        dx = 2.0 / self.size  # space step
+
+        U = np.random.rand(self.size, self.size)
+        V = np.random.rand(self.size, self.size)
+
+        fig, ax = plt.subplots(frameon=False, figsize=(2, 2))
+        fig.set_tight_layout(True)
+        ax.set_axis_off()
+        vid_writer = bch.VideoWriter()
+        for i in range(n):
+            self.update(U, V, dx)
+            if i % 500 == 0:
+                ax.imshow(U)
+                fig.canvas.draw()
+                rgb = np.array(fig.canvas.renderer.buffer_rgba())
+                vid_writer.append(rgb)
+
+        self.img = bch.add_image(rgb)
+
+        self.video = vid_writer.write()
+
+        self.score = self.alpha + self.beta
+        return super().__call__()
+
+
+def example_video(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    # run_cfg.auto_plot = False
+    # run_cfg.use_sample_cache = True
+    bench = bch.Bench("example_video", TuringPattern(), run_cfg=run_cfg, report=report)
+
+    bench.plot_sweep(
+        "Turing patterns with different parameters",
+        input_vars=[TuringPattern.param.alpha, TuringPattern.param.beta],
+        # input_vars=[TuringPattern.param.alpha],
+        result_vars=[TuringPattern.param.video],
+    )
+
+    return bench
+
+
+def example_video_tap(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:  # pragma: no cover
+    bench = TuringPattern().to_bench(run_cfg=run_cfg, report=report)
+    res = bench.plot_sweep(
+        input_vars=["alpha", "beta"],
+        # result_vars=["video","score"],
+        # result_vars=["score"],
+        run_cfg=run_cfg,
+    )
+
+    bench.report.append(res.to_video_grid())
+
+    return bench
+
+
+if __name__ == "__main__":
+    run_cfg_ex = bch.BenchRunCfg()
+    run_cfg_ex.level = 2
+    run_cfg_ex.use_sample_cache = True
+    run_cfg_ex.only_hash_tag = True
+
+    # example_video(run_cfg_ex).report.show()
+    example_video_tap(run_cfg_ex).report.show()

bencher/example/example_workflow.py

@@ -0,0 +1,189 @@
+# pylint: disable=duplicate-code
+
+
+import numpy as np
+
+import bencher as bch
+
+
+class VolumeSample(bch.ParametrizedSweep):
+    """A class to represent a 3D point in space."""
+
+    x = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="x coordinate of the sample volume", samples=9
+    )
+    y = bch.FloatSweep(
+        default=0, bounds=[-2.0, 2.0], doc="y coordinate of the sample volume", samples=10
+    )
+    z = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=11
+    )
+
+    surf_x = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=9
+    )
+
+    surf_y = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=11
+    )
+
+
+class VolumeResult(bch.ParametrizedSweep):
+    """A class to represent the properties of a volume sample."""
+
+    # value = bch.ResultVar("ul", doc="The scalar value of the 3D volume field")
+    p1_dis = bch.ResultVar("m", direction=bch.OptDir.minimize, doc="The distance to p1")
+    p2_dis = bch.ResultVar("m", direction=bch.OptDir.minimize, doc="The distance to p2")
+    total_dis = bch.ResultVar(
+        "m", direction=bch.OptDir.minimize, doc="The total distance to all points"
+    )
+    surf_value = bch.ResultVar(
+        "ul", direction=bch.OptDir.maximize, doc="The scalar value of the 3D volume field"
+    )
+    # occupancy = bch.ResultVar("occupied", doc="If the value is > 0.5 this point is considered occupied")
+
+
+p1 = np.array([0.4, 0.6, 0.0])
+p2 = np.array([-0.8, -0.2, 0.0])
+surf_x_max = 0.5
+surf_y_max = -0.2
+
+
+def bench_fn(point: VolumeSample) -> VolumeResult:
+    """This function takes a 3D point as input and returns distance of that point to the origin.
+
+    Args:
+        point (VolumeSample): Sample point
+
+    Returns:
+        VolumeResult: Value at that point
+    """
+
+    cur_point = np.array([point.x, point.y, point.z])
+
+    output = VolumeResult()
+    output.p1_dis = np.linalg.norm(p1 - cur_point)
+    output.p2_dis = np.linalg.norm(p2 - cur_point)
+    output.total_dis = output.p1_dis + output.p2_dis
+
+    output.surf_value = output.total_dis + np.linalg.norm(
+        np.array(
+            [np.cos(point.surf_x - surf_x_max), 2 * np.cos(point.surf_y - surf_y_max), point.z]
+        )
+    )
+
+    return output
+
+
+def example_floats2D_workflow(run_cfg: bch.BenchRunCfg, bench: bch.Bench = None) -> bch.Bench:
+    """Example of how to perform a 3D floating point parameter sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+    if bench is None:
+        bench = bch.Bench("Bencher_Example_Floats", bench_fn, VolumeSample)
+
+    # run_cfg.debug = False
+
+    res = bench.plot_sweep(
+        input_vars=[VolumeSample.param.x, VolumeSample.param.y],
+        result_vars=[
+            VolumeResult.param.total_dis,
+            VolumeResult.param.p1_dis,
+            VolumeResult.param.p2_dis,
+        ],
+        const_vars=[VolumeSample.param.z.with_const(0)],
+        title="Float 2D Example",
+        run_cfg=run_cfg,
+    )
+    recovered_p1 = res.get_optimal_vec(VolumeResult.param.p1_dis, res.bench_cfg.input_vars)
+    print(f"recovered p1: {recovered_p1}, distance: {np.linalg.norm(recovered_p1 - p1[:2])}")
+    # within tolerance of sampling
+    # assert np.linalg.norm(recovered_p1 - p1[:2]) < 0.15
+
+    recovered_p2 = res.get_optimal_vec(VolumeResult.param.p2_dis, res.bench_cfg.input_vars)
+    print(f"recovered p2: {recovered_p2} distance: {np.linalg.norm(recovered_p2 - p2[:2])}")
+    # within tolerance of sampling
+    # assert np.linalg.norm(recovered_p2 - p2[:2]) < 0.15
+
+    run_cfg.use_optuna = True
+    for rv in res.bench_cfg.result_vars:
+        bench.plot_sweep(
+            input_vars=[VolumeSample.param.surf_x, VolumeSample.param.surf_y],
+            result_vars=[
+                VolumeResult.param.surf_value,
+            ],
+            const_vars=res.get_optimal_inputs(rv, True),
+            title=f"Slice of 5D space for {rv.name}",
+            description="""This example shows how to sample 3 floating point variables and plot a 3D vector field of the results.""",
+            run_cfg=run_cfg,
+        )
+
+    return bench
+
+
+def example_floats3D_workflow(run_cfg: bch.BenchRunCfg, bench: bch.Bench = None) -> bch.Bench:
+    """Example of how to perform a 3D floating point parameter sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+    if bench is None:
+        bench = bch.Bench("Bencher_Example_Floats", bench_fn, VolumeSample)
+
+    # run_cfg.debug = False
+
+    res = bench.plot_sweep(
+        input_vars=[VolumeSample.param.x, VolumeSample.param.y, VolumeSample.param.z],
+        result_vars=[
+            VolumeResult.param.total_dis,
+            VolumeResult.param.p1_dis,
+            VolumeResult.param.p2_dis,
+            # get_optimal_inputsm.occupancy,
+        ],
+        title="Float 3D Example",
+        description="""This example shows how to sample 3 floating point variables and plot a volumetric representation of the results.  The benchmark function returns the distance to the origin""",
+        post_description="Here you can see concentric shells as the value of the function increases with distance from the origin. The occupancy graph should show a sphere with radius=0.5",
+        run_cfg=run_cfg,
+    )
+
+    recovered_p1 = res.get_optimal_vec(VolumeResult.param.p1_dis, res.bench_cfg.input_vars)
+    print(f"recovered p1: {recovered_p1}, distance: {np.linalg.norm(recovered_p1 - p1)}")
+    # within tolerance of sampling
+    # assert np.linalg.norm(recovered_p1 - p1) < 0.15
+
+    recovered_p2 = res.get_optimal_vec(VolumeResult.param.p2_dis, res.bench_cfg.input_vars)
+    print(f"recovered p2: {recovered_p2} distance: {np.linalg.norm(recovered_p2 - p2)}")
+    # within tolerance of sampling
+    # assert np.linalg.norm(recovered_p2 - p2) < 0.15
+
+    run_cfg.use_optuna = True
+    for rv in res.bench_cfg.result_vars:
+        bench.plot_sweep(
+            input_vars=[VolumeSample.param.surf_x, VolumeSample.param.surf_y],
+            result_vars=[
+                VolumeResult.param.surf_value,
+            ],
+            const_vars=res.get_optimal_inputs(rv, True),
+            title=f"Slice of 5D space for {rv.name}",
+            description="""This example shows how to sample 3 floating point variables and plot a 3D vector field of the results.""",
+            run_cfg=run_cfg,
+        )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+
+    bench_ex = example_floats2D_workflow(ex_run_cfg)
+    example_floats3D_workflow(ex_run_cfg, bench_ex)
+
+    bench_ex.report.show()

bencher/example/experimental/example_bokeh_plotly.py

@@ -0,0 +1,38 @@
+import holoviews as hv
+import numpy as np
+import panel as pn
+
+# hv.extension("bokeh", "plotly")
+backend1 = "plotly"
+# backend1 = "matplotlib"
+backend2 = "bokeh"
+
+# matplotlib.use("agg")
+
+# hv.extension(backend1, backend2)
+hv.extension(backend2, backend1)
+
+# hv.extension(backend1)
+
+# opts.defaults(opts.Surface(backend=backend1), opts.HeatMap(backend=backend2))
+
+# hv.output(opts.Surface(backend=backend1), opts.HeatMap(backend=backend2))
+# hv.output(surface.opts(fig_size=200, backend='matplotlib'), backend='matplotlib')
+
+main = pn.Row()
+
+# hv.output(backend="plotly")
+
+dat = np.ones([10, 10])
+# main.append(hv.Surface(dat))
+
+surf = hv.Surface(dat)
+main.append(hv.render(surf, backend=backend1))
+
+
+# hv.output(backend="bokeh")
+heat = hv.HeatMap(dat)
+heat *= hv.Text(0, 0, "I only work with bokeh and matplotlib")
+main.append(heat)
+
+main.show()

bencher/example/experimental/example_hover_ex.py

@@ -0,0 +1,45 @@
+# pylint: skip-file  #this is experimental still
+
+
+from bokeh.models import HoverTool
+import pandas as pd
+from hvplot import pandas  # noqa
+import holoviews as hv
+import panel as pn
+
+datadict = dict(
+    x=[1, 5],
+    y=[4, 10],
+    img=[
+        "https://raw.githubusercontent.com/holoviz/panel/master/doc/_static/logo_horizontal.png",
+        "https://raw.githubusercontent.com/holoviz/panel/master/doc/_static/logo_stacked.png",
+    ],
+)
+
+
+hover = HoverTool(
+    tooltips="""
+    <div>
+        <div>
+            <img src="@img" width=100 style="float: left; margin: 0px 15px 15px 0px; border="2"></img>
+        <div>
+            <span style="font-size: 15px;">Location</span>
+            <span style="font-size: 10px; color: #696;">(@x, @y)</span>
+        </div>
+    </div>
+
+"""
+)
+
+df_test = pd.DataFrame.from_dict(datadict)
+
+
+hvds = hv.Dataset(df_test)
+
+pt = hv.Scatter(hvds, kdims=["x"], vdims=["y"], hover_cols=["img"], tools=[hover])
+
+pn.Row(pt).show()
+
+# pt =df_test.hvplot.scatter(x="x", y="y", hover_cols=["img"], tools=[hover])
+
+# pt.show()

bencher/example/experimental/example_hvplot_explorer.py

@@ -0,0 +1,39 @@
+# THIS IS NOT A WORKING EXAMPLE YET
+# pylint: disable=duplicate-code
+import hvplot
+import bencher as bch
+from bencher import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
+
+bench = bch.Bench("Bencher_Example_Simple", bench_function, ExampleBenchCfgIn)
+
+
+if __name__ == "__main__":
+    bench_out = bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.offset],
+        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
+        """,
+        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",
+        run_cfg=bch.BenchRunCfg(
+            auto_plot=True,
+            use_cache=False,
+            repeats=2,
+        ),
+    )
+
+    hvexplorer = hvplot.explorer(bench_out.get_dataframe())
+    hvexplorer.show()