simba-uw-tf-dev 4.6.4__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_valid_boolean)
+                                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, get_current_time, find_files_of_filetypes_in_directory, remove_a_folder, copy_files_to_directory
+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
 
 

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/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)")