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

bencher/example/benchmark_data.py

@@ -0,0 +1,196 @@
+"""This file contains an example of how to define benchmarking parameters sweeps. Categorical values are defined as enums and passed to EnumSweep classes, other types of sweeps are defined by their respective classes.
+
+You can define a subclass which contains an input configuration which can be passed to a function in a type safe way. You can combine the subclass with a higher level class which contains more configuation parameters.  This is to help manage the complexity of large configuration/parameter spaces. 
+"""
+
+import math
+import random
+from enum import auto
+from strenum import StrEnum
+from bencher.variables.inputs import IntSweep, FloatSweep, StringSweep, EnumSweep, BoolSweep
+from bencher.variables.results import ResultVar, OptDir
+from bencher.variables.parametrised_sweep import ParametrizedSweep
+
+
+class PostprocessFn(StrEnum):
+    """Apply a postprocessing step to the data"""
+
+    absolute = auto()  # return the abs of the output data
+    negate = auto()  # return the negative of the output data
+
+
+class NoiseDistribution(StrEnum):
+    """A categorical variable describing the types of random noise"""
+
+    uniform = auto()  # uniform random noiase
+    gaussian = auto()  # gaussian noise
+    lognorm = auto()  # lognorm noise
+
+
+class NoiseCfg(ParametrizedSweep):
+    """A class for storing the parameters for generating various types of noise"""
+
+    noisy = BoolSweep(
+        default=False, doc="Optionally add random noise to the output of the function"
+    )
+
+    noise_distribution = EnumSweep(NoiseDistribution, doc=NoiseDistribution.__doc__)
+
+    sigma = FloatSweep(
+        default=1,
+        bounds=[0, 10],
+        doc="The standard deviation of the noise",
+        units="v",
+    )
+
+
+def calculate_noise(config: NoiseCfg) -> float:
+    """Generate a float value based on a noise distribution and scale
+
+    Args:
+        config (NoiseCfg): see NoiseCfg type
+
+    Returns:
+        float: a noisy float value
+    """
+
+    noise = 0.0
+    if config.noisy:
+        match config.noise_distribution:
+            case NoiseDistribution.uniform:
+                noise = random.uniform(0, config.sigma)
+            case NoiseDistribution.gaussian:
+                noise = random.gauss(0, config.sigma)
+            case NoiseDistribution.lognorm:
+                noise = random.lognormvariate(0, config.sigma)
+
+    return noise
+
+
+class ExampleBenchCfgIn(NoiseCfg):
+    """A class for representing a set of configuration options for the example worker. This class inherits from NoiseCfg so it also stores all its values as well."""
+
+    theta = FloatSweep(default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30)
+    offset = FloatSweep(default=0, bounds=[0, 0.3], doc="dc offset", units="v", samples=30)
+    postprocess_fn = EnumSweep(PostprocessFn)
+
+
+class ExampleBenchCfgOut(ParametrizedSweep):
+    out_sin = ResultVar(units="v", direction=OptDir.minimize, doc="sin of theta with some noise")
+    out_cos = ResultVar(units="v", direction=OptDir.minimize, doc="cos of theta with some noise")
+    out_bool = ResultVar(units="%", doc="sin > 0.5")
+
+
+def negate_fn(fn_input: float):
+    """returns the negative of the input
+
+    Args:
+        fn_input (float): any float value
+
+    Returns:
+        float: negative of the input
+    """
+    return -fn_input
+
+
+def bench_function(cfg: ExampleBenchCfgIn) -> ExampleBenchCfgOut:
+    """Takes an ExampleBenchCfgIn and returns a ExampleBenchCfgOut output"""
+    out = ExampleBenchCfgOut()
+    noise = calculate_noise(cfg)
+
+    postprocess_fn = abs if cfg.postprocess_fn == PostprocessFn.absolute else negate_fn
+
+    out.out_sin = postprocess_fn(cfg.offset + math.sin(cfg.theta) + noise)
+    out.out_cos = postprocess_fn(cfg.offset + math.cos(cfg.theta) + noise)
+
+    out.out_bool = out.out_sin > 0.5
+    return out
+
+
+class ExampleBenchCfg(ParametrizedSweep):
+    theta = FloatSweep(default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30)
+    offset = FloatSweep(default=0, bounds=[0, 0.3], doc="dc offset", units="v", samples=30)
+    postprocess_fn = EnumSweep(PostprocessFn)
+
+    noisy = BoolSweep(
+        default=False, doc="Optionally add random noise to the output of the function"
+    )
+    noise_distribution = EnumSweep(NoiseDistribution, doc=NoiseDistribution.__doc__)
+    sigma = FloatSweep(
+        default=1,
+        bounds=[0, 10],
+        doc="The standard deviation of the noise",
+        units="v",
+    )
+
+    out_sin = ResultVar(units="v", direction=OptDir.minimize, doc="sin of theta with some noise")
+    out_cos = ResultVar(units="v", direction=OptDir.minimize, doc="cos of theta with some noise")
+    out_bool = ResultVar(units="%", doc="sin > 0.5")
+
+    def __call__(self, **kwwargs) -> dict:
+        self.update_params_from_kwargs(**kwwargs)
+
+        noise = self.calculate_noise()
+        postprocess_fn = abs if self.postprocess_fn == PostprocessFn.absolute else negate_fn
+
+        self.out_sin = postprocess_fn(self.offset + math.sin(self.theta) + noise)
+        self.out_cos = postprocess_fn(self.offset + math.cos(self.theta) + noise)
+        self.out_bool = self.out_sin > 0.5
+        return self.get_results_values_as_dict()
+
+    def calculate_noise(self):
+        noise = 0.0
+        if self.noisy:
+            match self.noise_distribution:
+                case NoiseDistribution.uniform:
+                    noise = random.uniform(0, self.sigma)
+                case NoiseDistribution.gaussian:
+                    noise = random.gauss(0, self.sigma)
+                case NoiseDistribution.lognorm:
+                    noise = random.lognormvariate(0, self.sigma)
+
+        return noise
+
+
+def call(**kwargs) -> dict:
+    return ExampleBenchCfg().__call__(**kwargs)
+
+
+class AllSweepVars(ParametrizedSweep):
+    """A class containing all the sweep types, This class is used for unit testing how the configuration classes are serialised and hashed"""
+
+    var_float = FloatSweep(default=5, bounds=(0, 10), units="m/s")
+    var_int = IntSweep(default=3, bounds=[0, 4])
+    var_int_big = IntSweep(default=0, bounds=[0, 100], samples=3)
+    var_bool = BoolSweep()
+    var_string = StringSweep(["string1", "string2"])
+    var_enum = EnumSweep(PostprocessFn)
+
+    result = ResultVar()
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.var_float + self.var_int
+        return self.get_results_values_as_dict()
+
+
+class SimpleBenchClass(ParametrizedSweep):
+    var1 = IntSweep(default=0, bounds=[0, 2])
+
+    result = ResultVar()
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.var1
+        return self.get_results_values_as_dict()
+
+
+class SimpleBenchClassFloat(ParametrizedSweep):
+    var1 = FloatSweep(bounds=[0, 100])
+
+    result = ResultVar()
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.var1
+        return self.get_results_values_as_dict()

bencher/example/example_all.py

@@ -0,0 +1,45 @@
+import bencher as bch
+
+from bencher.example.example_categorical import example_categorical
+from bencher.example.example_floats import example_floats
+from bencher.example.example_floats2D import example_floats2D
+from bencher.example.example_pareto import example_pareto
+from bencher.example.example_simple_cat import example_1D_cat
+from bencher.example.example_simple_float import example_1D_float
+from bencher.example.example_float_cat import example_float_cat
+from bencher.example.example_time_event import example_time_event
+from bencher.example.example_float3D import example_floats3D
+
+from bencher.example.example_custom_sweep import example_custom_sweep
+from bencher.example.example_holosweep import example_holosweep
+from bencher.example.example_holosweep_tap import example_holosweep_tap
+
+from bencher.example.optuna.example_optuna import optuna_rastrigin
+from bencher.example.example_sample_cache import example_sample_cache
+
+# from bencher.example.example_workflow import example_floats2D_workflow, example_floats3D_workflow
+
+
+if __name__ == "__main__":
+    run_cfg = bch.BenchRunCfg()
+    run_cfg.overwrite_sample_cache = True
+    bench_runner = bch.BenchRunner("bencher_examples", run_cfg=run_cfg)
+
+    bench_runner.add_run(example_categorical)
+    bench_runner.add_run(example_floats)
+    bench_runner.add_run(example_floats2D)
+    bench_runner.add_run(example_floats3D)
+    bench_runner.add_run(example_1D_cat)
+    bench_runner.add_run(example_1D_float)
+    bench_runner.add_run(example_pareto)
+    bench_runner.add_run(example_float_cat)
+    bench_runner.add_run(example_time_event)
+    bench_runner.add_run(example_custom_sweep)
+    bench_runner.add_run(example_holosweep)
+    bench_runner.add_run(example_holosweep_tap)
+    bench_runner.add_run(optuna_rastrigin)
+    bench_runner.add_run(example_sample_cache)
+
+    # bench_runner.run(level=2, show=True, grouped=True)
+
+    bench_runner.run(level=4, show=True, grouped=True, save=False)

bencher/example/example_categorical.py

@@ -0,0 +1,99 @@
+# 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_categorical(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a categorical parameter sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    with open("README.md", "r", encoding="utf-8") as file:
+        readme = file.read()
+
+    # run_cfg.over_time = True
+
+    bench = bch.Bench(
+        "Bencher_Example_Categorical",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    bench.report.append(readme, "Intro")
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.noisy],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Categorical 1D Example",
+        description="""This example shows how to sample categorical values. The same objective from the float examples is used but theta is kept constant with a value of 0 (as described in the ExampleBenchCfgIn class definition).
+
+        
+```
+    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)          
+        return out
+```
+        
+        """,
+        post_description="The plot shows when noise=True the output has uniform random noise.",
+    )
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.noisy, ExampleBenchCfgIn.param.noise_distribution],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Categorical 2D Example",
+        description="""Adding another categorical value creates a facet plot over that dimension""",
+        post_description="The output shows swarm plots of different noise distributions",
+    )
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.noisy,
+            ExampleBenchCfgIn.param.noise_distribution,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Categorical 3D Example",
+        description="""Adding another categorical value extends the facets to the right""",
+        post_description="The output shows swarm plots of different noise distributions",
+    )
+
+    run_cfg.over_time = True
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.noisy,
+            ExampleBenchCfgIn.param.noise_distribution,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        title="Categorical 3D Example Over Time",
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        description="""Lastly, what if you want to track these distributions over time? Set over_time=True and bencher will cache and display historical resuts alongside the latest result.  Use clear_history=True to clear that cache.""",
+        post_description="The output shows faceted line plot with confidence intervals for the mean value over time.",
+        run_cfg=run_cfg,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    example_categorical(ex_run_cfg).report.show()

bencher/example/example_composable_container.py

@@ -0,0 +1,106 @@
+import bencher as bch
+
+from bencher.example.example_image import BenchPolygons
+
+
+class BenchComposableContainerImage(BenchPolygons):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    num_frames = bch.IntSweep(default=5, bounds=[1, 100])
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        var_name = None
+        var_value = None
+
+        if self.labels:
+            var_name = "sides"
+            var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+        for i in range(self.num_frames):
+            res = super().__call__(start_angle=i)
+            print(res)
+            vr.append(res["polygon"])
+        self.polygon_vid = vr.to_video(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                var_name=var_name,
+                var_value=var_value,
+                max_frame_duration=1.0 / 20.0,
+            )
+        )
+        return self.get_results_values_as_dict()
+
+
+class BenchComposableContainerVideo(bch.ParametrizedSweep):
+    unequal_length = bch.BoolSweep()
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        vr = bch.ComposableContainerVideo()
+        for i in range(3, 5):
+            num_frames = i * 10 if self.unequal_length else 5
+            res = BenchComposableContainerImage().__call__(
+                compose_method=bch.ComposeType.sequence, sides=i, num_frames=num_frames
+            )
+            vr.append(res["polygon_vid"])
+
+        self.polygon_vid = vr.to_video(bch.RenderCfg(compose_method=kwargs.get("compose_method")))
+        return self.get_results_values_as_dict()
+
+
+def example_composable_container_image(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerImage().to_bench(run_cfg, report)
+    bench.result_vars = ["polygon_vid"]
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    # bench.plot_sweep(input_vars=["compose_method", "labels"])
+
+    bench.plot_sweep(input_vars=["compose_method"])
+
+    # bench.compose_
+    # bench.plot_sweep(
+    # input_vars=[bch.p("num_frames", [2, 8, 20])],
+    # const_vars=dict(compose_method=bch.ComposeType.sequence),
+    # )
+
+    return bench
+
+
+def example_composable_container_video(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerVideo().to_bench(run_cfg, report)
+
+    bench.result_vars = ["polygon_vid"]
+    bench.add_plot_callback(bch.BenchResult.to_panes)
+    bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    bench.plot_sweep(input_vars=["compose_method", "labels"], const_vars=dict(unequal_length=True))
+
+    res = bench.plot_sweep(
+        input_vars=[],
+        const_vars=dict(unequal_length=False, compose_method=bch.ComposeType.sequence),
+        plot_callbacks=False,
+    )
+
+    bench.report.append(res.to_video_grid())
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.use_sample_cache = False
+    # ex_run_cfg.level = 2
+    ex_report = bch.BenchReport()
+    example_composable_container_image(ex_run_cfg, report=ex_report)
+    # example_composable_container_video(ex_run_cfg, report=ex_report)
+    ex_report.show()

bencher/example/example_composable_container2.py

@@ -0,0 +1,160 @@
+import bencher as bch
+from PIL import Image, ImageDraw
+from bencher.video_writer import VideoWriter
+
+
+class BenchImageTest(bch.ParametrizedSweep):
+    character = bch.StringSweep(["a", "b", "c", "d", "e", "f"])
+    r = bch.IntSweep(default=255, bounds=[0, 255])
+    g = bch.IntSweep(default=255, bounds=[0, 255])
+    b = bch.IntSweep(default=255, bounds=[0, 255])
+    width = bch.IntSweep(default=100, bounds=[10, 100])
+    height = bch.IntSweep(default=100, bounds=[10, 100])
+
+    image = bch.ResultImage()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        img = Image.new("RGB", (self.width, self.height), color=(self.r, self.g, self.b))
+        ImageDraw.Draw(img).text(
+            (self.width / 2.0, self.height / 2.0),
+            self.character,
+            (0, 0, 0),
+            anchor="mm",
+            font_size=self.height,
+        )
+        self.image = bch.gen_image_path()
+        img.save(self.image)
+        return super().__call__(**kwargs)
+
+
+def bench_image(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchImageTest().to_bench(run_cfg, report)
+    bench.sweep_sequential(group_size=1)
+    return bench
+
+
+class BenchComposableContainerImage(BenchImageTest):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    # num_frames = bch.IntSweep(default=5, bounds=[1, 10])
+    # character = bch.StringSweep(["a", "b"])
+
+    text_vid = bch.ResultVideo()
+    frame_width = bch.ResultVar("pixels")
+    frame_height = bch.ResultVar("pixels")
+    duration = bch.ResultVar("S")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        # if self.labels:
+        # var_name = "sides"
+        # var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+
+        for c in ["a", "b"]:
+            res = super().__call__(character=c)
+            vr.append(res["image"])
+
+        vid = vr.render(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                # var_name=var_name,
+                # var_value=var_value,
+                max_frame_duration=2.0,
+                # max_frame_duration=1.,
+                # duration=1.
+            )
+        )
+
+        self.frame_width, self.frame_height = vid.size
+        self.duration = vid.duration
+        print("RES", self.frame_width, self.frame_height, self.duration)
+
+        self.text_vid = VideoWriter().write_video_raw(vid)
+        return self.get_results_values_as_dict()
+
+
+# class BenchComposableContainerVideo(bch.ParametrizedSweep):
+#     unequal_length = bch.BoolSweep()
+#     compose_method = bch.EnumSweep(bch.ComposeType)
+#     labels = bch.BoolSweep()
+#     polygon_vid = bch.ResultVideo()
+
+#     def __call__(self, **kwargs):
+#         self.update_params_from_kwargs(**kwargs)
+#         vr = bch.ComposableContainerVideo()
+#         for i in range(3, 5):
+#             num_frames = i * 10 if self.unequal_length else 5
+#             res = BenchComposableContainerImage().__call__(
+#                 compose_method=bch.ComposeType.sequence, sides=i, num_frames=num_frames
+#             )
+#             vr.append(res["polygon_vid"])
+
+#         self.polygon_vid = vr.to_video(bch.RenderCfg(compose_method=kwargs.get("compose_method")))
+#         return self.get_results_values_as_dict()
+
+
+def example_composable_container_image(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerImage().to_bench(run_cfg, report)
+    bench.result_vars = ["text_vid", "duration"]
+    # bench.result_vars = ["duration"]
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_table)
+
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    # bench.plot_sweep(input_vars=["compose_method", "labels"])
+
+    bench.plot_sweep(input_vars=["compose_method"])
+
+    # bench.compose_
+    # bench.plot_sweep(
+    # input_vars=[bch.p("num_frames", [2, 8, 20])],
+    # const_vars=dict(compose_method=bch.ComposeType.sequence),
+    # )
+
+    return bench
+
+
+# def example_composable_container_video(
+#     run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+# ) -> bch.Bench:
+#     bench = BenchComposableContainerVideo().to_bench(run_cfg, report)
+
+#     bench.result_vars = ["polygon_vid"]
+#     bench.add_plot_callback(bch.BenchResult.to_panes)
+#     bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+#     bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+#     bench.plot_sweep(input_vars=["compose_method", "labels"], const_vars=dict(unequal_length=True))
+
+#     res = bench.plot_sweep(
+#         input_vars=[],
+#         const_vars=dict(unequal_length=False, compose_method=bch.ComposeType.sequence),
+#         plot_callbacks=False,
+#     )
+
+#     bench.report.append(res.to_video_grid())
+
+#     return bench
+
+
+# if __name__ == "__main__":
+#     ex_run_cfg = bch.BenchRunCfg()
+#     ex_run_cfg.use_sample_cache = False
+#     # ex_run_cfg.level = 2
+#     ex_report = bch.BenchReport()
+#     example_composable_container_image(ex_run_cfg, report=ex_report)
+#     # example_composable_container_video(ex_run_cfg, report=ex_report)
+#     ex_report.show()
+
+
+if __name__ == "__main__":
+    bench_runner = bch.BenchRunner("ImageChar")
+    # bench_runner.add_run(bench_image)
+    bench_runner.add_run(example_composable_container_image)
+
+    bench_runner.run(level=6, show=True, use_cache=False)

bencher/example/example_consts.py

@@ -0,0 +1,39 @@
+"""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 offset", units="rad")
+    noise = bch.FloatSweep(default=0, bounds=[0, 1], doc="noise", 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 + self.noise
+        return super().__call__(**kwargs)
+
+
+def example_2D_float_const(
+    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)
+    const_vars = SimpleFloat().get_input_defaults_override(offset=0.5)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    const_vars = SimpleFloat().get_input_defaults_override(noise=0.2)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    bench.plot_sweep(input_vars=["theta"], const_vars=dict(offset=0.3))
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_2D_float_const().report.show()