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

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()

bencher/example/experimental/example_interactive.py

@@ -0,0 +1,75 @@
+# import holoviews as hv
+# import numpy as np
+# import param
+# from holoviews import opts, streams
+# from holoviews.plotting.links import DataLink
+
+# import panel as pn
+
+# hv.extension("bokeh")
+
+# datasets = {
+#     "data1": np.random.randint(1, 10, size=(4, 2)),
+#     "data2": np.random.randint(1, 10, size=(4, 2)),
+# }
+
+# other_data = {i: np.random.randint(1, 10, size=(100, 100)) for i in range(4)}
+
+
+# class Explorer(param.Parameterized):
+#     dataset = param.ObjectSelector(default=list(datasets.keys())[0], objects=list(datasets.keys()))
+
+#     lines = param.Boolean(default=False)
+
+#     # streams
+#     stream = param.ClassSelector(
+#         default=streams.PointDraw(drag=False, add=False), class_=(streams.PointDraw), precedence=-1
+#     )
+
+#     selection = param.ClassSelector(
+#         default=streams.Selection1D(), class_=(streams.Selection1D), precedence=-1
+#     )
+
+#     @param.depends("dataset")
+#     def load_file(self):
+#         name = self.dataset
+#         datum = datasets[name]
+#         scatter = hv.Scatter(datum).opts(size=8)
+
+#         # update the PointDraw/Selection1D sources/data
+#         self.stream.source = scatter
+#         self.selection.source = scatter
+#         self.stream.update(data=scatter.columns())  # reset PointDraw data
+#         self.selection.update(index=[])  # reset selection index
+
+#         table = hv.Table(scatter).opts(index_position=False, editable=True, selectable=True)
+#         DataLink(scatter, table)
+
+#         return (scatter + table).opts(
+#             opts.Scatter(tools=["tap", "hover", "box_select"]), opts.Table(editable=True)
+#         )
+
+#     @param.depends("dataset", "selection.index", "lines")
+#     def view(self):
+#         """update 3rd plot whenever dataset, selection.index, or lines is changed"""
+#         if self.selection.index == []:
+#             return None
+#         else:
+#             # modify with your "other" data
+#             if self.lines is True:
+#                 return hv.Path(other_data[self.selection.index[0]]).opts(shared_axes=False)
+
+#         return hv.operation.datashader.regrid(
+#             hv.Image(other_data[self.selection.index[0]]),
+#             upsample=True,
+#             interpolation="bilinear",
+#         ).opts(shared_axes=False)
+
+#     @param.depends("stream.data", watch=True)
+#     def update_data(self):
+#         """update dataset whenever a point is deleted using PointDraw"""
+#         datasets[self.dataset] = np.vstack((self.stream.data["x"], self.stream.data["y"])).T
+
+
+# explorer = Explorer()
+# pn.Row(pn.Column(explorer.param, explorer.view), explorer.load_file).show()

bencher/example/experimental/example_streamnd.py

@@ -0,0 +1,49 @@
+# pylint: skip-file  #this is experimental still
+
+
+import time
+import numpy as np
+import holoviews as hv
+from holoviews import streams
+import panel as pn
+
+hv.extension("bokeh")
+
+# Step 1: Set up your initial data
+# For demonstration purposes, let's create a simple initial Image plot.
+
+# Initial data (replace this with your actual data source)
+initial_data = np.random.rand(10, 10)
+
+# Create an Image plot from the initial data
+initial_plot = hv.Image(initial_data)
+
+
+# Step 2: Create a callback function to update the plot with new data
+def update_plot(new_data):
+    # Update the Image plot with the new data
+    new_plot = hv.Image(new_data)
+    return new_plot
+
+
+# Step 3: Create a DynamicMap that triggers the update_plot callback
+# The DynamicMap will automatically update the plot when new_data changes.
+dmap = hv.DynamicMap(
+    update_plot, streams=[streams.Stream.define("NewData", new_data=initial_data)()]
+)
+
+# Display the initial plot and start streaming updates
+layout = initial_plot + dmap
+layout = layout.cols(1)
+
+# Simulate streaming updates by continuously updating the new_data stream
+for i in range(10):
+    # Replace this line with your actual data source/streaming mechanism
+    new_data = np.random.rand(10, 10)
+    # Update the new_data stream to trigger the DynamicMap callback
+    dmap.event(NewData=new_data)
+    # Sleep for a specified interval
+    time.sleep(1)
+
+
+pn.Row(dmap).show()

bencher/example/experimental/example_streams.py

@@ -0,0 +1,36 @@
+# pylint: skip-file  #this is experimental still
+
+import numpy as np
+import holoviews as hv
+from holoviews import opts
+from holoviews import streams
+import panel as pn
+
+xs = np.linspace(-3, 3, 400)
+
+hv.extension("bokeh")
+
+
+def function(xs, time):
+    "Some time varying function"
+    return np.exp(np.sin(xs + np.pi / time))
+
+
+def integral(limit, time):
+    print(limit, time)
+    limit = -3 if limit is None else np.clip(limit, -3, 3)
+    curve = hv.Curve((xs, function(xs, time)))[limit:]
+    area = hv.Area((xs, function(xs, time)))[:limit]
+    summed = area.dimension_values("y").sum() * 0.015  # Numeric approximation
+    return area * curve * hv.VLine(limit) * hv.Text(limit + 0.8, 2.0, "%.2f" % summed)
+
+
+integral_streams = [streams.Stream.define("Time", time=1.0)(), streams.PointerX().rename(x="limit")]
+
+integral_dmap = hv.DynamicMap(integral, streams=integral_streams)
+
+integral_dmap.opts(
+    opts.Area(color="#fff8dc", line_width=2), opts.Curve(color="black"), opts.VLine(color="red")
+)
+
+pn.Row(integral_dmap).show()

bencher/example/experimental/example_template.py

@@ -0,0 +1,40 @@
+import holoviews as hv
+import numpy as np
+import panel as pn
+
+pn.extension(sizing_mode="stretch_width")
+
+ACCENT_COLOR = pn.template.FastListTemplate.accent_base_color
+XS = np.linspace(0, np.pi)
+
+
+def sine(freq, phase):
+    return (
+        hv.Curve((XS, np.sin(XS * freq + phase)))
+        .opts(responsive=True, min_height=400, title="Sine", color=ACCENT_COLOR)
+        .opts(line_width=6)
+    )
+
+
+def cosine(freq, phase):
+    return (
+        hv.Curve((XS, np.cos(XS * freq + phase)))
+        .opts(responsive=True, min_height=400, title="Cosine", color=ACCENT_COLOR)
+        .opts(line_width=6)
+    )
+
+
+freq_widget = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
+phase_widget = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
+
+sine = pn.bind(sine, freq=freq_widget, phase=phase_widget)
+cosine = pn.bind(cosine, freq=freq_widget, phase=phase_widget)
+
+template = pn.template.FastListTemplate(
+    site="Panel",
+    title="FastListTemplate",
+    sidebar=[pn.pane.Markdown("## Settings"), freq_widget, phase_widget],
+    main=[
+        pn.pane.HoloViews(hv.DynamicMap(sine) + hv.DynamicMap(cosine), sizing_mode="stretch_both")
+    ],
+).show()