simba-uw-tf-dev 4.6.3__py3-none-any.whl → 4.6.6__py3-none-any.whl

simba/assets/lookups/tooptips.json

@@ -38,5 +38,10 @@
   "EGOCENTRIC_ANCHOR": "This body-part will be placed in the center of the video",
   "EGOCENTRIC_DIRECTION_ANCHOR": "This body-part will be placed at N degrees relative to the anchor",
   "EGOCENTRIC_DIRECTION": "The anchor body-part will always be placed at these degrees relative to the center anchor",
-  "CORE_COUNT": "Higher core counts speeds up processing but may require more RAM memory"
+  "CORE_COUNT": "Higher core counts speeds up processing but may require more RAM memory",
+  "KLEINBERG_SIGMA": "Higher values (e.g., 2-3) produce fewer but longer bursts; lower values (e.g., 1.1-1.5) detect more frequent, shorter bursts. Must be > 1.01",
+  "KLEINBERG_GAMMA": "Higher values (e.g., 0.5-1.0) reduce total burst count by making downward transitions costly; lower values (e.g., 0.1-0.3) allow more flexible state changes",
+  "KLEINBERG_HIERARCHY": "Hierarchy level to extract bursts from (0=lowest, higher=more selective).\n Level 0 captures all bursts; level 1-2 typically filters noise; level 3+ selects only the most prominent, sustained bursts.\nHigher levels yield fewer but more confident detections",
+  "KLEINBERG_HIERARCHY_SEARCH": "If True, searches for target hierarchy level within detected burst periods,\n falling back to lower levels if target not found. If False, extracts only bursts at the exact specified hierarchy level.\n Recommended when target hierarchy may be sparse.",
+  "KLEINBERG_SAVE_ORIGINALS": "If True, saves the original data in a new sub-directory of \nthe project_folder/csv/machine_results directory"
 }

simba/data_processors/cuda/geometry.py

@@ -8,6 +8,7 @@ from numba import cuda, njit
 
 from simba.utils.checks import check_float, check_valid_array
 from simba.utils.enums import Formats
+from simba.utils.printing import SimbaTimer
 
 try:
     import cupy as cp
@@ -401,20 +402,21 @@ def find_midpoints(x: np.ndarray,
 
 
 @cuda.jit()
-def _directionality_to_static_targets_kernel(left_ear, right_ear, nose, target, results):
+def _directionality_to_static_targets_kernel(left_ear, right_ear, nose, target_x, target_y, results):
     i = cuda.grid(1)
-    if i > left_ear.shape[0]:
+    if i >= left_ear.shape[0]:
         return
     else:
-        LE, RE = left_ear[i], right_ear[i]
-        N, Tx, Ty = nose[i], target[0], target[1]
-
-        Px = abs(LE[0] - Tx)
-        Py = abs(LE[1] - Ty)
-        Qx = abs(RE[0] - Tx)
-        Qy = abs(RE[1] - Ty)
-        Nx = abs(N[0] - Tx)
-        Ny = abs(N[1] - Ty)
+        LE = left_ear[i]
+        RE = right_ear[i]
+        N = nose[i]
+
+        Px = abs(LE[0] - target_x)
+        Py = abs(LE[1] - target_y)
+        Qx = abs(RE[0] - target_x)
+        Qy = abs(RE[1] - target_y)
+        Nx = abs(N[0] - target_x)
+        Ny = abs(N[1] - target_y)
         Ph = math.sqrt(Px * Px + Py * Py)
         Qh = math.sqrt(Qx * Qx + Qy * Qy)
         Nh = math.sqrt(Nx * Nx + Ny * Ny)
@@ -438,7 +440,8 @@ def _directionality_to_static_targets_kernel(left_ear, right_ear, nose, target,
 def directionality_to_static_targets(left_ear: np.ndarray,
                                      right_ear: np.ndarray,
                                      nose: np.ndarray,
-                                     target: np.ndarray) -> np.ndarray:
+                                     target: np.ndarray,
+                                     verbose: bool = False) -> np.ndarray:
     """
     GPU helper to calculate if an animal is directing towards a static location (e.g., ROI centroid), given the target location and the left ear, right ear, and nose coordinates of the observer.
 
@@ -487,32 +490,38 @@ def directionality_to_static_targets(left_ear: np.ndarray,
     >>> directionality_to_static_targets(left_ear=left_ear, right_ear=right_ear, nose=nose, target=target)
 
     """
-
+    timer = SimbaTimer(start=True)
     left_ear = np.ascontiguousarray(left_ear).astype(np.int32)
     right_ear = np.ascontiguousarray(right_ear).astype(np.int32)
     nose = np.ascontiguousarray(nose).astype(np.int32)
     target = np.ascontiguousarray(target).astype(np.int32)
 
+    target_x = int(target[0])
+    target_y = int(target[1])
+
     left_ear_dev = cuda.to_device(left_ear)
     right_ear_dev = cuda.to_device(right_ear)
     nose_dev = cuda.to_device(nose)
-    target_dev = cuda.to_device(target)
     results = cuda.device_array((left_ear.shape[0], 4), dtype=np.int32)
     bpg = (left_ear.shape[0] + (THREADS_PER_BLOCK - 1)) // THREADS_PER_BLOCK
-    _directionality_to_static_targets_kernel[bpg, THREADS_PER_BLOCK](left_ear_dev, right_ear_dev, nose_dev, target_dev, results)
+    _directionality_to_static_targets_kernel[bpg, THREADS_PER_BLOCK](left_ear_dev, right_ear_dev, nose_dev, target_x, target_y, results)
 
     results = results.copy_to_host()
+    timer.stop_timer()
+    if verbose: print(f'Directionality to static target computed in for {left_ear.shape[0]} observations (elapsed time: {timer.elapsed_time_str}s)')
     return results
 
 
 @cuda.jit()
 def _directionality_to_nonstatic_targets_kernel(left_ear, right_ear, nose, target, results):
     i = cuda.grid(1)
-    if i > left_ear.shape[0]:
+    if i >= left_ear.shape[0]:
         return
     else:
-        LE, RE = left_ear[i], right_ear[i]
-        N, T = nose[i], target[i]
+        LE = left_ear[i]
+        RE = right_ear[i]
+        N = nose[i]
+        T = target[i]
 
         Px = abs(LE[0] - T[0])
         Py = abs(LE[1] - T[1])
@@ -543,11 +552,19 @@ def _directionality_to_nonstatic_targets_kernel(left_ear, right_ear, nose, targe
 def directionality_to_nonstatic_target(left_ear: np.ndarray,
                                        right_ear: np.ndarray,
                                        nose: np.ndarray,
-                                       target: np.ndarray) -> np.ndarray:
+                                       target: np.ndarray,
+                                       verbose: bool = False) -> np.ndarray:
 
     """
     GPU method to calculate if an animal is directing towards a moving point location given the target location and the left ear, right ear, and nose coordinates of the observer.
 
+    .. csv-table::
+       :header: EXPECTED RUNTIMES
+       :file: ../../../docs/tables/directionality_to_nonstatic_target_cuda.csv
+       :widths: 30, 30, 20, 10, 10
+       :align: center
+       :class: simba-table
+       :header-rows: 1
 
     .. image:: _static/img/directing_moving_targets.png
        :width: 400
@@ -573,27 +590,28 @@ def directionality_to_nonstatic_target(left_ear: np.ndarray,
     >>> right_ear = np.random.randint(0, 500, (100, 2))
     >>> nose = np.random.randint(0, 500, (100, 2))
     >>> target = np.random.randint(0, 500, (100, 2))
-    >>> directionality_to_static_targets(left_ear=left_ear, right_ear=right_ear, nose=nose, target=target)
+    >>> directionality_to_nonstatic_target(left_ear=left_ear, right_ear=right_ear, nose=nose, target=target)
     """
 
-    left_ear = np.ascontiguousarray(left_ear).astype(np.int32)
-    right_ear = np.ascontiguousarray(right_ear).astype(np.int32)
-    nose = np.ascontiguousarray(nose).astype(np.int32)
-    target = np.ascontiguousarray(target).astype(np.int32)
+    timer = SimbaTimer(start=True)
+    left_ear = np.ascontiguousarray(left_ear).astype(np.int64)
+    right_ear = np.ascontiguousarray(right_ear).astype(np.int64)
+    nose = np.ascontiguousarray(nose).astype(np.int64)
+    target = np.ascontiguousarray(target).astype(np.int64)
 
     left_ear_dev = cuda.to_device(left_ear)
     right_ear_dev = cuda.to_device(right_ear)
     nose_dev = cuda.to_device(nose)
     target_dev = cuda.to_device(target)
-    results = cuda.device_array((left_ear.shape[0], 4), dtype=np.int32)
+    results = cuda.device_array((left_ear.shape[0], 4), dtype=np.int64)
     bpg = (left_ear.shape[0] + (THREADS_PER_BLOCK - 1)) // THREADS_PER_BLOCK
     _directionality_to_nonstatic_targets_kernel[bpg, THREADS_PER_BLOCK](left_ear_dev, right_ear_dev, nose_dev, target_dev, results)
 
     results = results.copy_to_host()
+    timer.stop_timer()
+    if verbose: print(f'Directionality to moving target computed in for {left_ear.shape[0]} observations (elapsed time: {timer.elapsed_time_str}s)')
     return results
 
 
 
 
-
-