simba-uw-tf-dev 5.2.8__tar.gz → 5.3.1__tar.gz

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.2.8
+Version: 5.3.1
 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.8 → simba_uw_tf_dev-5.3.1}/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.8",
+    version="5.3.1",
     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.8 → simba_uw_tf_dev-5.3.1}/simba/assets/.recent_projects.txt

@@ -1,3 +1,4 @@
+D:/troubleshooting/open_field_rearing/project_folder/project_config.ini
 F:/troubleshooting/varsha/project_folder/project_config.ini
 E:/troubleshooting/mitra/project_folder/project_config.ini
 F:/troubleshooting/sam/sam/project_folder/project_config.ini

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/simba/data_processors/kleinberg_calculator.py

@@ -1,18 +1,18 @@
 __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 +49,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 +82,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 +98,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 +161,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 +171,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.8 → simba_uw_tf_dev-5.3.1}/simba/data_processors/movement_calculator.py

@@ -18,9 +18,10 @@ from simba.utils.checks import (
     check_that_column_exist, check_valid_boolean, check_valid_dict,
     check_valid_lst, check_valid_tuple)
 from simba.utils.errors import FrameRangeError, InvalidInputError, NoDataError
-from simba.utils.warnings import MissingFileWarning
 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.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'
 

simba_uw_tf_dev-5.3.1/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.3.1/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 float64, int64, njit
+
+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,}python   bursts={result.shape[0]:>6,}  time={elapsed:.4f}s")

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/simba/mixins/train_model_mixin.py

@@ -2107,7 +2107,7 @@ class TrainModelMixin(object):
             self.dataset_splits = read_config_entry(
                 config,
                 ConfigKey.CREATE_ENSEMBLE_SETTINGS.value,
-                MLParamKeys.LEARNING_DATA_SPLITS.value,
+                MLParamKeys.LEARNING_CURVE_DATA_SPLITS.value,
                 data_type=Dtypes.INT.value,
                 default_value=Dtypes.NAN.value,
             )
@@ -2116,7 +2116,7 @@ class TrainModelMixin(object):
                 value=self.shuffle_splits,
             )
             check_int(
-                name=MLParamKeys.LEARNING_DATA_SPLITS.value, value=self.dataset_splits
+                name=MLParamKeys.LEARNING_CURVE_DATA_SPLITS.value, value=self.dataset_splits
             )
         else:
             self.shuffle_splits, self.dataset_splits = (

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/simba/model/train_rf.py

@@ -120,9 +120,9 @@ class TrainRandomForestClassifier(ConfigReader, TrainModelMixin):
 
             if generate_learning_curve in Options.PERFORM_FLAGS.value:
                 shuffle_splits = read_config_entry(self.config,ConfigKey.CREATE_ENSEMBLE_SETTINGS.value,MLParamKeys.LEARNING_CURVE_K_SPLITS.value,data_type=Dtypes.INT.value,default_value=Dtypes.NAN.value)
-                dataset_splits = read_config_entry(self.config,ConfigKey.CREATE_ENSEMBLE_SETTINGS.value,MLParamKeys.LEARNING_DATA_SPLITS.value,data_type=Dtypes.INT.value,default_value=Dtypes.NAN.value)
+                dataset_splits = read_config_entry(self.config,ConfigKey.CREATE_ENSEMBLE_SETTINGS.value,MLParamKeys.LEARNING_CURVE_DATA_SPLITS.value,data_type=Dtypes.INT.value,default_value=Dtypes.NAN.value)
                 check_int(name=MLParamKeys.LEARNING_CURVE_K_SPLITS.value, value=shuffle_splits)
-                check_int(name=MLParamKeys.LEARNING_DATA_SPLITS.value, value=dataset_splits)
+                check_int(name=MLParamKeys.LEARNING_CURVE_DATA_SPLITS.value, value=dataset_splits)
             else:
                 shuffle_splits, dataset_splits = Dtypes.NAN.value, Dtypes.NAN.value
             if generate_features_importance_bar_graph in Options.PERFORM_FLAGS.value:

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/simba/utils/config_creator.py

@@ -228,7 +228,7 @@ class ProjectConfigCreator(object):
             MLParamKeys.LEARNING_CURVE_K_SPLITS.value
         ] = Dtypes.NONE.value
         self.config[ConfigKey.CREATE_ENSEMBLE_SETTINGS.value][
-            MLParamKeys.LEARNING_DATA_SPLITS.value
+            MLParamKeys.LEARNING_CURVE_DATA_SPLITS.value
         ] = Dtypes.NONE.value
 
         self.config.add_section(ConfigKey.MULTI_ANIMAL_ID_SETTING.value)

{simba_uw_tf_dev-5.2.8 → simba_uw_tf_dev-5.3.1}/simba_uw_tf_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 5.2.8
+Version: 5.3.1
 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.8 → simba_uw_tf_dev-5.3.1}/simba_uw_tf_dev.egg-info/SOURCES.txt

@@ -573,6 +573,7 @@ simba/data_processors/movement_calculator.py
 simba/data_processors/mutual_exclusivity_corrector.py
 simba/data_processors/pup_retrieval_calculator.py
 simba/data_processors/pybursts_calculator.py
+simba/data_processors/pybursts_calculator_numba.py
 simba/data_processors/severity_bout_based_calculator.py
 simba/data_processors/severity_calculator.py
 simba/data_processors/severity_frame_based_calculator.py

simba_uw_tf_dev-5.2.8/simba/data_processors/pybursts_calculator.py

@@ -1,113 +0,0 @@
-### 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):
-    """
-    Burst detection using `pyburst <https://pypi.org/project/pybursts/>`_.
-    Private method called by ``simba.data_processors.kleinberg_calculator.KleinbergCalculator``.
-
-    """
-
-    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))
-
-    def f(j, x):
-        return alpha[j] * math.exp(-alpha[j] * x)
-
-    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)
-
-            if f(j, gaps[t]) > 0:
-                C_prime[j] = cost[el] - math.log(f(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