introduce benchmarking

Author: BenjaminMidtvedt

deeptrack/benchmarks/test_simulate_mie.py

@@ -0,0 +1,64 @@
+import sys
+import numpy as np
+import itertools
+import deeptrack as dt
+
+u = dt.units
+
+
+def create_pipeline(output_region=(0, 0, 128, 128), num_particles=1):
+
+    optics = dt.Brightfield(output_region=output_region)
+
+    mie = dt.MieSphere(
+        radius=0.5e-6,
+        refractive_index=1.45,
+        z=lambda: np.random.randn() * 10,
+        position=lambda: output_region[2:] * np.random.randn(2),
+        L=10,
+    )
+
+    field = optics(mie ^ num_particles)
+    return field
+
+
+def test_simulate_mie_128_1(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 128, 128), num_particles=1)
+    benchmark(
+        lambda: pipeline.update()(),
+    )
+
+
+def test_simulate_mie_128_5(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 128, 128), num_particles=5)
+    benchmark(
+        lambda: pipeline.update()(),
+    )
+
+
+def test_simulate_mie_512_1(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 512, 512), num_particles=1)
+    benchmark(
+        lambda: pipeline.update()(),
+    )
+
+
+def test_simulate_mie_512_5(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 512, 512), num_particles=5)
+    benchmark(
+        lambda: pipeline.update()(),
+    )
+
+
+def test_simulate_mie_1024_1(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 1024, 1024), num_particles=1)
+    benchmark(
+        lambda: pipeline.update()(),
+    )
+
+
+def test_simulate_mie_1024_5(benchmark):
+    pipeline = create_pipeline(output_region=(0, 0, 1024, 1024), num_particles=5)
+    benchmark(
+        lambda: pipeline.update()(),
+    )

deeptrack/features.py

@@ -1031,12 +1031,18 @@ class BindUpdate(StructuralFeature):
     __distributed__ = False
 
     def __init__(self, feature: Feature, **kwargs):
-        self.feature = feature
+        import warnings
+
+        warnings.warn(
+            "BindUpdate is deprecated and may be removed in a future release. Please use BindResolve in conjunction with Arguments.",
+            DeprecationWarning,
+        )
+        self.feature = self.add_feature(feature)
         super().__init__(**kwargs)
 
-    def _update(self, **kwargs):
-        super()._update(**kwargs)
-        self.feature._update(**{**kwargs, **self.properties})
+    def update(self, **kwargs):
+        super().update(**kwargs)
+        self.feature.update(**{**kwargs, **self.properties})
 
     def get(self, image, **kwargs):
         return self.feature.resolve(image, **kwargs)

deeptrack/image.py

@@ -16,12 +16,24 @@
     Transforms.
 """
 
+import warnings
 import numpy as np
 import numpy.lib.mixins
 import operator as ops
 from tensorflow import Tensor
 from .backend.tensorflow_bindings import TENSORFLOW_BINDINGS
 
+CUPY_INSTALLED = False
+try:
+    import cupy as cp
+
+    CUPY_INSTALLED = True
+except Exception as e:
+    CUPY_INSTALLED = False
+    warnings.warn(
+        "cupy not installed. GPU-accelerated simulations will not be possible"
+    )
+
 
 def _binary_method(op):
     """Implement a forward binary method with a noperator, e.g., __add__."""
@@ -257,9 +269,16 @@ def __array_function__(self, func, types, args, kwargs):
             else:
                 return NotImplemented
 
+        elif not (
+            isinstance(self._value, (np.ndarray, tuple, list))
+            or np.isscalar(self._value)
+        ) and not hasattr(self._value, "__array_function__"):
+            print(func, type(self._value), self._value)
+            return NotImplemented
+
         out = func(*values, **kwargs)
 
-        if isinstance(out, bool):
+        if isinstance(out, (bool, int, float)):
             return out
 
         out = Image(out)
@@ -270,7 +289,7 @@ def __array_function__(self, func, types, args, kwargs):
         return out
 
     def __array__(self):
-        return np.array(self._value)
+            return np.array(self._value)
 
     def __getattr__(self, key):
         return getattr(self._value, key)

deeptrack/test/test_elementwise.py

@@ -12,6 +12,7 @@
 from .. import elementwise, features, Image
 
 import numpy as np
+import cupy as cp
 import numpy.testing
 import inspect
 
@@ -42,6 +43,12 @@ def grid_test_features(
 
             expected_result = expected_result_function(f_a_input)
 
+            if isinstance(output._value, cp.ndarray):
+                output = output.get()
+
+            if isinstance(expected_result, cp.ndarray):
+                expected_result = expected_result.get()
+
             if isinstance(output, list) and isinstance(expected_result, list):
                 [
                     np.testing.assert_almost_equal(np.array(a), np.array(b))
@@ -68,7 +75,15 @@ def test(self):
         grid_test_features(
             self,
             cl,
-            [-1, 0, 1, (np.random.rand(50, 500) - 0.5) * 100, np.inf, np.nan],
+            [
+                -1,
+                0,
+                1,
+                (np.random.rand(50, 500) - 0.5) * 100,
+                (cp.random.rand(50, 500) - 0.5) * 100,
+                np.inf,
+                np.nan,
+            ],
             np.__dict__[cl.__name__.lower()],
         )
 

pyproject.toml

@@ -0,0 +1,5 @@
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = [
+    "deeptrack/benchmarks",
+]