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

simba/data_processors/cuda/statistics.py

@@ -5,6 +5,8 @@ import math
 from itertools import combinations
 from typing import Optional, Tuple
 
+from simba.utils.printing import SimbaTimer
+
 try:
     from typing import Literal
 except:
@@ -20,11 +22,11 @@ from simba.utils.warnings import GPUToolsWarning
 try:
     import cupy as cp
     from cuml.metrics import kl_divergence as kl_divergence_gpu
-    from cuml.metrics.cluster.adjusted_rand_index import adjusted_rand_score
-    from cuml.metrics.cluster.silhouette_score import cython_silhouette_score
+    #from cuml.metrics.cluster.adjusted_rand_index import adjusted_rand_score
+    #from cuml.metrics.cluster.silhouette_score import cython_silhouette_score
     from cupyx.scipy.spatial.distance import cdist
-except:
-    GPUToolsWarning(msg='GPU tools not detected, reverting to CPU')
+except Exception as e:
+    GPUToolsWarning(msg=f'GPU tools not detected, reverting to CPU: {e.args}')
     import numpy as cp
     from scipy.spatial.distance import cdist
     from scipy.stats import entropy as kl_divergence_gpu
@@ -227,7 +229,6 @@ def get_euclidean_distance_cupy(x: np.ndarray,
     using CuPy for GPU acceleration. The computation is performed in batches to handle large
     datasets efficiently.
 
-
     .. seealso::
        For CPU function see :func:`~simba.mixins.feature_extraction_mixin.FeatureExtractionMixin.framewise_euclidean_distance`.
        For CUDA JIT function see :func:`~simba.data_processors.cuda.statistics.get_euclidean_distance_cuda`.
@@ -834,8 +835,11 @@ def i_index(x: np.ndarray, y: np.ndarray):
     return i_idx
 
 
-def kullback_leibler_divergence_gpu(x: np.ndarray, y: np.ndarray, fill_value: int = 1, bucket_method: Literal[
-    "fd", "doane", "auto", "scott", "stone", "rice", "sturges", "sqrt"] = "scott") -> float:
+def kullback_leibler_divergence_gpu(x: np.ndarray,
+                                    y: np.ndarray,
+                                    fill_value: int = 1,
+                                    bucket_method: Literal["fd", "doane", "auto", "scott", "stone", "rice", "sturges", "sqrt"] = "scott",
+                                    verbose: bool = False) -> float:
     """
     Compute Kullback-Leibler divergence between two distributions.
 
@@ -847,7 +851,6 @@ def kullback_leibler_divergence_gpu(x: np.ndarray, y: np.ndarray, fill_value: in
     .. seealso::
        For CPU implementation, see :func:`simba.mixins.statistics_mixin.Statistics.kullback_leibler_divergence`.
 
-
     :param ndarray x: First 1d array representing feature values.
     :param ndarray y: Second 1d array representing feature values.
     :param Optional[int] fill_value: Optional pseudo-value to use to fill empty buckets in ``y`` histogram
@@ -860,13 +863,18 @@ def kullback_leibler_divergence_gpu(x: np.ndarray, y: np.ndarray, fill_value: in
     >>> kl = kullback_leibler_divergence_gpu(x=x, y=y)
     """
 
+    timer = SimbaTimer(start=True)
+
     bin_width, bin_count = bucket_data(data=x, method=bucket_method)
     r = np.array([np.min(x), np.max(x)])
     x_hist = Statistics._hist_1d(data=x, bin_count=bin_count, range=r)
     y_hist = Statistics._hist_1d(data=y, bin_count=bin_count, range=r)
     y_hist[y_hist == 0] = fill_value
     x_hist, y_hist = x_hist / np.sum(x_hist), y_hist / np.sum(y_hist)
-    return kl_divergence_gpu(P=x_hist.astype(np.float32), Q=y_hist.astype(np.float32), convert_dtype=False)
+    r =  kl_divergence_gpu(P=x_hist.astype(np.float32), Q=y_hist.astype(np.float32), convert_dtype=False)
+    timer.stop_timer()
+    if verbose: print(f'KL divergence performed on {x.shape[0]} observations (elapsed time: {timer.elapsed_time_str}s)')
+    return r
 
 
 @cuda.jit()

simba/data_processors/egocentric_aligner.py

@@ -7,7 +7,8 @@ import pandas as pd
 from simba.utils.checks import (check_if_dir_exists, check_if_valid_rgb_tuple,
                                 check_int, check_str, check_valid_boolean,
                                 check_valid_dataframe, check_valid_tuple)
-from simba.utils.data import egocentrically_align_pose_numba
+from simba.utils.data import (egocentrically_align_pose_numba, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import Formats, Options
 from simba.utils.errors import InvalidInputError
 from simba.utils.printing import SimbaTimer, stdout_success
@@ -73,7 +74,7 @@ class EgocentricalAligner():
         check_str(name=f'{self.__class__.__name__} anchor_1', value=anchor_1, allow_blank=False)
         check_str(name=f'{self.__class__.__name__} anchor_2', value=anchor_2, allow_blank=False)
         check_int(name=f'{self.__class__.__name__} core_cnt', value=core_cnt, min_value=-1, max_value=find_core_cnt()[0], unaccepted_vals=[0])
-        if core_cnt == -1: self.core_cnt = find_core_cnt()[0]
+        self.core_cnt = find_core_cnt()[0] if core_cnt == -1 or core_cnt > find_core_cnt()[0] else core_cnt
         check_int(name=f'{self.__class__.__name__} direction', value=direction, min_value=0, max_value=360)
         if isinstance(anchor_location, tuple):
             check_valid_tuple(x=anchor_location, source=f'{self.__class__.__name__} anchor_location', accepted_lengths=(2,), valid_dtypes=(int,))
@@ -98,6 +99,7 @@ class EgocentricalAligner():
 
     def run(self):
         timer = SimbaTimer(start=True)
+        self.pool = None if not self.rotate_video else get_cpu_pool(core_cnt=self.core_cnt, source=self.__class__.__name__)
         for file_cnt, file_path in enumerate(self.data_paths):
             video_timer = SimbaTimer(start=True)
             _, self.video_name, _ = get_fn_ext(filepath=file_path)
@@ -127,8 +129,7 @@ class EgocentricalAligner():
             if self.verbose:
                 print(f'{self.video_name} complete, saved at {save_path} (elapsed time: {video_timer.elapsed_time_str}s)')
             if self.rotate_video:
-                if self.verbose:
-                    print(f'Rotating video {self.video_name}...')
+                if self.verbose: print(f'Rotating video {self.video_name}...')
                 video_path = find_video_of_file(video_dir=self.videos_dir, filename=self.video_name, raise_error=False)
                 save_path = os.path.join(self.save_dir, f'{self.video_name}.mp4')
                 video_rotator = EgocentricVideoRotator(video_path=video_path,
@@ -139,11 +140,13 @@ class EgocentricalAligner():
                                                        gpu=self.gpu,
                                                        fill_clr=self.fill_clr,
                                                        core_cnt=self.core_cnt,
-                                                       save_path=save_path)
+                                                       save_path=save_path,
+                                                       pool=self.pool)
                 video_rotator.run()
             if self.verbose:
                 print(f'Rotated data for video {self.video_name} ({file_cnt+1}/{len(self.data_paths)}) saved in {self.save_dir}.')
         timer.stop_timer()
+        terminate_cpu_pool(pool=self.pool, source=self.__class__.__name__)
         stdout_success(msg=f'Egocentrically aligned data for {len(self.data_paths)} files saved in {self.save_dir}', elapsed_time=timer.elapsed_time_str)
 
 
@@ -156,9 +159,24 @@ class EgocentricalAligner():
 #                                   direction=0,
 #                                   gpu=True,
 #                                   anchor_location=(600, 300),
-#                                   fill_clr=(128,128,128))
+#                                   fill_clr=(128,128,128),
+#                                   core_cnt=18)
 #     aligner.run()
 
+
+if __name__ == "__main__":
+    aligner = EgocentricalAligner(anchor_1='butt/proximal tail',
+                                  anchor_2='snout',
+                                  data_dir=r'C:\troubleshooting\open_field_below\project_folder\csv\outlier_corrected_movement_location',
+                                  videos_dir=r'C:\troubleshooting\open_field_below\project_folder\videos',
+                                  save_dir=r"C:\troubleshooting\open_field_below\project_folder\videos\rotated",
+                                  direction=0,
+                                  gpu=True,
+                                  anchor_location=(600, 300),
+                                  fill_clr=(128,128,128),
+                                  core_cnt=18)
+    aligner.run()
+
 #     aligner = EgocentricalAligner(anchor_1='tail_base',
 #                                   anchor_2='nose',
 #                                   data_dir=r'C:\Users\sroni\OneDrive\Desktop\rotate_ex\data',

simba/data_processors/kleinberg_calculator.py

@@ -13,10 +13,14 @@ from simba.data_processors.pybursts_calculator import kleinberg_burst_detection
 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,
-                                check_that_column_exist, check_valid_lst)
+                                check_that_column_exist, check_valid_boolean,
+                                check_valid_lst)
 from simba.utils.enums import Paths, TagNames
 from simba.utils.printing import SimbaTimer, log_event, stdout_success
-from simba.utils.read_write import get_fn_ext, read_df, write_df
+from simba.utils.read_write import (copy_files_to_directory,
+                                    find_files_of_filetypes_in_directory,
+                                    get_current_time, get_fn_ext, read_df,
+                                    remove_a_folder, write_df)
 from simba.utils.warnings import KleinbergWarning
 
 
@@ -38,12 +42,13 @@ class KleinbergCalculator(ConfigReader):
 
     :param str config_path: path to SimBA project config file in Configparser format
     :param List[str] classifier_names: Classifier names to apply Kleinberg smoothing to.
-    :param float sigma: Burst detection sigma value. Higher sigma values and fewer, longer, behavioural bursts will be recognised. Default: 2.
-    :param float gamma: Burst detection gamma value. Higher gamma values and fewer behavioural bursts will be recognised. Default: 0.3.
-    :param int hierarchy: Burst detection hierarchy level. Higher hierarchy values and fewer behavioural bursts will to be recognised. Default: 1.
-    :param bool hierarchical_search: See `Tutorial <https://github.com/sgoldenlab/simba/blob/master/docs/kleinberg_filter.md#hierarchical-search-example>`_ Default: False.
+    :param float sigma: State transition cost for moving to higher burst levels. 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. Default: 2.
+    :param float gamma: State transition cost for moving to lower burst levels. 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. Must be >= 0. Default: 0.3.
+    :param int hierarchy: Hierarchy level to extract bursts from (0=lowest, higher=more selective). Level 0 captures all bursts; level 1-2 typically filters noise; level 3+ selects only the most prominent, sustained bursts. Higher levels yield fewer but more confident detections. Must be >= 0. Default: 1.
+    :param bool hierarchical_search: If True, searches for target hierarchy level within detected burst periods, falling back to lower levels if target not found. If False, extracts only bursts at the exact specified hierarchy level. Recommended when target hierarchy may be sparse. Default: False.
     :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.`
 
     :example I:
     >>> kleinberg_calculator = KleinbergCalculator(config_path='MySimBAConfigPath', classifier_names=['Attack'], sigma=2, gamma=0.3, hierarchy=2, hierarchical_search=False)
@@ -68,10 +73,12 @@ class KleinbergCalculator(ConfigReader):
 
     def __init__(self,
                  config_path: Union[str, os.PathLike],
-                 classifier_names: List[str],
-                 sigma: Optional[int] = 2,
-                 gamma: Optional[float] = 0.3,
+                 classifier_names: Optional[List[str]] = None,
+                 sigma: float = 2,
+                 gamma: float = 0.3,
                  hierarchy: Optional[int] = 1,
+                 verbose: bool = True,
+                 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):
@@ -81,25 +88,31 @@ class KleinbergCalculator(ConfigReader):
         check_float(value=sigma, name=f'{self.__class__.__name__} sigma', min_value=1.01)
         check_float(value=gamma, name=f'{self.__class__.__name__} gamma', min_value=0)
         check_int(value=hierarchy, name=f'{self.__class__.__name__} hierarchy', min_value=0)
-        check_valid_lst(data=classifier_names, source=f'{self.__class__.__name__} classifier_names', valid_dtypes=(str,), min_len=1)
+        if isinstance(classifier_names, list):
+            check_valid_lst(data=classifier_names, source=f'{self.__class__.__name__} classifier_names', valid_dtypes=(str,), min_len=1)
+        else:
+            classifier_names = deepcopy(self.clf_names)
+        check_valid_boolean(value=verbose, source=f'{self.__class__.__name__} verbose', raise_error=True)
+        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), float(hierarchy), classifier_names)
+        self.sigma, self.gamma, self.hierarchy, self.clfs = ( float(sigma), float(gamma), int(hierarchy), classifier_names)
+        self.verbose, self.save_originals = verbose, save_originals
         if input_dir is None:
-            self.data_paths, self.output_dir = self.machine_results_paths, self.machine_results_dir
-            check_if_filepath_list_is_empty(filepaths=self.machine_results_paths, error_msg=f"SIMBA ERROR: No data files found in {self.machine_results_dir}. Cannot perform Kleinberg smoothing")
-            original_data_files_folder = os.path.join(self.project_path, Paths.MACHINE_RESULTS_DIR.value, f"Pre_Kleinberg_{self.datetime}")
-            if not os.path.exists(original_data_files_folder):
-                os.makedirs(original_data_files_folder)
-            for file_path in self.machine_results_paths:
-                _, file_name, ext = get_fn_ext(file_path)
-                shutil.copyfile(file_path, os.path.join(original_data_files_folder, file_name + ext))
+            self.input_dir = os.path.join(self.project_path, Paths.MACHINE_RESULTS_DIR.value)
         else:
             check_if_dir_exists(in_dir=input_dir)
-            self.data_paths = glob.glob(input_dir + f"/*.{self.file_type}")
-            check_if_filepath_list_is_empty(filepaths=self.data_paths, error_msg=f"SIMBA ERROR: No data files found in {input_dir}. Cannot perform Kleinberg smoothing")
-            if not os.path.isdir(output_dir):
-                os.makedirs(output_dir)
-        print(f"Processing Kleinberg burst detection for {len(self.data_paths)} file(s) and {len(classifier_names)} classifier(s)...")
+            self.input_dir = deepcopy(input_dir)
+        self.data_paths = find_files_of_filetypes_in_directory(directory=self.input_dir, extensions=[f'.{self.file_type}'], sort_alphabetically=True, raise_error=True)
+        if output_dir is None:
+            self.output_dir = deepcopy(self.input_dir)
+        else:
+            check_if_dir_exists(in_dir=output_dir)
+            self.output_dir = deepcopy(output_dir)
+        self.original_data_files_folder = os.path.join(self.output_dir, f"Pre_Kleinberg_{self.datetime}")
+        remove_a_folder(folder_dir=self.original_data_files_folder, ignore_errors=True)
+        os.makedirs(self.original_data_files_folder)
+        copy_files_to_directory(file_paths=self.data_paths, dir=self.original_data_files_folder, verbose=False, integer_save_names=False)
+        if self.verbose: print(f"Processing Kleinberg burst detection for {len(self.data_paths)} file(s) and {len(classifier_names)} classifier(s)...")
 
     def hierarchical_searcher(self):
         if (len(self.kleinberg_bouts["Hierarchy"]) == 1) and (int(self.kleinberg_bouts.at[0, "Hierarchy"]) == 0):
@@ -135,7 +148,7 @@ class KleinbergCalculator(ConfigReader):
         for file_cnt, file_path in enumerate(self.data_paths):
             _, video_name, _ = get_fn_ext(file_path)
             video_timer = SimbaTimer(start=True)
-            print(f"Performing Kleinberg burst detection for video {video_name}  (Video {file_cnt+1}/{len(self.data_paths)})...")
+            if self.verbose: print(f"[{get_current_time()}] Performing Kleinberg burst detection for video {video_name} (Video {file_cnt+1}/{len(self.data_paths)})...")
             data_df = read_df(file_path, self.file_type).reset_index(drop=True)
             video_out_df = deepcopy(data_df)
             check_that_column_exist(df=data_df, column_name=self.clfs, file_name=video_name)
@@ -150,7 +163,7 @@ class KleinbergCalculator(ConfigReader):
                     self.kleinberg_bouts.insert(loc=0, column="Video", value=video_name)
                     detailed_df_lst.append(self.kleinberg_bouts)
                     if self.hierarchical_search:
-                        print(f"Applying hierarchical search for video {video_name}...")
+                        if self.verbose: print(f"[{get_current_time()}] Applying hierarchical search for video {video_name}...")
                         self.hierarchical_searcher()
                     else:
                         self.clf_bouts_in_hierarchy = self.kleinberg_bouts[self.kleinberg_bouts["Hierarchy"] == self.hierarchy]
@@ -160,19 +173,38 @@ class KleinbergCalculator(ConfigReader):
                     video_out_df.loc[hierarchy_idx, clf] = 1
             write_df(video_out_df, self.file_type, save_path)
             video_timer.stop_timer()
-            print(f'Kleinberg analysis complete for video {video_name} (saved at {save_path}), elapsed time: {video_timer.elapsed_time_str}s.')
+            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.')
 
         self.timer.stop_timer()
+        if not self.save_originals:
+            remove_a_folder(folder_dir=self.original_data_files_folder, ignore_errors=False)
+        else:
+            if self.verbose: stdout_success(msg=f"Original, un-smoothened data, saved in {self.original_data_files_folder} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
         if len(detailed_df_lst) > 0:
             self.detailed_df = pd.concat(detailed_df_lst, axis=0)
             detailed_save_path = os.path.join(self.logs_path, f"Kleinberg_detailed_log_{self.datetime}.csv")
             self.detailed_df.to_csv(detailed_save_path)
-            stdout_success(msg=f"Kleinberg analysis complete. See {detailed_save_path} for details of detected bouts of all classifiers in all hierarchies", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
+            if self.verbose:  stdout_success(msg=f"Kleinberg analysis complete for {len(self.data_paths)} files. Results stored in {self.output_dir} directory. See {detailed_save_path} for details of detected bouts of all classifiers in all hierarchies", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
         else:
-            print("Kleinberg analysis complete.")
+            if self.verbose: print(f"[{get_current_time()}] Kleinberg analysis complete for {len(self.data_paths)} files. Results stored in {self.output_dir} directory.")
             KleinbergWarning(msg="All behavior bouts removed following kleinberg smoothing", source=self.__class__.__name__)
 
 
+
+
+# test = KleinbergCalculator(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini",
+#                            classifier_names=['straub_tail'],
+#                            sigma=1.1,
+#                            gamma=0.1,
+#                            hierarchy=1,
+#                            save_originals=False,
+#                            hierarchical_search=False)
+#
+# test.run()
+#
+
+
+
 # test = KleinbergCalculator(config_path='/Users/simon/Desktop/envs/simba/troubleshooting/levi/project_folder/project_config.ini',
 #                            classifier_names=['No_Seizure_(0)'],
 #                            sigma=1.1,

simba/feature_extractors/feature_subsets.py

@@ -154,11 +154,11 @@ class FeatureSubsetsCalculator(ConfigReader, TrainModelMixin):
             self.within_animal_four_point_combs[animal] = np.array(list(combinations(animal_bps, 4)))
 
     def _get_two_point_bp_distances(self):
-        for c in self.two_point_combs:
+        for cnt, c in enumerate(self.two_point_combs):
             x1, y1, x2, y2 = list(sum([(f"{x}_x", f"{y}_y") for (x, y) in zip(c, c)], ()))
             bp1 = self.data_df[[x1, y1]].values
             bp2 = self.data_df[[x2, y2]].values
-            self.results[f"Distance (mm) {c[0]}-{c[1]}"] = FeatureExtractionMixin.framewise_euclidean_distance(location_1=bp1.astype(np.float64), location_2=bp2.astype(np.float64), px_per_mm=np.float64(self.px_per_mm), centimeter=False)
+            self.results[f"Distance (mm) {c[0]}-{c[1]}"] = FeatureExtractionMixin.bodypart_distance(bp1_coords=bp1.astype(np.int32), bp2_coords=bp2.astype(np.int32), px_per_mm=np.float64(self.px_per_mm), in_centimeters=False)
 
     def __get_three_point_angles(self):
         for animal, points in self.within_animal_three_point_combs.items():
@@ -342,13 +342,20 @@ class FeatureSubsetsCalculator(ConfigReader, TrainModelMixin):
 
 
 
+# test = FeatureSubsetsCalculator(config_path=r"C:\troubleshooting\srami0619\project_folder\project_config.ini",
+#                                 feature_families=[TWO_POINT_BP_DISTANCES],
+#                                 append_to_features_extracted=False,
+#                                 file_checks=True,
+#                                 append_to_targets_inserted=False)
+# test.run()
+
+
 
 # test = FeatureSubsetsCalculator(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini",
-#                                 feature_families=[ARENA_EDGE],
+#                                 feature_families=[TWO_POINT_BP_DISTANCES],
 #                                 append_to_features_extracted=False,
 #                                 file_checks=True,
-#                                 append_to_targets_inserted=False,
-#                                 save_dir=r"C:\troubleshooting\mitra\project_folder\csv\feature_subset")
+#                                 append_to_targets_inserted=False)
 # test.run()
 
 #

simba/feature_extractors/straub_tail_analyzer.py

@@ -9,8 +9,6 @@ try:
 except:
     from typing_extensions import Literal
 
-import functools
-import multiprocessing
 from copy import deepcopy
 
 import numpy as np

simba/mixins/statistics_mixin.py

@@ -8,6 +8,8 @@ from sklearn.metrics import (adjusted_mutual_info_score, adjusted_rand_score,
                              fowlkes_mallows_score)
 from sklearn.neighbors import LocalOutlierFactor
 
+from simba.utils.printing import SimbaTimer
+
 try:
     from typing import Literal
 except:
@@ -538,7 +540,8 @@ class Statistics(FeatureExtractionMixin):
         sample_1: np.ndarray,
         sample_2: np.ndarray,
         fill_value: Optional[int] = 1,
-        bucket_method: Literal["fd", "doane", "auto", "scott", "stone", "rice", "sturges", "sqrt"] = "auto") -> float:
+        bucket_method: Literal["fd", "doane", "auto", "scott", "stone", "rice", "sturges", "sqrt"] = "auto",
+        verbose: bool = False) -> float:
 
         r"""
         Compute Kullback-Leibler divergence between two distributions.
@@ -562,6 +565,7 @@ class Statistics(FeatureExtractionMixin):
         :returns: Kullback-Leibler divergence between ``sample_1`` and ``sample_2``
         :rtype: float
         """
+        timer = SimbaTimer(start=True)
         check_valid_array(data=sample_1, source=Statistics.kullback_leibler_divergence.__name__, accepted_ndims=(1,), accepted_dtypes=Formats.NUMERIC_DTYPES.value)
         check_valid_array(data=sample_2, source=Statistics.kullback_leibler_divergence.__name__, accepted_ndims=(1,), accepted_dtypes=Formats.NUMERIC_DTYPES.value)
         check_str(name=f"{self.__class__.__name__} bucket_method", value=bucket_method, options=Options.BUCKET_METHODS.value)
@@ -573,7 +577,10 @@ class Statistics(FeatureExtractionMixin):
         sample_1_hist[sample_1_hist == 0] = fill_value
         sample_2_hist[sample_2_hist == 0] = fill_value
         sample_1_hist, sample_2_hist = sample_1_hist / np.sum(sample_1_hist), sample_2_hist / np.sum(sample_2_hist)
-        return stats.entropy(pk=sample_1_hist, qk=sample_2_hist)
+        kl = stats.entropy(pk=sample_1_hist, qk=sample_2_hist)
+        timer.stop_timer()
+        if verbose: print(f'KL divergence performed on {sample_1.shape[0]} observations (elapsed time: {timer.elapsed_time_str}s)')
+        return kl
 
     def rolling_kullback_leibler_divergence(
         self,

simba/plotting/gantt_creator_mp.py

@@ -4,17 +4,18 @@ import warnings
 
 warnings.simplefilter(action="ignore", category=FutureWarning)
 import functools
+import gc
 import multiprocessing
 import os
 import platform
-from typing import List, Optional, Union
 from copy import deepcopy
+from typing import List, Optional, Union
 
-import gc
 import cv2
+import matplotlib
 import numpy as np
 import pandas as pd
-import matplotlib
+
 matplotlib.use('Agg')
 
 from simba.mixins.config_reader import ConfigReader
@@ -23,13 +24,14 @@ from simba.utils.checks import (
     check_all_file_names_are_represented_in_video_log,
     check_file_exist_and_readable, check_int, check_str,
     check_that_column_exist, check_valid_boolean, check_valid_lst)
-from simba.utils.data import (create_color_palette, detect_bouts, terminate_cpu_pool, get_cpu_pool)
+from simba.utils.data import (create_color_palette, detect_bouts, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import Formats, Options
 from simba.utils.errors import NoSpecifiedOutputError
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory, find_core_cnt,
-                                    get_fn_ext, read_df, get_current_time)
+                                    get_current_time, get_fn_ext, read_df)
 
 HEIGHT = "height"
 WIDTH = "width"

simba/plotting/pose_plotter_mp.py

@@ -12,15 +12,19 @@ import pandas as pd
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.geometry_mixin import GeometryMixin
 from simba.mixins.plotting_mixin import PlottingMixin
-from simba.utils.checks import (check_instance, check_int, check_nvidea_gpu_available, check_str, check_that_column_exist, check_valid_boolean)
-from simba.utils.data import create_color_palette, terminate_cpu_pool, get_cpu_pool
+from simba.utils.checks import (check_instance, check_int,
+                                check_nvidea_gpu_available, check_str,
+                                check_that_column_exist, check_valid_boolean)
+from simba.utils.data import (create_color_palette, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import OS, Formats, Options
 from simba.utils.errors import CountError, InvalidFilepathError
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     find_core_cnt,
                                     find_files_of_filetypes_in_directory,
-                                    get_fn_ext, get_video_meta_data, read_df, get_current_time)
+                                    get_current_time, get_fn_ext,
+                                    get_video_meta_data, read_df)
 from simba.utils.warnings import FrameRangeWarning
 
 

simba/plotting/roi_plotter_mp.py

@@ -24,15 +24,16 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_valid_boolean, check_valid_lst,
                                 check_video_and_data_frm_count_align)
 from simba.utils.data import (create_color_palettes, detect_bouts,
-                              slice_roi_dict_for_video, terminate_cpu_pool, get_cpu_pool)
+                              get_cpu_pool, slice_roi_dict_for_video,
+                              terminate_cpu_pool)
 from simba.utils.enums import ROI_SETTINGS, Formats, Keys, Paths, TextOptions
 from simba.utils.errors import (BodypartColumnNotFoundError, DuplicationError,
                                 NoFilesFoundError, NoROIDataError,
                                 ROICoordinatesNotFoundError)
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
-                                    find_core_cnt, get_video_meta_data,
-                                    read_df, get_current_time)
+                                    find_core_cnt, get_current_time,
+                                    get_video_meta_data, read_df)
 from simba.utils.warnings import (DuplicateNamesWarning, FrameRangeWarning,
                                   GPUToolsWarning)
 

simba/plotting/yolo_pose_track_visualizer.py

@@ -13,10 +13,11 @@ from simba.mixins.plotting_mixin import PlottingMixin
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_dir_exists, check_int,
                                 check_valid_boolean, check_valid_dataframe)
-from simba.utils.data import terminate_cpu_pool, get_cpu_pool
+from simba.utils.data import get_cpu_pool, terminate_cpu_pool
 from simba.utils.enums import Defaults, Formats
 from simba.utils.errors import InvalidFilepathError, NoFilesFoundError
-from simba.utils.lookups import get_random_color_palette, intermittent_palette, get_current_time
+from simba.utils.lookups import (get_current_time, get_random_color_palette,
+                                 intermittent_palette)
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory,

simba/plotting/yolo_pose_visualizer.py

@@ -14,7 +14,8 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_dir_exists, check_int,
                                 check_valid_boolean, check_valid_dataframe,
                                 check_valid_lst, check_valid_tuple)
-from simba.utils.data import create_color_palette, terminate_cpu_pool, get_cpu_pool
+from simba.utils.data import (create_color_palette, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import Defaults, Options
 from simba.utils.errors import (CountError, DataHeaderError, FrameRangeError,
                                 InvalidInputError, NoDataError)
@@ -22,9 +23,9 @@ from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory, find_core_cnt,
                                     find_files_of_filetypes_in_directory,
-                                    get_fn_ext, get_video_meta_data,
-                                    read_frm_of_video, recursive_file_search,
-                                    remove_a_folder, get_current_time)
+                                    get_current_time, get_fn_ext,
+                                    get_video_meta_data, read_frm_of_video,
+                                    recursive_file_search, remove_a_folder)
 
 FRAME = 'FRAME'
 CLASS_ID = 'CLASS_ID'

simba/sandbox/analyze_runtimes.py

@@ -0,0 +1,30 @@
+"""Analyze runtime statistics for directionality_to_nonstatic_target"""
+import numpy as np
+from collections import defaultdict
+
+# Parse the runtime data
+data = {
+    10000: [0.4389, 0.0008, 0.0012],
+    100000: [0.0063, 0.0052, 0.0052],
+    1000000: [0.0768, 0.0306, 0.0239],
+    10000000: [0.2195, 0.2122, 0.2083],
+    50000000: [1.8936, 1.5664, 1.2548]
+}
+
+# Calculate statistics
+print("=" * 80)
+print(f"{'Observations':<15} {'Mean (s)':<12} {'Std (s)':<12} {'Min (s)':<12} {'Max (s)':<12} {'Throughput (M obs/s)':<20}")
+print("=" * 80)
+
+for obs_count in sorted(data.keys()):
+    times = np.array(data[obs_count])
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    throughput = obs_count / (mean_time * 1_000_000)  # Million observations per second
+    
+    print(f"{obs_count:<15,} {mean_time:<12.4f} {std_time:<12.4f} {min_time:<12.4f} {max_time:<12.4f} {throughput:<20.2f}")
+
+print("=" * 80)
+print("\nNote: First run typically includes JIT compilation overhead (especially for 10k observations)")