simba-uw-tf-dev 5.2.7__tar.gz → 5.2.9__tar.gz

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.2.7
+Version: 5.2.9
 Summary: Toolkit for computer classification and analysis of behaviors in experimental animals
 Home-page: https://github.com/sgoldenlab/simba
 Author: Simon Nilsson, Jia Jie Choong, Sophia Hwang

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/requirements_gpu.txt

@@ -4,4 +4,5 @@ shap==0.46.1.dev78
 cuml-cu12==24.12.0
 torch==2.5.0
 ultralytics==8.4.9
+pynvvideocodec==2.1.0
 nvidia-cuda-runtime-cu12

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/setup.py

@@ -29,7 +29,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="5.2.7",
+    version="5.2.9",
     author="Simon Nilsson, Jia Jie Choong, Sophia Hwang",
     author_email="sronilsson@gmail.com",
     description="Toolkit for computer classification and analysis of behaviors in experimental animals",

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/data_processors/cuda/utils.py

@@ -315,7 +315,8 @@ def get_nvc_decoder(video_path: Union[str, os.PathLike],
                     gpu_id: int = 0,
                     use_device_memory: bool = False):
 
-    from simba.utils.checks import (check_file_exist_and_readable, check_instance, check_int)
+    from simba.utils.checks import (check_file_exist_and_readable,
+                                    check_instance, check_int)
     from simba.utils.errors import SimBAGPUError
 
     if nvc is None:

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/data_processors/kleinberg_calculator.py

@@ -1,18 +1,16 @@
 __author__ = "Simon Nilsson; sronilsson@gmail.com"
 
-import glob
 import os
-import shutil
 from copy import deepcopy
 from typing import List, Optional, Union
 
 import numpy as np
 import pandas as pd
 
-from simba.data_processors.pybursts_calculator import kleinberg_burst_detection
+from simba.data_processors.pybursts_calculator import kleinberg_burst_detection as kleinberg_burst_detection_og
+from simba.data_processors.pybursts_calculator_numba import kleinberg_burst_detection as kleinberg_burst_detection_numba
 from simba.mixins.config_reader import ConfigReader
-from simba.utils.checks import (check_float, check_if_dir_exists,
-                                check_if_filepath_list_is_empty, check_int,
+from simba.utils.checks import (check_float, check_if_dir_exists,check_int,
                                 check_that_column_exist, check_valid_boolean,
                                 check_valid_lst)
 from simba.utils.enums import Paths, TagNames
@@ -49,6 +47,7 @@ class KleinbergCalculator(ConfigReader):
     :param Optional[Union[str, os.PathLike]] input_dir: The directory with files to perform kleinberg smoothing on. If None, defaults to `project_folder/csv/machine_results`
     :param Optional[Union[str, os.PathLike]] output_dir: Location to save smoothened data in. If None, defaults to `project_folder/csv/machine_results`
     :param Optional[bool] save_originals: If True, saves the original data in sub-directory of the ouput directory.`
+    :param bool numba: If True, uses Numba JIT-accelerated burst detection for faster computation. Default: False.
 
     :example I:
     >>> kleinberg_calculator = KleinbergCalculator(config_path='MySimBAConfigPath', classifier_names=['Attack'], sigma=2, gamma=0.3, hierarchy=2, hierarchical_search=False)
@@ -81,7 +80,8 @@ class KleinbergCalculator(ConfigReader):
                  save_originals: bool = True,
                  hierarchical_search: Optional[bool] = False,
                  input_dir: Optional[Union[str, os.PathLike]] = None,
-                 output_dir: Optional[Union[str, os.PathLike]] = None):
+                 output_dir: Optional[Union[str, os.PathLike]] = None,
+                 numba: bool = True):
 
         ConfigReader.__init__(self, config_path=config_path)
         log_event(logger_name=str(self.__class__.__name__), log_type=TagNames.CLASS_INIT.value, msg=self.create_log_msg_from_init_args(locals=locals()))
@@ -96,7 +96,9 @@ class KleinbergCalculator(ConfigReader):
         check_valid_boolean(value=save_originals, source=f'{self.__class__.__name__} save_originals', raise_error=True)
         self.hierarchical_search, sigma, gamma, hierarchy, self.output_dir = (hierarchical_search, float(sigma), float(gamma), int(hierarchy), output_dir)
         self.sigma, self.gamma, self.hierarchy, self.clfs = ( float(sigma), float(gamma), int(hierarchy), classifier_names)
+        check_valid_boolean(value=numba, source=f'{self.__class__.__name__} numba', raise_error=True)
         self.verbose, self.save_originals = verbose, save_originals
+        self.kleinberg_burst_detection = kleinberg_burst_detection_numba if numba else kleinberg_burst_detection_og
         if input_dir is None:
             self.input_dir = os.path.join(self.project_path, Paths.MACHINE_RESULTS_DIR.value)
         else:
@@ -157,7 +159,7 @@ class KleinbergCalculator(ConfigReader):
                 clf_offsets = data_df.index[data_df[clf] == 1].values
                 if len(clf_offsets) > 0:
                     video_out_df[clf] = 0
-                    self.kleinberg_bouts = pd.DataFrame(kleinberg_burst_detection(offsets=clf_offsets, s=self.sigma, gamma=self.gamma), columns=["Hierarchy", "Start", "Stop"])
+                    self.kleinberg_bouts = pd.DataFrame(self.kleinberg_burst_detection(offsets=clf_offsets, s=self.sigma, gamma=self.gamma), columns=["Hierarchy", "Start", "Stop"])
                     self.kleinberg_bouts["Stop"] += 1
                     self.kleinberg_bouts.insert(loc=0, column="Classifier", value=clf)
                     self.kleinberg_bouts.insert(loc=0, column="Video", value=video_name)
@@ -167,10 +169,12 @@ class KleinbergCalculator(ConfigReader):
                         self.hierarchical_searcher()
                     else:
                         self.clf_bouts_in_hierarchy = self.kleinberg_bouts[self.kleinberg_bouts["Hierarchy"] == self.hierarchy]
-                    hierarchy_idx = list(self.clf_bouts_in_hierarchy.apply(lambda x: list(range(x["Start"], x["Stop"] + 1)), 1))
-                    hierarchy_idx = [x for xs in hierarchy_idx for x in xs]
-                    hierarchy_idx = [x for x in hierarchy_idx if x in list(data_df.index)]
-                    video_out_df.loc[hierarchy_idx, clf] = 1
+                    if len(self.clf_bouts_in_hierarchy) > 0:
+                        starts = self.clf_bouts_in_hierarchy["Start"].values
+                        stops = self.clf_bouts_in_hierarchy["Stop"].values + 1
+                        hierarchy_idx = np.concatenate([np.arange(s, e) for s, e in zip(starts, stops)])
+                        hierarchy_idx = hierarchy_idx[np.isin(hierarchy_idx, data_df.index)]
+                        video_out_df.loc[hierarchy_idx, clf] = 1
             write_df(video_out_df, self.file_type, save_path)
             video_timer.stop_timer()
             if self.verbose: print(f'[{get_current_time()}] Kleinberg analysis complete for video {video_name} (saved at {save_path}), elapsed time: {video_timer.elapsed_time_str}s.')

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/data_processors/movement_calculator.py

@@ -21,6 +21,7 @@ from simba.utils.errors import FrameRangeError, InvalidInputError, NoDataError
 from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_fn_ext, read_df, seconds_to_timestamp)
+from simba.utils.warnings import MissingFileWarning
 
 START, END = 'START', 'END'
 
@@ -151,9 +152,6 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
                     raise FrameRangeError(msg=f'Cannot compute movement between frame {start_frm} (time s: {start_time}) and frame {end_frm} (time s: {end_time}) in video {video_name}. The data only has {len(self.data_df)} frames.', source=self.__class__.__name__)
                 self.data_df = self.data_df.loc[start_frm:end_frm].reset_index()
                 if self.verbose: stdout_information(msg=f"Slicing video {video_name} between frames {start_frm} and {end_frm}...)")
-            else:
-                start_frm, end_frm = int(0 * self.fps), int(899 * self.fps)
-                self.data_df = self.data_df.loc[start_frm:end_frm].reset_index()
             if self.bp_list:
                 check_that_column_exist(df=self.data_df, column_name=self.bp_list, file_name=file_path)
                 self.data_df = self.data_df[self.bp_list]
@@ -212,7 +210,7 @@ if __name__ == "__main__" and not hasattr(sys, 'ps1'):
     runner.save()
 
 
-# TIME_TIME_PATH = r"F:\troubleshooting\sam\sam\project_folder\DATA MASTERSHEET (1).csv"
+# TIME_TIME_PATH = r"F:\troubleshooting\sam\sam\project_folder\DATA MASTERSHEET_0428_PRE_ISO.csv"
 # time_stamps = pd.read_csv(TIME_TIME_PATH)[['VIDEO_FILE_NAME', 'START', 'END']].set_index('VIDEO_FILE_NAME').to_dict(orient='index')
 # test = MovementCalculator(config_path=r"F:\troubleshooting\sam\sam\project_folder\project_config.ini",
 #                           body_parts=['center'],  #['Simon CENTER OF GRAVITY', 'JJ CENTER OF GRAVITY', 'Animal_1 CENTER OF GRAVITY']

simba_uw_tf_dev-5.2.9/simba/data_processors/pybursts_calculator.py

@@ -0,0 +1,162 @@
+### CODE MODIFID FROM PYBURST PACKAGE  https://pypi.org/project/pybursts/
+import math
+
+import numpy as np
+
+
+def kleinberg_burst_detection(offsets: np.ndarray, s: float, gamma: float):
+    """
+    Detect hierarchical bursts in a 1D sequence of event times using Kleinberg's two-state infinite-state automaton (modified from `pybursts <https://pypi.org/project/pybursts/>`_).
+
+    Bursts are intervals where events arrive at a higher-than-baseline rate. The algorithm assigns each inter-event gap to a discrete *level* ``q``: level ``0`` is baseline, higher levels (1, 2, …) are progressively faster (higher-rate) bursts. Each level transition opens or closes a burst at that level, producing a hierarchy of nested bursts.
+
+    .. note::
+       Private helper used by :class:`~simba.data_processors.kleinberg_calculator.KleinbergCalculator`.
+       For an end-to-end pipeline (frame indices → bouts → bursts), use that class.
+
+    :param np.ndarray offsets: 1D numeric array of event times (seconds, frame indices, or any monotonically meaningful unit). May be unsorted; sorted internally. Must have **strictly positive gaps** (no two events at the same time).
+    :param float s: Base of the rate scale (``> 1``). The candidate rate at level ``j`` is ``s**j / mean_gap``, so larger ``s`` means levels grow farther apart and bursts must be more pronounced to reach higher levels. Common choice: ``s = 2``.
+    :param float gamma: Cost of moving up one level (``>= 0``). Higher ``gamma`` penalizes rising into a burst, producing fewer / shorter bursts. Lower ``gamma`` makes the detector more sensitive. Common choice: ``gamma = 1``.
+
+    :returns: 2D ``np.ndarray`` of shape ``(N, 3)`` and ``dtype=object`` with one row per detected burst, columns ``[level, start_offset, end_offset]``:
+
+        * ``level`` — integer burst level (``0`` is the baseline level, higher levels are nested faster bursts).
+        * ``start_offset`` — value from ``offsets`` where this burst opens.
+        * ``end_offset`` — value from ``offsets`` where this burst closes (inclusive of the last event in the run).
+
+        For a single-event input, returns a single row ``[0, offsets[0], offsets[0]]``.
+    :rtype: np.ndarray
+
+    :raises ValueError: If ``offsets`` contains two or more events at the same time (zero gap).
+
+    .. seealso::
+       :func:`~simba.data_processors.pybursts_calculator_numba.kleinberg_burst_detection` for Numba JIT-accelerated version.
+
+    .. csv-table:: EXPECTED RUNTIMES
+       :file: ../../docs/tables/kleinberg_burst_detection.csv
+       :widths: 20, 15, 20, 20, 15
+       :align: center
+       :header-rows: 1
+
+    :example:
+    >>> import numpy as np
+    >>> from simba.data_processors.pybursts_calculator import kleinberg_burst_detection
+    >>> offsets = np.array([1.0, 1.1, 1.2, 5.0, 9.0, 9.05, 9.1])
+    >>> bursts = kleinberg_burst_detection(offsets=offsets, s=2.0, gamma=1.0)
+    >>> bursts.shape[1]
+    3
+    """
+
+    offsets = np.array(offsets, dtype=object)
+
+    if offsets.size == 1:
+        bursts = np.array([0, offsets[0], offsets[0]], ndmin=2, dtype=object)
+        return bursts
+
+    offsets = np.sort(offsets)
+    gaps = np.diff(offsets)
+
+    if not np.all(gaps):
+        raise ValueError("Input cannot contain events with zero time between!")
+
+    T = np.sum(gaps)
+    n = np.size(gaps)
+
+    g_hat = T / n
+
+    k = int(math.ceil(float(1 + math.log(T, s) + math.log(1 / np.amin(gaps), s))))
+
+    gamma_log_n = gamma * math.log(n)
+
+    def tau(i, j):
+        if i >= j:
+            return 0
+        else:
+            return (j - i) * gamma_log_n
+
+    alpha_function = np.vectorize(lambda x: s**x / g_hat)
+    alpha = alpha_function(np.arange(k))
+
+    log_alpha = np.log(alpha)
+
+    C = np.repeat(float("inf"), k)
+    C[0] = 0
+
+    q = np.empty((k, 0))
+    for t in range(n):
+        C_prime = np.repeat(float("inf"), k)
+        q_prime = np.empty((k, t + 1))
+        q_prime.fill(np.nan)
+
+        for j in range(k):
+            cost_function = np.vectorize(lambda x: C[x] + tau(x, j))
+            cost = cost_function(np.arange(0, k))
+
+            el = np.argmin(cost)
+
+            C_prime[j] = cost[el] - log_alpha[j] + alpha[j] * gaps[t]
+
+            if t > 0:
+                q_prime[j, :t] = q[el, :]
+
+            q_prime[j, t] = j + 1
+
+        C = C_prime
+        q = q_prime
+
+    j = np.argmin(C)
+    q = q[j, :]
+
+    prev_q = 0
+
+    N = 0
+    for t in range(n):
+        if q[t] > prev_q:
+            N = N + q[t] - prev_q
+        prev_q = q[t]
+
+    bursts = np.array(
+        [np.repeat(np.nan, N), np.repeat(offsets[0], N), np.repeat(offsets[0], N)],
+        ndmin=2,
+        dtype=object,
+    ).transpose()
+    burst_counter = -1
+    prev_q = 0
+    stack = np.repeat(np.nan, N)
+    stack_counter = -1
+    for t in range(n):
+        if q[t] > prev_q:
+            num_levels_opened = q[t] - prev_q
+            for i in range(int(num_levels_opened)):
+                burst_counter += 1
+                bursts[burst_counter, 0] = prev_q + i
+                bursts[burst_counter, 1] = offsets[t]
+                stack_counter += 1
+                stack[stack_counter] = burst_counter
+        elif q[t] < prev_q:
+            num_levels_closed = prev_q - q[t]
+            for i in range(int(num_levels_closed)):
+                bursts[int(stack[stack_counter]), 2] = offsets[t]
+                stack_counter -= 1
+        prev_q = q[t]
+
+    while stack_counter >= 0:
+        bursts[int(stack[stack_counter]), 2] = offsets[n]
+        stack_counter -= 1
+
+    return bursts
+#
+#
+# if __name__ == "__main__":
+#     import time
+#
+#     np.random.seed(42)
+#     sizes = [100, 1_000, 10_000, 100_000, 1_000_000]
+#     s, gamma = 2.0, 0.3
+#
+#     for n in sizes:
+#         offsets = np.sort(np.cumsum(np.random.exponential(scale=1.0, size=n)))
+#         start = time.perf_counter()
+#         result = kleinberg_burst_detection(offsets=offsets, s=s, gamma=gamma)
+#         elapsed = time.perf_counter() - start
+#         print(f"n={n:>10,}  bursts={result.shape[0]:>6,}  time={elapsed:.4f}s")

simba_uw_tf_dev-5.2.9/simba/data_processors/pybursts_calculator_numba.py

@@ -0,0 +1,181 @@
+### CODE MODIFID FROM PYBURST PACKAGE  https://pypi.org/project/pybursts/
+import math
+from typing import Union
+
+import numpy as np
+from numba import njit, float64, int64
+
+from simba.utils.checks import check_float
+from simba.utils.errors import ArrayError, FloatError, InvalidInputError
+
+
+@njit("float64[:](float64[:], int64, float64[:], float64)", cache=True)
+def _kleinberg_viterbi(gaps: np.ndarray, k: int, alpha: np.ndarray, gamma_log_n: float) -> np.ndarray:
+    """Numba-accelerated Viterbi forward pass with backpointer traceback."""
+    n = gaps.shape[0]
+    log_alpha = np.empty(k)
+    for j in range(k):
+        log_alpha[j] = math.log(alpha[j])
+    C = np.full(k, np.inf)
+    C[0] = 0.0
+    C_prime = np.empty(k)
+    backptr = np.empty((n, k), dtype=np.int64)
+
+    for t in range(n):
+        for j in range(k):
+            best_cost = np.inf
+            best_i = 0
+            for i in range(k):
+                tc = 0.0 if i >= j else (j - i) * gamma_log_n
+                cost = C[i] + tc
+                if cost < best_cost:
+                    best_cost = cost
+                    best_i = i
+            C_prime[j] = best_cost - log_alpha[j] + alpha[j] * gaps[t]
+            backptr[t, j] = best_i
+        for j in range(k):
+            C[j] = C_prime[j]
+
+    best_j = 0
+    best_val = C[0]
+    for j in range(1, k):
+        if C[j] < best_val:
+            best_val = C[j]
+            best_j = j
+
+    states = np.empty(n, dtype=np.int64)
+    states[n - 1] = best_j
+    for t in range(n - 2, -1, -1):
+        states[t] = backptr[t + 1, states[t + 1]]
+
+    q = np.empty(n, dtype=np.float64)
+    for t in range(n):
+        q[t] = float(states[t] + 1)
+    return q
+
+
+def kleinberg_burst_detection(offsets: np.ndarray, s: float, gamma: float) -> np.ndarray:
+    """
+    Detect hierarchical bursts in a 1D sequence of event times using Kleinberg's two-state infinite-state automaton (modified from `pybursts <https://pypi.org/project/pybursts/>`_).
+
+    Bursts are intervals where events arrive at a higher-than-baseline rate. The algorithm assigns each inter-event gap to a discrete *level* ``q``: level ``0`` is baseline, higher levels (1, 2, …) are progressively faster (higher-rate) bursts. Each level transition opens or closes a burst at that level, producing a hierarchy of nested bursts.
+
+    .. note::
+       Private helper used by :class:`~simba.data_processors.kleinberg_calculator.KleinbergCalculator`.
+       For an end-to-end pipeline (frame indices → bouts → bursts), use that class.
+
+    :param np.ndarray offsets: 1D numeric array of event times (seconds, frame indices, or any monotonically meaningful unit). May be unsorted; sorted internally. Must have **strictly positive gaps** (no two events at the same time).
+    :param float s: Base of the rate scale (``> 1``). The candidate rate at level ``j`` is ``s**j / mean_gap``, so larger ``s`` means levels grow farther apart and bursts must be more pronounced to reach higher levels. Common choice: ``s = 2``.
+    :param float gamma: Cost of moving up one level (``>= 0``). Higher ``gamma`` penalizes rising into a burst, producing fewer / shorter bursts. Lower ``gamma`` makes the detector more sensitive. Common choice: ``gamma = 1``.
+
+    :returns: 2D ``np.ndarray`` of shape ``(N, 3)`` and ``dtype=object`` with one row per detected burst, columns ``[level, start_offset, end_offset]``:
+
+        * ``level`` — integer burst level (``0`` is the baseline level, higher levels are nested faster bursts).
+        * ``start_offset`` — value from ``offsets`` where this burst opens.
+        * ``end_offset`` — value from ``offsets`` where this burst closes (inclusive of the last event in the run).
+
+        For a single-event input, returns a single row ``[0, offsets[0], offsets[0]]``.
+    :rtype: np.ndarray
+
+    :raises FloatError: If ``s`` is not a valid float or is <= 1.0.
+    :raises FloatError: If ``gamma`` is not a valid float or is < 0.
+    :raises ArrayError: If ``offsets`` is not a valid numpy array.
+    :raises InvalidInputError: If ``offsets`` has fewer than 1 element.
+    :raises InvalidInputError: If ``offsets`` contains duplicate values (zero gaps).
+
+    .. seealso::
+       :func:`~simba.data_processors.pybursts_calculator.kleinberg_burst_detection` for non-Numba version.
+
+    .. csv-table:: EXPECTED RUNTIMES
+       :file: ../../docs/tables/kleinberg_burst_detection.csv
+       :widths: 20, 15, 20, 20, 15
+       :align: center
+       :header-rows: 1
+
+    :example:
+    >>> import numpy as np
+    >>> from simba.data_processors.pybursts_calculator_numba import kleinberg_burst_detection
+    >>> offsets = np.array([1.0, 1.1, 1.2, 5.0, 9.0, 9.05, 9.1])
+    >>> bursts = kleinberg_burst_detection(offsets=offsets, s=2.0, gamma=1.0)
+    >>> bursts.shape[1]
+    3
+    """
+
+    check_float(name=f'{kleinberg_burst_detection.__name__} s', value=s, min_value=1.01)
+    check_float(name=f'{kleinberg_burst_detection.__name__} gamma', value=gamma, min_value=0.0)
+    if not isinstance(offsets, (np.ndarray, list, tuple)):
+        raise ArrayError(msg=f'offsets should be a numpy array, list, or tuple, but got {type(offsets)}', source=kleinberg_burst_detection.__name__)
+    offsets = np.array(offsets, dtype=np.float64)
+    if offsets.size < 1:
+        raise InvalidInputError(msg=f'offsets must have at least 1 element, but got {offsets.size}', source=kleinberg_burst_detection.__name__)
+
+    if offsets.size == 1:
+        bursts = np.array([0, offsets[0], offsets[0]], ndmin=2, dtype=object)
+        return bursts
+
+    offsets = np.sort(offsets)
+    gaps = np.diff(offsets)
+
+    if not np.all(gaps):
+        raise InvalidInputError(msg=f'offsets contains duplicate values (zero-length gaps between events). All offsets must be unique.', source=kleinberg_burst_detection.__name__)
+
+    T = float(np.sum(gaps))
+    n = gaps.size
+    g_hat = T / n
+    k = int(math.ceil(1.0 + math.log(T, s) + math.log(1.0 / float(np.amin(gaps)), s)))
+    gamma_log_n = gamma * math.log(n)
+    alpha = np.array([s ** j / g_hat for j in range(k)], dtype=np.float64)
+
+    q = _kleinberg_viterbi(gaps, k, alpha, gamma_log_n)
+
+    prev_q = 0.0
+    N = 0
+    for t in range(n):
+        if q[t] > prev_q:
+            N += int(q[t] - prev_q)
+        prev_q = q[t]
+
+    bursts = np.empty((N, 3), dtype=object)
+    burst_counter = -1
+    prev_q = 0.0
+    stack = np.empty(N, dtype=np.int64)
+    stack_counter = -1
+    for t in range(n):
+        if q[t] > prev_q:
+            num_levels_opened = int(q[t] - prev_q)
+            for i in range(num_levels_opened):
+                burst_counter += 1
+                bursts[burst_counter, 0] = int(prev_q + i)
+                bursts[burst_counter, 1] = int(offsets[t])
+                stack_counter += 1
+                stack[stack_counter] = burst_counter
+        elif q[t] < prev_q:
+            num_levels_closed = int(prev_q - q[t])
+            for i in range(num_levels_closed):
+                bursts[stack[stack_counter], 2] = int(offsets[t])
+                stack_counter -= 1
+        prev_q = q[t]
+
+    while stack_counter >= 0:
+        bursts[stack[stack_counter], 2] = int(offsets[n])
+        stack_counter -= 1
+
+    return bursts
+#
+#
+# if __name__ == "__main__":
+#     import time
+#
+#     np.random.seed(42)
+#     sizes = [100, 1_000, 10_000, 100_000, 1_000_000]
+#     s, gamma = 2.0, 0.3
+#
+#     # warm up numba JIT
+#     _ = kleinberg_burst_detection(offsets=np.arange(10, dtype=np.float64), s=s, gamma=gamma)
+#
+#     for n in sizes:
+#         offsets = np.sort(np.cumsum(np.random.exponential(scale=1.0, size=n)))
+#         start = time.perf_counter()
+#         result = kleinberg_burst_detection(offsets=offsets, s=s, gamma=gamma)
+#         elapsed = time.perf_counter() - start
+#         print(f"n={n:>10,}  bursts={result.shape[0]:>6,}  time={elapsed:.4f}s")

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/labelling/labelling_interface.py

@@ -317,9 +317,8 @@ class LabellingInterface(ConfigReader):
         start_frm, end_frm = int(start_frm), int(end_frm)
         if start_frm >= end_frm:
             raise FrameRangeError(msg=f'The RANGE START FRAME ({start_frm}) has to be smaller than the RANGE END FRAME ({end_frm})', source=self.__class__.__name__)
-        for frm_no in range(int(start_frm), int(end_frm) + 1):
-            for target in self.clf_names:
-                self.data_df_targets[target].loc[frm_no] = self.clf_cbs[target].get()
+        for target in self.clf_names:
+            self.data_df_targets[target].loc[start_frm:end_frm] = int(self.clf_cbs[target].get())
         self.set_img(img_lbl=self.img_lbl, video_path=self.video_path, img_idx=end_frm)
         self.current_frm_eb.entry_set(end_frm)
         self.img_idx = deepcopy(end_frm)

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/labelling/standard_labeller.py

@@ -28,7 +28,8 @@ from simba.utils.checks import (check_file_exist_and_readable, check_int,
                                 check_valid_dataframe, check_valid_dict,
                                 check_video_and_data_frm_count_align)
 from simba.utils.enums import Formats, TagNames
-from simba.utils.errors import FrameRangeError, NoDataError, NoFilesFoundError
+from simba.utils.errors import (FrameRangeError, NoDataError,
+                                NoFilesFoundError, SimbaError)
 from simba.utils.lookups import (get_current_time, get_display_resolution,
                                  get_img_resize_info,
                                  get_labelling_img_kbd_bindings,
@@ -166,7 +167,7 @@ class LabellingInterface(ConfigReader):
         self.forward_btn = SimbaButton(parent=self.navigation_frm, txt="", img='play_large_green', tooltip_txt="+1 FRAME", cmd=self.__advance_frame, cmd_kwargs={'frm_id': lambda: self.img_idx + 1})
         self.last_frm_btn = SimbaButton(parent=self.navigation_frm, txt="", img='skip_forward_large', tooltip_txt="GO TO LAST FRAME", cmd=self.__advance_frame, cmd_kwargs={'frm_id': self.max_frm_id})
 
-        self.set_img(img_lbl=self.img_lbl, video_path=self.video_path, img_idx=self.img_idx, display_size=self.img_display_size)
+        self.set_img(img_lbl=self.img_lbl, video_path=self.cap, img_idx=self.img_idx, display_size=self.img_display_size)
 
         self.navigation_frm.grid(row=2, column=0, sticky=NSEW, pady=10, padx=10, columnspan=1)
         self.current_frm_eb.grid(row=0, column=0, sticky=EW, columnspan=4)
@@ -350,7 +351,7 @@ class LabellingInterface(ConfigReader):
                 else:
                     self.clf_cbs[clf].set(bool(self.data_df_targets[clf].loc[frm_id]))
             self.img_idx = deepcopy(frm_id)
-            self.set_img(img_lbl=self.img_lbl, video_path=self.video_path, img_idx=frm_id, display_size=self.img_display_size)
+            self.set_img(img_lbl=self.img_lbl, video_path=self.cap, img_idx=frm_id, display_size=self.img_display_size)
 
     def __save_behavior_in_range(self,
                                  start_frm: int,
@@ -361,13 +362,12 @@ class LabellingInterface(ConfigReader):
         start_frm, end_frm = int(start_frm), int(end_frm)
         if start_frm >= end_frm:
             raise FrameRangeError(msg=f'The RANGE START FRAME ({start_frm}) has to be smaller than the RANGE END FRAME ({end_frm})', source=self.__class__.__name__)
-        for frm_no in range(int(start_frm), int(end_frm) + 1):
-            for target in self.clf_names:
-                self.data_df_targets[target].loc[frm_no] = int(self.clf_cbs[target].get())
-        self.set_img(img_lbl=self.img_lbl, video_path=self.video_path, img_idx=end_frm, display_size=self.img_display_size)
+        for target in self.clf_names:
+            self.data_df_targets[target].loc[start_frm:end_frm] = int(self.clf_cbs[target].get())
         self.current_frm_eb.entry_set(end_frm)
         self.img_idx = deepcopy(end_frm)
         self.__create_print_statements(frame=(start_frm, end_frm))
+        self.main_window.after(1, lambda: self.set_img(img_lbl=self.img_lbl, video_path=self.cap, img_idx=end_frm, display_size=self.img_display_size))
 
     def save_behavior_in_frm(self,
                              frame_idx: int,
@@ -380,8 +380,7 @@ class LabellingInterface(ConfigReader):
         try:
             write_df(self.save_df, self.file_type, self.targets_inserted_file_path)
         except Exception as e:
-            print(e, f"SIMBA ERROR: File for video {self.video_name} could not be saved.")
-            raise FileExistsError
+            raise SimbaError(msg=f"Annotation file for video {self.video_name} could not be saved at {self.targets_inserted_file_path}. {e}", source=self.__class__.__name__)
         stdout_success(msg=f"SAVED: Annotation file for video {self.video_name} saved within the {self.targets_folder} directory at file path: {self.targets_inserted_file_path}.", source=self.__class__.__name__)
         if not self.config.has_section("Last saved frames"):
             self.config.add_section("Last saved frames")
@@ -455,3 +454,7 @@ class LabellingInterface(ConfigReader):
 #                               threshold_dict={'Attack': 0.4},
 #                               setting='from_scratch',
 #                               continuing=False)
+# _ = LabellingInterface(config_path=r"F:\troubleshooting\sophiaa\project_folder\project_config.ini",
+#                        file_path=r"F:\troubleshooting\sophiaa\project_folder\videos\Choice222.mp4",
+#                        thresholds=None,
+#                        continuing=False)

{simba_uw_tf_dev-5.2.7 → simba_uw_tf_dev-5.2.9}/simba/model/yolo_fit.py

@@ -200,6 +200,19 @@ if __name__ == "__main__" and not hasattr(sys, 'ps1'):
 # fitter.run()
 #
 
+#
+# fitter = FitYolo(weights_path=r"F:\yolo_weights\yolo26n.pt",
+#                  model_yaml=r"F:\irondog\data\yolo\map.yaml",
+#                  save_path=r"F:\irondog\data\yolo\mdl",
+#                  epochs=1500,
+#                  batch=16,
+#                  workers=3,
+#                  format=None,
+#                  device=0,
+#                  imgsz=256)
+# fitter.run()
+#
+
 
 
 # fitter = FitYolo(weights_path=r"C:\Users\sroni\Downloads\yolo26n.pt",