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

bencher/example/experimental/example_updates.py

@@ -0,0 +1,84 @@
+# pylint: skip-file  #this is experimental still
+
+
+import numpy as np
+import pandas as pd
+import holoviews as hv
+import panel as pn
+
+# import streamz
+# import streamz.dataframe
+
+from holoviews import opts
+from holoviews.streams import Buffer
+
+from tornado.ioloop import PeriodicCallback
+from tornado import gen
+
+
+hv.extension("bokeh")
+
+
+count = 0
+buffer = Buffer(np.zeros((0, 2)), length=50)
+
+dataType = pd.DataFrame()
+
+
+@gen.coroutine
+def f():
+    global count
+    count += 1
+    buffer.send(np.array([[count, np.random.rand()]]))
+
+
+def plot(**kwargs):
+    # print(dat)
+    return hv.Curve(**kwargs)
+
+
+cb = PeriodicCallback(f, 1)
+cb.start()
+
+# dmap = hv.DynamicMap(hv.Curve, streams=[buffer]).opts(padding=0.1, width=600)
+dmap = hv.DynamicMap(plot, streams=[buffer]).opts(padding=0.1, width=600)
+
+pn.Row(dmap).show()
+
+
+example = pd.DataFrame({"x": [], "y": [], "count": []}, columns=["x", "y", "count"])
+dfstream = Buffer(example, length=100, index=False)
+
+
+def plot():
+    curve_dmap = hv.DynamicMap(hv.Curve, streams=[dfstream])
+    point_dmap = hv.DynamicMap(hv.Points, streams=[dfstream])
+    (curve_dmap * point_dmap).opts(
+        opts.Points(color="count", line_color="black", size=5, padding=0.1, xaxis=None, yaxis=None),
+        opts.Curve(line_width=1, color="black"),
+    )
+
+
+def gen_brownian():
+    x, y, count = 0, 0, 0
+    while True:
+        x += np.random.randn()
+        y += np.random.randn()
+        count += 1
+        yield pd.DataFrame([(x, y, count)], columns=["x", "y", "count"])
+
+
+@gen.coroutine
+def update_callback():
+    brownian = gen_brownian()
+    for i in range(2):
+        dfstream.send(next(brownian))
+
+
+cb = PeriodicCallback(update_callback, 1)
+cb.start()
+
+# update_button = pn.widgets.Button(name="Update Grid", button_type="primary")
+# update_button.on_click(update_callback)
+
+pn.Row(plot()).show()

bencher/example/experimental/example_vector.py

@@ -0,0 +1,84 @@
+# """Example on how to sweep over function with vector outputs"""
+
+# from math import cos, sin
+
+# import numpy as np
+
+# import bencher as bch
+
+
+# class OffsetCfg(bch.ParametrizedSweep):
+#     """A class for describing which parameters to sweep"""
+
+#     dc_offset = bch.FloatSweep(
+#         default=0,
+#         bounds=[0.0, 2.0],
+#         samples=4,
+#         units="v",
+#         doc="DC offset to add to the result of the signal",
+#     )
+#     phase_offset = bch.FloatSweep(
+#         default=0,
+#         bounds=[0.0, 3.14],
+#         samples=4,
+#         units="rad",
+#         doc="phase offset that is added to the input before passing to the trig function",
+#     )
+
+
+# class SweepResult(bch.ParametrizedSweep):
+#     """A class to describe the vector outputs of the benchmark function"""
+
+#     sin_sweep = bch.ResultList(
+#         index_name="time", index_units="s", units="v", doc="A list of values from a sin function"
+#     )
+#     cos_sweep = bch.ResultList(
+#         index_name="time", index_units="s", units="v", doc="A list of values from a cos function"
+#     )
+
+
+# def sin_sweep(cfg: OffsetCfg) -> SweepResult:
+#     """A function that returns vector outputs of the sin and cos functions
+
+#     Args:
+#         cfg (OffsetCfg): Options for phase and dc offset
+
+#     Returns:
+#         SweepResult: vectors with sin and cos results
+#     """
+#     res = SweepResult()
+#     print(type(res.sin_sweep))
+#     for i in np.arange(0, 6.28, 0.02):
+#         res.sin_sweep.append(sin(i + cfg.phase_offset) + cfg.dc_offset, i)
+#         # res.sin_sweep.indices.append(i)
+#     for i in np.arange(0, 3.28, 0.02):
+#         res.cos_sweep.append(cos(i + cfg.phase_offset) + cfg.dc_offset, i)
+#         # res.cos_sweep.indices.append(i)
+#     return res
+
+
+# def example_vector() -> bch.Bench:
+#     """Example on how to sweep over function with vector outputs"""
+#     bencher = bch.Bench("vector output example", sin_sweep, OffsetCfg)
+
+#     bencher.plot_sweep(
+#         title="Sweep DC offset",
+#         input_vars=[OffsetCfg.param.dc_offset],
+#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
+#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of dc offsets""",
+#         post_description="""The output shows stack of sin and cos functions as the dc offset increases""",
+#     )
+
+#     bencher.plot_sweep(
+#         title="Sweep phase offset",
+#         input_vars=[OffsetCfg.param.phase_offset],
+#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
+#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of phase offsets""",
+#         post_description="""The output shows different phases of the sin and cos functions""",
+#     )
+
+#     return bencher
+
+
+# if __name__ == "__main__":
+#     example_vector().plot()

bencher/example/meta/example_meta.py

@@ -0,0 +1,171 @@
+from typing import Any
+import bencher as bch
+import numpy as np
+
+from enum import auto
+from strenum import StrEnum
+import random
+import holoviews as hv
+import math
+
+
+class NoiseDistribution(StrEnum):
+    """A categorical variable describing the types of random noise"""
+
+    uniform = auto()  # uniform random noiase
+    gaussian = auto()  # gaussian noise
+
+    @staticmethod
+    def calculate_noise(noisy, noise_distribution, sigma) -> float:
+        if noisy:
+            match noise_distribution:
+                case NoiseDistribution.uniform:
+                    return random.uniform(0, sigma)
+                case NoiseDistribution.gaussian:
+                    return random.gauss(0, sigma)
+        return 0.0
+
+
+class BenchableObject(bch.ParametrizedSweep):
+    """A class to represent a 3D point in space."""
+
+    # floating point variables
+    float1 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="x coordinate of the sample volume")
+    float2 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="y coordinate of the sample volume")
+    float3 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="z coordinate of the sample volume")
+
+    sigma = bch.FloatSweep(default=1, bounds=[1, 10], doc="standard deviation of the added noise")
+
+    # categorial variables
+    noisy = bch.BoolSweep(
+        default=False, doc="Optionally add random noise to the output of the function"
+    )
+    noise_distribution = bch.EnumSweep(NoiseDistribution, doc=NoiseDistribution.__doc__)
+
+    negate_output = bch.StringSweep(["positive", "negative"])
+
+    distance = bch.ResultVar("m", doc="The distance from the sample point to the origin")
+    sample_noise = bch.ResultVar("m", doc="The amount of noise added to the distance sample")
+
+    result_hmap = bch.ResultHmap()
+    # result_im
+    ##todo all var types
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        # distance to origin
+        self.distance = math.pow(
+            np.linalg.norm(np.array([self.float1, self.float2, self.float3])), 2
+        )
+        self.sample_noise = NoiseDistribution.calculate_noise(
+            self.noisy, self.noise_distribution, self.sigma
+        )
+
+        self.distance += self.sample_noise
+
+        if self.negate_output == "negative":
+            self.distance *= -1
+
+        self.result_hmap = hv.Text(
+            x=0, y=0, text=f"distance:{self.distance}\nnoise:{self.sample_noise}"
+        )
+
+        return super().__call__()
+
+
+class BenchMeta(bch.ParametrizedSweep):
+    """This class uses bencher to display the multidimensional types bencher can represent"""
+
+    float_vars = bch.IntSweep(
+        default=1, bounds=(0, 4), doc="The number of floating point variables that are swept"
+    )
+    categorical_vars = bch.IntSweep(
+        default=1, bounds=(0, 3), doc="The number of categorical variables that are swept"
+    )
+    sample_with_repeats = bch.IntSweep(default=1, bounds=(1, 10))
+
+    sample_over_time = bch.BoolSweep(default=False)
+
+    level = bch.IntSweep(default=2, units="level", bounds=(2, 5))
+
+    # plots = bch.ResultHmap()
+    # plots = bch.ResultContainer()
+    plots = bch.ResultReference(units="int")
+
+    def __call__(self, **kwargs: Any) -> Any:
+        self.update_params_from_kwargs(**kwargs)
+
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = self.level
+        run_cfg.repeats = self.sample_with_repeats
+        run_cfg.over_time = self.sample_over_time
+        run_cfg.plot_size = 500
+
+        bench = bch.Bench("benchable", BenchableObject(), run_cfg=run_cfg)
+
+        inputs_vars_float = [
+            "float1",
+            "float2",
+            "float3",
+            "sigma",
+        ]
+
+        inputs_vars_cat = [
+            "noisy",
+            "noise_distribution",
+            "negate_output",
+        ]
+
+        input_vars = (
+            inputs_vars_float[0 : self.float_vars] + inputs_vars_cat[0 : self.categorical_vars]
+        )
+
+        res = bench.plot_sweep(
+            "test",
+            input_vars=input_vars,
+            result_vars=[BenchableObject.param.distance],
+            # result_vars=[BenchableObject.param.distance, BenchableObject.param.sample_noise],
+            # result_vars=[ BenchableObject.param.sample_noise],
+            # result_vars=[BenchableObject.param.result_hmap],
+            plot_callbacks=False,
+        )
+
+        self.plots = bch.ResultReference()
+        self.plots.obj = res.to_auto()
+
+        # self.plots.obj = res.to_heatmap_multi()
+
+        # self.plots.obj = res.to_line_multi(width=500, height=300)
+
+        return super().__call__()
+
+
+def example_meta(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Meta Bench",
+        description="""## All Combinations of Variable Sweeps and Resulting Plots
+This uses bencher to display all the combinatios of plots bencher is able to produce""",
+        input_vars=[
+            bch.p("float_vars", [0, 1, 2, 3]),
+            BenchMeta.param.categorical_vars,
+            bch.p("sample_with_repeats", [1, 2]),
+            # BenchMeta.param.sample_over_time,
+        ],
+        const_vars=[
+            # BenchMeta.param.float_vars.with_const(1),
+            # BenchMeta.param.sample_with_repeats.with_const(2),
+            # BenchMeta.param.categorical_vars.with_const(2),
+            # BenchMeta.param.sample_over_time.with_const(True),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta().report.show()

bencher/example/meta/example_meta_cat.py

@@ -0,0 +1,25 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_cat(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Sweeping Categorical Variables",
+        input_vars=[
+            bch.p("categorical_vars", [1, 2, 3]),
+            bch.p("sample_with_repeats", [1, 2]),
+        ],
+        const_vars=[
+            BenchMeta.param.float_vars.with_const(0),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_cat().report.show()

bencher/example/meta/example_meta_float.py

@@ -0,0 +1,23 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_float(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Sweeping Floating Point Variables",
+        input_vars=[bch.p("float_vars", [1, 2, 3])],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+            BenchMeta.param.level.with_const(3),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_float().report.show()

bencher/example/meta/example_meta_levels.py

@@ -0,0 +1,26 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_levels(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Using Levels to define sample density",
+        description="Sample levels let you perform parameter sweeps without having to decide how many samples to take when defining the class.  If you perform a sweep at level 2, then all the points are reused when sampling at level 3.  The higher levels reuse the points from lower levels to avoid having to recompute potentially expensive samples. The other advantage is that it enables a workflow where you can quickly see the results of the sweep at a low resolution to sense check the code, and then run it at a high level to get the fidelity you want.  When calling a sweep at a high level, you can publish the intermediate lower level results as the computiation continues so that you can track the progress of the computation and end the sweep early when you have sufficient resolution",
+        input_vars=[
+            bch.p("float_vars", [1, 2]),
+            bch.p("level", [2, 3, 4]),
+        ],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_levels().report.show()

bencher/example/optuna/example_optuna.py

@@ -0,0 +1,78 @@
+import bencher as bch
+import numpy as np
+import optuna
+from optuna.samplers import TPESampler
+
+
+def objective(trial):
+    x = trial.suggest_float("x", -10, 10)
+    return x**2
+
+
+study = optuna.create_study(sampler=TPESampler())
+study.optimize(objective, n_trials=10)
+
+rast_range = 1.5
+
+optimal_value = 0.1234
+
+
+class ToyOptimisationProblem(bch.ParametrizedSweep):
+    input1 = bch.FloatSweep(default=0, bounds=[-rast_range, rast_range], samples=10)
+    input2 = bch.FloatSweep(default=0, bounds=[-rast_range, rast_range], samples=10)
+    offset = bch.FloatSweep(default=0, bounds=[-rast_range, rast_range])
+
+    bump_scale = bch.FloatSweep(default=1.5, bounds=[1, 10])
+
+    # RESULTS
+    output = bch.ResultVar("ul", bch.OptDir.minimize)
+
+    def rastrigin(self, **kwargs) -> dict:
+        """A modified version of the rastrigin function which is very difficult to find the global optimum
+        https://en.wikipedia.org/wiki/Rastrigin_function
+
+        Returns:
+            dict: dictionary of return values
+        """
+        self.update_params_from_kwargs(**kwargs)
+        x = np.array([self.input1 + optimal_value, self.input2 + optimal_value])
+
+        self.output = (
+            np.sum(x * x - self.bump_scale * np.cos(self.bump_scale * np.pi * x))
+            + self.bump_scale * np.size(x)
+            + self.offset
+        )
+        return self.get_results_values_as_dict()
+
+
+def optuna_rastrigin(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+):
+    explorer = ToyOptimisationProblem()
+
+    bench = bch.Bench("Rastrigin", explorer.rastrigin, run_cfg=run_cfg, report=report)
+
+    # res = bench.to_optuna(
+    #     input_vars=[explorer.param.input1, explorer.param.input2],
+    #     result_vars=[explorer.param.output],
+    #     n_trials=30
+    # )
+
+    # run_cfg.use_optuna = True
+    res = bench.plot_sweep(
+        "Rastrigin",
+        input_vars=[explorer.param.input1, explorer.param.input2],
+        result_vars=[explorer.param.output],
+        run_cfg=run_cfg,
+    )
+
+    bench.report.append(res.to_optuna_plots())
+    bench.report.append(res.to_optuna_from_sweep(bench))
+    bench.report.append_markdown(
+        f"The optimal value should be input1:{-optimal_value},input2:{-optimal_value} with a value of 0"
+    )
+    return bench
+
+
+if __name__ == "__main__":
+    optuna_rastrigin().report.show()

bencher/example/shelved/example_float2D_scatter.py

@@ -0,0 +1,109 @@
+# import random
+
+# import bencher as bch
+
+
+# class GaussianDist(bch.ParametrizedSweep):
+#     """A class to represent a gaussian distribution."""
+
+#     mean = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], doc="mean of the gaussian distribution", samples=3
+#     )
+#     sigma = bch.FloatSweep(
+#         default=1, bounds=[0, 1.0], doc="standard deviation of gaussian distribution", samples=4
+#     )
+
+
+# class Example2DGaussianResult(bch.ParametrizedSweep):
+#     """A class to represent the properties of a volume sample."""
+
+#     gauss_x = bch.ResultVar("m", doc="x value of the 2D gaussian")
+#     gauss_y = bch.ResultVar("m", doc="y value of the 2D gaussian")
+
+#     point2D = bch.ResultVec(2, "m", doc="2D vector of the point")
+
+
+# def bench_fn(dist: GaussianDist) -> Example2DGaussianResult:
+#     """This function samples a point from a gaussian distribution.
+
+#     Args:
+#         dist (GaussianDist): Sample point
+
+#     Returns:
+#         Example2DGaussianResult: Value at that point
+#     """
+#     output = Example2DGaussianResult()
+
+#     output.gauss_x = random.gauss(dist.mean, dist.sigma)
+#     output.gauss_y = random.gauss(dist.mean, dist.sigma)
+#     output.point2D = [output.gauss_x, output.gauss_y]
+
+#     return output
+
+
+# def example_floats2D_scatter(run_cfg: bch.BenchRunCfg) -> 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_Scatter", bench_fn, GaussianDist, plot_lib=bch.PlotLibrary.default()
+#     )
+
+#     bench.plot_sweep(
+#         result_vars=[
+#             Example2DGaussianResult.param.point2D,
+#             Example2DGaussianResult.param.gauss_x,
+#             Example2DGaussianResult.param.gauss_y,
+#         ],
+#         title="Float 2D Scatter Example",
+#         run_cfg=run_cfg,
+#     )
+
+#     bench.plot_sweep(
+#         input_vars=[GaussianDist.param.mean],
+#         result_vars=[
+#             Example2DGaussianResult.param.point2D,
+#             Example2DGaussianResult.param.gauss_x,
+#             Example2DGaussianResult.param.gauss_y,
+#         ],
+#         title="Float 2D Scatter With Changing Mean",
+#         run_cfg=run_cfg,
+#     )
+
+#     bench.plot_sweep(
+#         input_vars=[GaussianDist.param.sigma],
+#         result_vars=[
+#             Example2DGaussianResult.param.point2D,
+#             Example2DGaussianResult.param.gauss_x,
+#             Example2DGaussianResult.param.gauss_y,
+#         ],
+#         title="Float 2D Scatter With Changing Sigma",
+#         run_cfg=run_cfg,
+#     )
+
+#     # future work
+#     # bench.plot_sweep(
+#     #     input_vars=[GaussianDist.param.mean, GaussianDist.param.sigma],
+#     #     result_vars=[
+#     #         GaussianResult.param.point2D,
+#     #         GaussianResult.param.gauss_x,
+#     #         GaussianResult.param.gauss_y,
+#     #     ],
+#     #     title="Float 2D Scatter With Changing Sigma",
+#     #     run_cfg=run_cfg,
+#     # )
+
+#     return bench
+
+
+# if __name__ == "__main__":
+#     ex_run_cfg = bch.BenchRunCfg()
+#     ex_run_cfg.repeats = 50
+#     ex_run_cfg.over_time = True
+#     # ex_run_cfg.clear_history = True
+#     example_floats2D_scatter(ex_run_cfg).report.show()

bencher/example/shelved/example_float3D_cone.py

@@ -0,0 +1,96 @@
+# import numpy as np
+
+# import bencher as bch
+
+
+# class VolumeSample(bch.ParametrizedSweep):
+#     """A class to represent a 3D point in space."""
+
+#     pos_samples = 1
+
+#     x = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=pos_samples, doc="x coordinate of the sample volume"
+#     )
+#     y = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=pos_samples, doc="y coordinate of the sample volume"
+#     )
+#     z = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=pos_samples, doc="z coordinate of the sample volume"
+#     )
+
+#     vec_samples = 5
+
+#     vec_x = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=vec_samples, doc="x coordinate of the sample volume"
+#     )
+#     vec_y = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=vec_samples, doc="y coordinate of the sample volume"
+#     )
+#     vec_z = bch.FloatSweep(
+#         default=0, bounds=[-1.0, 1.0], samples=vec_samples, doc="z coordinate of the sample volume"
+#     )
+
+
+# class VolumeResult(bch.ParametrizedSweep):
+#     """A class to represent the properties of a volume sample."""
+
+#     vec_dir = bch.ResultVec(3, "vec", doc="A vector field with an interesting shape")
+
+
+# def bench_fn(point: VolumeSample, normalise=False) -> 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()
+
+#     vec = np.array([point.vec_x, point.vec_y, point.vec_z])
+
+#     if normalise:
+#         norm = np.linalg.norm(vec)
+#         if norm > 0:
+#             vec /= norm
+
+#     output.vec_dir = list(vec)
+#     return output
+
+
+# def example_cone(run_cfg: bch.BenchRunCfg) -> 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_Cone", bench_fn, VolumeSample)
+
+#     bench.plot_sweep(
+#         input_vars=[
+#             VolumeSample.param.x,
+#             VolumeSample.param.y,
+#             VolumeSample.param.z,
+#             VolumeSample.param.vec_x,
+#             VolumeSample.param.vec_y,
+#             VolumeSample.param.vec_z,
+#         ],
+#         result_vars=[
+#             VolumeResult.param.vec_dir,
+#         ],
+#         title="Float 3D cone Example",
+#         description="""This example shows how to sample 3 floating point variables and plot a vector field representation of the results.  The benchmark function returns the distance to the origin""",
+#         run_cfg=run_cfg,
+#     )
+
+#     return bench
+
+
+# if __name__ == "__main__":
+#     ex_run_cfg = bch.BenchRunCfg()
+#     ex_run_cfg.use_cache = True
+#     example_cone(ex_run_cfg).report.show()