simba-uw-tf-dev 4.6.4__py3-none-any.whl → 4.6.7__py3-none-any.whl

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,
@@ -3271,10 +3278,34 @@ class Statistics(FeatureExtractionMixin):
 
         Youden's J statistic is a measure of the overall performance of a binary classification test, taking into account both sensitivity (true positive rate) and specificity (true negative rate).
 
-        :param sample_1: The first binary array.
-        :param sample_2: The second binary array.
-        :return: Youden's J statistic.
+        The Youden's J statistic is calculated as:
+
+        .. math::
+            J = \text{sensitivity} + \text{specificity} - 1
+
+        where:
+
+        - :math:`\text{sensitivity} = \frac{TP}{TP + FN}` is the true positive rate
+        - :math:`\text{specificity} = \frac{TN}{TN + FP}` is the true negative rate
+
+        The statistic ranges from -1 to 1, where:
+        - :math:`J = 1` indicates perfect classification
+        - :math:`J = 0` indicates the test performs no better than random
+        - :math:`J < 0` indicates the test performs worse than random
+
+        :param sample_1: The first binary array (ground truth or reference).
+        :param sample_2: The second binary array (predictions or test results).
+        :return: Youden's J statistic. Returns NaN if either sensitivity or specificity cannot be calculated (division by zero).
         :rtype: float
+
+        :references:
+            .. [1] Youden, W. J. (1950). Index for rating diagnostic tests. Cancer, 3(1), 32-35.
+                   https://acsjournals.onlinelibrary.wiley.com/doi/abs/10.1002/1097-0142(1950)3:1%3C32::AID-CNCR2820030106%3E3.0.CO;2-3
+
+        :example:
+        >>> y_true = np.array([1, 1, 0, 0, 1, 0, 1, 1, 0, 0])
+        >>> y_pred = np.array([1, 1, 0, 1, 1, 0, 1, 0, 0, 0])
+        >>> j = Statistics.youden_j(sample_1=y_true, sample_2=y_pred)
         """
 
         check_valid_array(data=sample_1, source=f'{Statistics.youden_j.__name__} sample_1', accepted_ndims=(1,), accepted_values=[0, 1])
@@ -4250,7 +4281,7 @@ class Statistics(FeatureExtractionMixin):
         return separation_trace / compactness
 
     @staticmethod
-    def i_index(x: np.ndarray, y: np.ndarray):
+    def i_index(x: np.ndarray, y: np.ndarray, verbose: bool = False) -> float:
 
         """
         Calculate the I-Index for evaluating clustering quality.
@@ -4275,9 +4306,10 @@ class Statistics(FeatureExtractionMixin):
         >>> X, y = make_blobs(n_samples=5000, centers=20, n_features=3, random_state=0, cluster_std=0.1)
         >>> Statistics.i_index(x=X, y=y)
         """
+        timer = SimbaTimer(start=True)
         check_valid_array(data=x, accepted_ndims=(2,), accepted_dtypes=Formats.NUMERIC_DTYPES.value)
         check_valid_array(data=y, accepted_ndims=(1,), accepted_dtypes=Formats.NUMERIC_DTYPES.value, accepted_axis_0_shape=[x.shape[0], ])
-        _ = get_unique_values_in_iterable(data=y, name=Statistics.i_index.__name__, min=2)
+        cluster_cnt = get_unique_values_in_iterable(data=y, name=Statistics.i_index.__name__, min=2)
         unique_y = np.unique(y)
         n_y = unique_y.shape[0]
         global_centroid = np.mean(x, axis=0)
@@ -4289,7 +4321,12 @@ class Statistics(FeatureExtractionMixin):
             cluster_centroid = np.mean(cluster_obs, axis=0)
             swc += np.sum(np.linalg.norm(cluster_obs - cluster_centroid, axis=1) ** 2)
 
-        return sst / (n_y * swc)
+
+        i_index = np.float32(sst / (n_y * swc))
+        timer.stop_timer()
+        if verbose: print(f'I-index for {x.shape[0]} observations in {cluster_cnt} clusters computed (elapsed time: {timer.elapsed_time_str}s)')
+        return i_index
+
 
     @staticmethod
     def sd_index(x: np.ndarray, y: np.ndarray) -> float:
@@ -5291,7 +5328,7 @@ class Statistics(FeatureExtractionMixin):
         """
         Compute one-way ANOVAs comparing each column (axis 1) on two arrays.
 
-        .. notes::
+        .. note::
            Use for computing and presenting aggregate statistics. Not suitable for featurization.
 
         .. seealso::
@@ -5329,7 +5366,7 @@ class Statistics(FeatureExtractionMixin):
         """
         Compute Kruskal-Wallis comparing each column (axis 1) on two arrays.
 
-        .. notes::
+        .. note::
            Use for computing and presenting aggregate statistics. Not suitable for featurization.
 
         .. seealso::
@@ -5366,7 +5403,7 @@ class Statistics(FeatureExtractionMixin):
         """
         Compute pairwise grouped Tukey-HSD tests.
 
-        .. notes::
+        .. note::
            Use for computing and presenting aggregate statistics. Not suitable for featurization.
 
         :param np.ndarray data: 2D array  with observations rowwise (axis 0) and features columnwise (axis 1)

simba/mixins/timeseries_features_mixin.py

@@ -2198,7 +2198,7 @@ class TimeseriesFeatureMixin(object):
         :example:
         >>> x = np.random.randint(0, 100, (400, 2))
         >>> results_1 = TimeseriesFeatureMixin.sliding_entropy_of_directional_changes(x=x, bins=16, window_size=5.0, sample_rate=30)
-        >>> x = pd.read_csv(r"C:\troubleshooting\two_black_animals_14bp\project_folder\csv\input_csv\Together_1.csv")[['Ear_left_1_x', 'Ear_left_1_y']].values
+        >>> x = pd.read_csv(r"C:/troubleshooting/two_black_animals_14bp/project_folder/csv/input_csv/Together_1.csv")[['Ear_left_1_x', 'Ear_left_1_y']].values
         >>> results_2 = TimeseriesFeatureMixin.sliding_entropy_of_directional_changes(x=x, bins=16, window_size=5.0, sample_rate=30)
         """
 

simba/mixins/train_model_mixin.py

@@ -77,10 +77,10 @@ from simba.utils.errors import (ClassifierInferenceError, CorruptedFileError,
                                 SamplingError, SimBAModuleNotFoundError)
 from simba.utils.lookups import get_meta_data_file_headers, get_table
 from simba.utils.printing import SimbaTimer, stdout_success
-from simba.utils.read_write import (find_core_cnt, get_fn_ext,
-                                    get_memory_usage_of_df, get_pkg_version,
-                                    read_config_entry, read_df, read_meta_file,
-                                    str_2_bool)
+from simba.utils.read_write import (find_core_cnt, get_current_time,
+                                    get_fn_ext, get_memory_usage_of_df,
+                                    get_pkg_version, read_config_entry,
+                                    read_df, read_meta_file, str_2_bool)
 from simba.utils.warnings import (GPUToolsWarning, MissingUserInputWarning,
                                   MultiProcessingFailedWarning,
                                   NoModuleWarning, NotEnoughDataWarning,
@@ -1383,18 +1383,39 @@ class TrainModelMixin(object):
                           x_df: Union[pd.DataFrame, np.ndarray],
                           multiclass: bool = False,
                           model_name: Optional[str] = None,
-                          data_path: Optional[Union[str, os.PathLike]] = None) -> np.ndarray:
+                          data_path: Optional[Union[str, os.PathLike]] = None,
+                          verbose: bool = False) -> np.ndarray:
 
         """
-        :param RandomForestClassifier clf: Random forest classifier object
-        :param Union[pd.DataFrame, np.ndarray] x_df: Features for data to predict as a dataframe or array of size (M,N).
-        :param bool multiclass: If True, the classifier predicts more than 2 targets. Else, boolean classifier.
-        :param Optional[str] model_name: Name of model
-        :param Optional[str] data_path: Path to model on disk
-        :return np.ndarray: 2D array with frame represented by rows and present/absent probabilities as columns
-        :raises FeatureNumberMismatchError: If shape of x_df and clf.n_features_ or n_features_in_ show mismatch
+        Helper to predict class probabilities using a fitted random forest classifier.
+
+        Computes prediction probabilities for binary or multiclass classification using either
+        scikit-learn or cuML RandomForestClassifier. For binary classifiers, returns the
+        probability of the positive class (class 1). For multiclass classifiers, returns
+        probabilities for all classes.
+
+        .. csv-table::
+           :header: EXPECTED RUNTIMES
+           :file: ../../docs/tables/clf_predict_proba.csv
+           :widths: 10, 45, 45
+           :align: center
+           :header-rows: 1
+
+        .. seealso::
+           To fit a classifier, see :func:`simba.mixins.train_model_mixin.TrainModelMixin.clf_fit`
+           To define a classifier, see :func:`simba.mixins.train_model_mixin.TrainModelMixin.clf_define`
+
+        :param Union[RandomForestClassifier, cuRF] clf: Fitted random forest classifier object from sklearn or cuml.
+        :param Union[pd.DataFrame, np.ndarray] x_df: Features for data to predict. DataFrame or array of shape (n_samples, n_features).
+        :param bool multiclass: If True, the classifier predicts more than 2 classes. If False, binary classifier (default: False).
+        :param Optional[str] model_name: Name of the model for error messages and logging. Default: None.
+        :param Optional[Union[str, os.PathLike]] data_path: Path to the data file being processed, used in error messages. Default: None.
+        :param bool verbose: If True, print inference progress and timing information. Default: False.
+        :return np.ndarray: Prediction probabilities. For binary classifiers: 1D array of shape (n_samples,) with probability of positive class. For multiclass: 2D array of shape (n_samples, n_classes) with probabilities for each class.
+
         """
 
+        timer = SimbaTimer(start=True)
         if hasattr(clf, "n_features_"):
             clf_n_features = clf.n_features_
         elif hasattr(clf, "n_features_in_"):
@@ -1420,6 +1441,8 @@ class TrainModelMixin(object):
         p_vals = clf.predict_proba(x_df)
         if multiclass and (clf.n_classes_ != p_vals.shape[1]):
             raise ClassifierInferenceError(msg=f"The classifier {model_name} (data path: {data_path}) is a multiclassifier expected to create {clf.n_classes_} behavior probabilities. However, it produced probabilities for {p_vals.shape[1]} behaviors. See The SimBA GitHub FAQ page or Gitter for more information and suggested fixes.", source=self.__class__.__name__)
+        timer.stop_timer()
+        if verbose: print(f'Inference for model {model_name} over {x_df.shape[0]} observations complete ({timer.elapsed_time_str}s).')
         if not multiclass:
             if isinstance(p_vals, pd.DataFrame):
                 return p_vals[1].values
@@ -1447,7 +1470,7 @@ class TrainModelMixin(object):
                    bootstrap: Optional[bool] = True,
                    verbose: Optional[int] = 1,
                    class_weight: Optional[dict] = None,
-                   cuda: Optional[bool] = False) -> RandomForestClassifier:
+                   cuda: Optional[bool] = False) -> Union[RandomForestClassifier, cuRF]:
 
         if not cuda:
             # NOTE: LOKY ISSUES ON WINDOWS WITH SCIKIT IF THE CORE COUNT EXCEEDS 61.
@@ -1482,20 +1505,32 @@ class TrainModelMixin(object):
                 clf: Union[RandomForestClassifier, cuRF],
                 x_df: pd.DataFrame,
                 y_df: pd.DataFrame,
-                ) -> RandomForestClassifier:
+                verbose: bool = False) -> Union[RandomForestClassifier, cuRF]:
 
         """
-        Helper to fit clf model
+        Helper to fit clf model.
 
-        :param clf: Un-fitted random forest classifier object
+        .. csv-table::
+           :header: EXPECTED RUNTIMES
+           :file: ../../docs/tables/clf_fit.csv
+           :widths: 20, 20, 30, 30
+           :align: center
+           :header-rows: 1
+
+        .. seealso::
+           To define a cuml/sklearn object, see :func:`simba.mixins.train_model_mixin.TrainModelMixin.clf_define`
+
+        :param clf: Un-fitted random forest classifier object, either from sklearn or cuml.
         :param pd.DataFrame x_df: Pandas dataframe with features.
         :param pd.DataFrame y_df: Pandas dataframe/Series with target
         :return: Fitted random forest classifier object
         :rtype: RandomForestClassifier
         """
 
+        timer = SimbaTimer(start=True)
         nan_features = x_df[~x_df.applymap(np.isreal).all(1)]
         nan_target = y_df.loc[pd.to_numeric(y_df).isna()]
+        using_cuda = True if CUML in str(clf.__class__.__module__).lower() else False
         if len(nan_features) > 0:
             raise FaultyTrainingSetError(
                 msg=f"{len(nan_features)} frame(s) in your project_folder/csv/targets_inserted directory contains FEATURES with non-numerical values",
@@ -1504,9 +1539,16 @@ class TrainModelMixin(object):
             raise FaultyTrainingSetError(
                 msg=f"{len(nan_target)} frame(s) in your project_folder/csv/targets_inserted directory contains ANNOTATIONS with non-numerical values",
                 source=self.__class__.__name__)
+        if verbose: print(f'[{get_current_time()}] Fitting classifier for {len(x_df)} observations (cuda: {"True" if using_cuda else "False"})...')
+        if using_cuda:
+            x_data = x_df.values if isinstance(x_df, pd.DataFrame) else x_df
+            y_data = y_df.values if isinstance(y_df, (pd.DataFrame, pd.Series)) else y_df
+            clf.fit(x_data, y_data)
+        else:
+            clf.fit(x_df, y_df)
 
-        clf.fit(x_df, y_df)
-
+        timer.stop_timer()
+        if verbose: print(f'[{get_current_time()}] Classifier fitted in {timer.elapsed_time_str}s.')
         return clf
 
     @staticmethod
@@ -1563,9 +1605,7 @@ class TrainModelMixin(object):
         :rtype: Tuple[pd.DataFrame, List[int]]
 
         """
-        if (platform.system() == "Darwin") and (
-                multiprocessing.get_start_method() != "spawn"
-        ):
+        if (platform.system() == "Darwin") and (multiprocessing.get_start_method() != "spawn"):
             multiprocessing.set_start_method("spawn", force=True)
         cpu_cnt, _ = find_core_cnt()
         df_lst, frame_numbers_lst = [], []
@@ -1592,9 +1632,7 @@ class TrainModelMixin(object):
                         :, ~df_concat.columns.str.contains("^Unnamed")
                         ].astype(np.float32)
             memory_size = get_memory_usage_of_df(df=df_concat)
-            print(
-                f'Dataset size: {memory_size["megabytes"]}MB / {memory_size["gigabytes"]}GB'
-            )
+            print(f'Dataset size: {memory_size["megabytes"]}MB / {memory_size["gigabytes"]}GB')
 
             return df_concat, frame_numbers_lst
 
@@ -2607,9 +2645,9 @@ class TrainModelMixin(object):
         :param bool plot: If True, create SHAP aggregation and plots.
 
         :example:
-        >>> CONFIG_PATH = r"C:\troubleshooting\mitra\project_folder\project_config.ini"
-        >>> RF_PATH = r"C:\troubleshooting\mitra\models\validations\straub_tail_5_new\straub_tail_5.sav"
-        >>> DATA_PATH = r"C:\troubleshooting\mitra\project_folder\csv\targets_inserted\new_straub\appended\501_MA142_Gi_CNO_0514.csv"
+        >>> CONFIG_PATH = r"C:/troubleshooting/mitra/project_folder/project_config.ini"
+        >>> RF_PATH = r"C:/troubleshooting/mitra/models/validations/straub_tail_5_new/straub_tail_5.sav"
+        >>> DATA_PATH = r"C:/troubleshooting/mitra/project_folder/csv/targets_inserted/new_straub/appended/501_MA142_Gi_CNO_0514.csv"
         >>> config = ConfigReader(config_path=CONFIG_PATH)
         >>> df = read_df(file_path=DATA_PATH, file_type='csv')
         >>> y = df['straub_tail']

simba/model/inference_batch.py

@@ -45,7 +45,7 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
     >>> inferencer.run()
 
     :example II:
-    >>> inferencer = InferenceBatch(config_path=r"D:\troubleshooting\mitra\project_folder\project_config.ini", features_dir=r"D:\troubleshooting\mitra\project_folder\videos\bg_removed\rotated\tail_features\APPENDED")
+    >>> inferencer = InferenceBatch(config_path=r"D:/troubleshooting/mitra/project_folder/project_config.ini", features_dir=r"D:/troubleshooting/mitra/project_folder/videos/bg_removed/rotated/tail_features/APPENDED")
     >>> inferencer.run()
     """
 

simba/model/yolo_seg_inference.py

@@ -55,9 +55,9 @@ class YOLOSegmentationInference():
        To visualize the segmentation results, see :func:`simba.plotting.yolo_seg_visualizer.YOLOSegmentationVisualizer`
 
     :example:
-    >>> weights_path = r"D:\platea\yolo_071525\mdl\train3\weights\best.pt"
-    >>> video_path = r"D:\platea\platea_videos\videos\clipped\10B_Mouse_5-choice_MustTouchTrainingNEWFINAL_a7.mp4"
-    >>> save_dir=r"D:\platea\platea_videos\videos\yolo_results"
+    >>> weights_path = r"D:/platea/yolo_071525/mdl/train3/weights/best.pt"
+    >>> video_path = r"D:/platea/platea_videos/videos/clipped/10B_Mouse_5-choice_MustTouchTrainingNEWFINAL_a7.mp4"
+    >>> save_dir = r"D:/platea/platea_videos/videos/yolo_results"
     >>> runner = YOLOSegmentationInference(weights_path=weights_path, video_path=video_path, save_dir=save_dir, verbose=True, device=0, format=None, stream=True, batch_size=10, imgsz=320, interpolate=True, threshold=0.8, retina_msk=True)
     >>> runner.run()
 

simba/plotting/heat_mapper_clf_mp.py

@@ -98,14 +98,14 @@ class HeatMapperClfMultiprocess(ConfigReader, PlottingMixin):
 
 
     :example II:
-    >>> test = HeatMapperClfMultiprocess(config_path=r"C:\troubleshooting\RAT_NOR\project_folder\project_config.ini",
+    >>> test = HeatMapperClfMultiprocess(config_path=r"C:/troubleshooting/RAT_NOR/project_folder/project_config.ini",
     >>>                          style_attr = {'palette': 'jet', 'shading': 'gouraud', 'bin_size': 50, 'max_scale': 'auto'},
     >>>                          final_img_setting=True,
     >>>                          video_setting=True,
     >>>                          frame_setting=True,
     >>>                          bodypart='Ear_left',
     >>>                          clf_name='straub_tail',
-    >>>                          data_paths=[r"C:\troubleshooting\RAT_NOR\project_folder\csv\test\2022-06-20_NOB_DOT_4.csv"])
+    >>>                          data_paths=[r"C:/troubleshooting/RAT_NOR/project_folder/csv/test/2022-06-20_NOB_DOT_4.csv"])
     >>> test.run()
     """
 

simba/pose_importers/simba_blob_importer.py

@@ -44,10 +44,10 @@ class SimBABlobImporter(ConfigReader):
     :param Optional[bool] verbose: If True, prints progress messages. Default: True.
 
     :example:
-    >>> r = SimBABlobImporter(config_path=r"C:\troubleshooting\simba_blob_project\project_folder\project_config.ini", data_path=r'C:\troubleshooting\simba_blob_project\data')
+    >>> r = SimBABlobImporter(config_path=r"C:/troubleshooting/simba_blob_project/project_folder/project_config.ini", data_path=r'C:/troubleshooting/simba_blob_project/data')
     >>> r.run()
-    >>> r = SimBABlobImporter(config_path=r"C:\troubleshooting\simba_blob_project\project_folder\project_config.ini", 
-    ...                       data_path=r'C:\troubleshooting\simba_blob_project\data',
+    >>> r = SimBABlobImporter(config_path=r"C:/troubleshooting/simba_blob_project/project_folder/project_config.ini", 
+    ...                       data_path=r'C:/troubleshooting/simba_blob_project/data',
     ...                       smoothing_settings={'method': 'savitzky-golay', 'time_window': 100},
     ...                       interpolation_settings={'method': 'nearest', 'type': 'body-parts'})
     >>> r.run()

simba/roi_tools/roi_aggregate_stats_mp.py

@@ -168,7 +168,7 @@ class ROIAggregateStatisticsAnalyzerMultiprocess(ConfigReader, FeatureExtraction
     :param save_path (str | os.PathLike, optional): Path to save summary statistics.
 
     :example:
-    >>> analyzer = ROIAggregateStatisticsAnalyzerMultiprocess(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini", body_parts=['Center'], first_entry_time=True, threshold=0.0, calculate_distances=True, transpose=False, detailed_bout_data=True)
+    >>> analyzer = ROIAggregateStatisticsAnalyzerMultiprocess(config_path=r"C:/troubleshooting/mitra/project_folder/project_config.ini", body_parts=['Center'], first_entry_time=True, threshold=0.0, calculate_distances=True, transpose=False, detailed_bout_data=True)
     >>> analyzer.run()
     >>> analyzer.save()
     """

simba/roi_tools/roi_clf_calculator_mp.py

@@ -150,7 +150,7 @@ class ROIClfCalculatorMultiprocess(ConfigReader):
        'GitHub tutorial <https://github.com/sgoldenlab/simba/blob/master/docs/Scenario2.md#part-4--analyze-machine-results`__.
 
     :example:
-    >>> analyzer = ROIClfCalculatorMultiprocess(config_path=r"D:\troubleshooting\maplight_ri\project_folder\project_config.ini", bp_names=['resident_NOSE'], clf_names=['attack'], clf_time=True, started_bout_cnt=True, ended_bout_cnt=False, bout_table=True, transpose=True, core_cnt=20)
+    >>> analyzer = ROIClfCalculatorMultiprocess(config_path=r"D:/troubleshooting/maplight_ri/project_folder/project_config.ini", bp_names=['resident_NOSE'], clf_names=['attack'], clf_time=True, started_bout_cnt=True, ended_bout_cnt=False, bout_table=True, transpose=True, core_cnt=20)
     >>> analyzer.run()
     >>> analyzer.save()
     """

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