holobench 1.3.6__py2.py3-none-any.whl

bencher/example/example_simple_float.py

@@ -0,0 +1,38 @@
+"""This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
+import bencher as bch
+
+# All the examples will be using the data structures and benchmark function defined in this file
+from bencher.example.benchmark_data import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
+
+
+def example_1D_float(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> 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 = bch.Bench(
+        "benchmarking_example_float1D",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
+    bench.plot_sweep(
+        title="Example 1D Float",
+        input_vars=[ExampleBenchCfgIn.param.theta],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        description=example_1D_float.__doc__,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.repeats = 2
+    # ex_run_cfg.over_time = True
+
+    example_1D_float(ex_run_cfg).report.show()

bencher/example/example_strings.py

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

bencher/example/example_time_event.py

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

bencher/example/example_video.py

@@ -0,0 +1,124 @@
+import bencher as bch
+import numpy as np
+import matplotlib.pyplot as plt
+import panel as pn
+
+
+# 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()
+
+    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.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
+    tp = TuringPattern()
+
+    run_cfg.use_sample_cache = False
+    # run_cfg.use_optuna = True
+    run_cfg.auto_plot = False
+    run_cfg.run_tag = "3"
+    bench = tp.to_bench(run_cfg=run_cfg, report=report)
+
+    res = bench.plot_sweep(
+        "phase",
+        input_vars=["alpha", "beta"],
+        # result_vars=["video","score"],
+        run_cfg=run_cfg,
+    )
+
+    bench.report.append(res.describe_sweep())
+    bench.report.append(
+        res.to_heatmap(tp.param.score, tap_var=tp.param.video, tap_container=pn.pane.Video)
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    run_cfg_ex = bch.BenchRunCfg()
+    run_cfg_ex.level = 2
+
+    # 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()