holobench 1.3.6__py2.py3-none-any.whl

bencher/caching.py

@@ -0,0 +1,51 @@
+from diskcache import Cache
+
+from bencher.variables.parametrised_sweep import ParametrizedSweep
+from bencher.utils import hash_sha1
+import logging
+from sortedcontainers import SortedDict
+
+# from job import job,JobCache,JobFunctionCache
+
+
+class CachedParams(ParametrizedSweep):
+    def __init__(self, clear_cache=True, cache_name="fcache", **params):
+        super().__init__(**params)
+
+        self.cache = Cache(f"cachedir/{cache_name}/sample_cache")
+        logging.info(f"cache dir{self.cache.directory}")
+        print(f"cache dir{self.cache.directory}")
+
+        if clear_cache:
+            self.cache.clear()
+
+    def kwargs_to_hash_key(self, **kwargs):
+        return tuple(SortedDict(kwargs).items())
+
+    def in_cache(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        # print(self.get_inputs_as_dict())
+        inputs_key = self.kwargs_to_hash_key(**self.get_inputs_as_dict())
+        key = hash_sha1(inputs_key)
+        print(f"key:{key},value: {inputs_key}")
+        value = None
+        if key in self.cache:
+            value = self.cache[key]
+        return key, value
+
+    def cache_wrap(self, func, **kwargs):
+        key, value = self.in_cache(**kwargs)
+        if value is None:
+            value = func(**kwargs)
+            self.cache[key] = value
+        return value
+
+    # def cache_mem(self, function):
+    #     def cache_wrap1(self, func, **kwargs):
+    #         key, value = self.in_cache(**kwargs)
+    #         if value is None:
+    #             value = function(**kwargs)
+    #             self.cache[key] = value
+    #         return value
+
+    #     return cache_wrap1

bencher/example/benchmark_data.py

@@ -0,0 +1,200 @@
+"""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_custom_sweep.py

@@ -0,0 +1,59 @@
+import bencher as bch
+
+
+class Square(bch.ParametrizedSweep):
+    """An example of a datatype with an integer and float parameter"""
+
+    x = bch.FloatSweep(
+        sample_values=[2, 3, 4, 7, 8, 9],
+        doc="An example of a user defines set of sweep values",
+    )
+    y = bch.IntSweep(
+        sample_values=[1, 2, 6], doc="An example of a user defines set of sweep values"
+    )
+
+    result = bch.ResultVar("ul", doc="Square of x")
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.x * self.x * self.y * 3
+        return self.get_results_values_as_dict()
+
+
+def example_custom_sweep(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    bencher = bch.Bench(
+        "benchmarking_example_custom_sweep", Square(), run_cfg=run_cfg, report=report
+    )
+    # bencher = bch.Bench("benchmarking_example_custom_sweep", call,run_cfg=run_cfg)
+
+    # 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 User Defined Sweep 1D",
+        input_vars=[Square.param.x],
+        result_vars=[Square.param.result],
+        description="Sample the x parameter",
+    )
+
+    bencher.plot_sweep(
+        title="Example User Defined Sweep 2D",
+        description="By default bencher sweep all the variables in a class",
+    )
+
+    return bencher
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg(run_tag="example_tag1", print_meta=True)
+    example_custom_sweep(ex_run_cfg).report.show()

bencher/example/example_docs.py

@@ -0,0 +1,34 @@
+import bencher as bch
+from bencher.example.example_video import example_video
+from bencher.example.example_image import example_image
+from bencher.example.meta.example_meta_levels import example_meta_levels
+from bencher.example.meta.example_meta_cat import example_meta_cat
+from bencher.example.meta.example_meta_float import example_meta_float
+
+
+def example_docs(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    # b_run = bch.BenchRunner("bench_runner_test", run_cfg=run_cfg)
+    # b_run.add_run(example_categorical)
+    # b_run.add_run(example_floats)
+    # b_run.add_run(example_image)
+    # b_run.add_run(example_video)
+    # b_run.add_run(example_meta_levels)
+    # b_run.add_run(run_levels)
+    # b_run.run(level=4, grouped=True, save=True)
+    # b_run.shutdown()
+    run_cfg.repeats = 1
+    run_cfg.level = 2
+    example_image(run_cfg, report)
+    example_video(run_cfg, report)
+    example_meta_cat(report=report)
+    example_meta_float(report=report)
+    example_meta_levels(report=report)
+    # example_meta(run_cfg,report)
+
+    return report
+
+
+if __name__ == "__main__":
+    example_docs().show()

bencher/example/example_float3D.py

@@ -0,0 +1,101 @@
+# 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=4
+    )
+    y = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="y coordinate of the sample volume", samples=5
+    )
+    z = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=6
+    )
+
+
+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")
+    occupancy = bch.ResultVar(
+        "occupied", doc="If the value is > 0.5 this point is considered occupied"
+    )
+    interesting = bch.ResultVar("ul", doc="A more interesting scalar field")
+    interesting_vec = bch.ResultVec(3, "vec", doc="A vector field with an interesting shape")
+    interesting_vec_and_occ = bch.ResultVec(
+        3, "vec", doc="The same vector field but only showing values in a sphere of radius 0.5"
+    )
+
+
+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
+    """
+    output = VolumeResult()
+    output.value = np.linalg.norm(np.array([point.x, point.y, point.z]))  # distance to origin
+    output.occupancy = float(output.value < 0.5)
+    # from https://plotly.com/python/3d-volume-plots/
+    output.interesting = np.sin(np.pi * point.x) * np.cos(np.pi * point.z) * np.sin(np.pi * point.y)
+    output.interesting_vec = [
+        np.sin(np.pi * point.x),
+        np.cos(np.pi * point.z),
+        np.sin(np.pi * point.y),
+    ]
+
+    if output.occupancy:
+        output.interesting_vec_and_occ = output.interesting_vec
+    else:
+        output.interesting_vec_and_occ = [0, 0, 0]
+
+    return output
+
+
+def example_floats3D(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> 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
+    """
+    bench = bch.Bench(
+        "Bencher_Example_Floats",
+        bench_fn,
+        VolumeSample,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    bench.plot_sweep(
+        title="Float 3D Example",
+        input_vars=[VolumeSample.param.x, VolumeSample.param.y, VolumeSample.param.z],
+        result_vars=[
+            VolumeResult.param.value,
+            VolumeResult.param.occupancy,
+            VolumeResult.param.interesting,
+        ],
+        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",
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.level = 3
+    example_floats3D(ex_run_cfg).report.show()

bencher/example/example_float_cat.py

@@ -0,0 +1,98 @@
+"""Example of how to perform a parameter sweep for categorical variables"""
+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_float_cat(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a parameter sweep for categorical 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_Float_Cat",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.theta,
+            ExampleBenchCfgIn.param.offset,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+        title="Float 2D Cat 1D 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],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+        title="Float 1D Cat 1D  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.",
+        plot=False,
+    )
+
+    # report.append(bench.get_result().to_curve())
+
+    # # this does not work yet because it tries to find min and max of categorical values
+    # bench.plot_sweep(
+    #     input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.postprocess_fn],
+    #     result_vars=[ExampleBenchCfgOut.param.out_sin],
+    #     const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+    #     title="Float 1D Cat 1D  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.",
+    #     run_cfg=run_cfg,
+    # )
+
+    return bench
+
+
+def run_example_float_cat(ex_run_cfg=bch.BenchRunCfg()) -> None:
+    ex_run_cfg.repeats = 2
+    ex_run_cfg.over_time = True
+    ex_run_cfg.clear_cache = True
+    ex_run_cfg.clear_history = True
+    ex_run_cfg.level = 3
+    # ex_run_cfg.time_event = "run 1"
+    # ex_run_cfg.use_optuna = True
+
+    example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.repeats = 2
+    # ex_run_cfg.over_time = True
+    ex_run_cfg.clear_cache = False
+    ex_run_cfg.clear_history = False
+    # ex_run_cfg.time_event = "run 2"
+    # ex_run_cfg.use_optuna = True
+
+    # example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.clear_cache = False
+    # ex_run_cfg.clear_history = False
+    # ex_run_cfg.time_event = "run 2"
+
+    # example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.time_event = "run 3"
+    return example_float_cat(ex_run_cfg)
+
+
+if __name__ == "__main__":
+    run_example_float_cat().report.show()