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

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

@@ -1,30 +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)")
+"""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)")

simba/sandbox/test_directionality.py

@@ -1,47 +1,47 @@
-"""Test directionality_to_nonstatic_target function"""
-import sys
-import numpy as np
-
-print(f"Python: {sys.executable}")
-print("="*60)
-
-try:
-    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
-    print("✓ Function imported successfully")
-except Exception as e:
-    print(f"✗ Error importing function: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-# Create test data
-print("\nCreating test data...")
-left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-
-print(f"left_ear shape: {left_ear.shape}, dtype: {left_ear.dtype}")
-print(f"right_ear shape: {right_ear.shape}, dtype: {right_ear.dtype}")
-print(f"nose shape: {nose.shape}, dtype: {nose.dtype}")
-print(f"target shape: {target.shape}, dtype: {target.dtype}")
-
-# Test the function
-print("\nTesting directionality_to_nonstatic_target...")
-try:
-    result = directionality_to_nonstatic_target(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}")
-    print(f"Result: {result}")
-except Exception as e:
-    print(f"✗ Error running function: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-print("\n" + "="*60)
-print("Test passed!")
+"""Test directionality_to_nonstatic_target function"""
+import sys
+import numpy as np
+
+print(f"Python: {sys.executable}")
+print("="*60)
+
+try:
+    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+    print("✓ Function imported successfully")
+except Exception as e:
+    print(f"✗ Error importing function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+# Create test data
+print("\nCreating test data...")
+left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+
+print(f"left_ear shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+print(f"right_ear shape: {right_ear.shape}, dtype: {right_ear.dtype}")
+print(f"nose shape: {nose.shape}, dtype: {nose.dtype}")
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+# Test the function
+print("\nTesting directionality_to_nonstatic_target...")
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"Result: {result}")
+except Exception as e:
+    print(f"✗ Error running function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+print("\n" + "="*60)
+print("Test passed!")

simba/sandbox/test_nonstatic_directionality.py

@@ -1,27 +1,27 @@
-"""Test directionality_to_nonstatic_target with int64"""
-import numpy as np
-from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
-
-print("Testing directionality_to_nonstatic_target with int64...")
-
-left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-nose = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-target = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-
-print(f"Arrays shape: {left_ear.shape}, dtype: {left_ear.dtype}")
-
-try:
-    result = directionality_to_nonstatic_target(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target,
-        verbose=True
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}, dtype: {result.dtype}")
-    print(f"First 5 results:\n{result[:5]}")
-except Exception as e:
-    print(f"✗ Error: {e}")
-    import traceback
-    traceback.print_exc()
+"""Test directionality_to_nonstatic_target with int64"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+
+print("Testing directionality_to_nonstatic_target with int64...")
+
+left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+nose = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+target = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+
+print(f"Arrays shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target,
+        verbose=True
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}, dtype: {result.dtype}")
+    print(f"First 5 results:\n{result[:5]}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/test_pycharm_cuda.py

@@ -1,51 +1,51 @@
-"""Test script to verify PyCharm CUDA environment setup"""
-import sys
-print(f"Python version: {sys.version}")
-print(f"Python path: {sys.executable}")
-
-try:
-    from numba import cuda
-    print(f"\nNumba CUDA available: {cuda.is_available()}")
-    if cuda.is_available():
-        print(f"CUDA devices: {len(cuda.gpus)}")
-except Exception as e:
-    print(f"\nError importing numba.cuda: {e}")
-
-try:
-    import cupy as cp
-    print(f"CuPy version: {cp.__version__}")
-    # Test CuPy
-    x = cp.array([1, 2, 3, 4, 5])
-    print(f"CuPy test array: {x.get()}")
-except Exception as e:
-    print(f"Error importing cupy: {e}")
-
-try:
-    import numpy as np
-    print(f"NumPy version: {np.__version__}")
-except Exception as e:
-    print(f"Error importing numpy: {e}")
-
-try:
-    import cv2
-    print(f"OpenCV version: {cv2.__version__}")
-except Exception as e:
-    print(f"Error importing cv2: {e}")
-
-# Test SimBA CUDA imports
-try:
-    from simba.data_processors.cuda.geometry import is_inside_rectangle
-    print("\n✓ Successfully imported simba.data_processors.cuda.geometry")
-    
-    # Quick test
-    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
-    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
-    result = is_inside_rectangle(x=test_points, y=test_rect)
-    print(f"✓ is_inside_rectangle test passed: {result}")
-except Exception as e:
-    print(f"\n✗ Error importing SimBA CUDA functions: {e}")
-    import traceback
-    traceback.print_exc()
-
-print("\n" + "="*50)
-print("Environment check complete!")
+"""Test script to verify PyCharm CUDA environment setup"""
+import sys
+print(f"Python version: {sys.version}")
+print(f"Python path: {sys.executable}")
+
+try:
+    from numba import cuda
+    print(f"\nNumba CUDA available: {cuda.is_available()}")
+    if cuda.is_available():
+        print(f"CUDA devices: {len(cuda.gpus)}")
+except Exception as e:
+    print(f"\nError importing numba.cuda: {e}")
+
+try:
+    import cupy as cp
+    print(f"CuPy version: {cp.__version__}")
+    # Test CuPy
+    x = cp.array([1, 2, 3, 4, 5])
+    print(f"CuPy test array: {x.get()}")
+except Exception as e:
+    print(f"Error importing cupy: {e}")
+
+try:
+    import numpy as np
+    print(f"NumPy version: {np.__version__}")
+except Exception as e:
+    print(f"Error importing numpy: {e}")
+
+try:
+    import cv2
+    print(f"OpenCV version: {cv2.__version__}")
+except Exception as e:
+    print(f"Error importing cv2: {e}")
+
+# Test SimBA CUDA imports
+try:
+    from simba.data_processors.cuda.geometry import is_inside_rectangle
+    print("\n✓ Successfully imported simba.data_processors.cuda.geometry")
+    
+    # Quick test
+    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
+    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
+    result = is_inside_rectangle(x=test_points, y=test_rect)
+    print(f"✓ is_inside_rectangle test passed: {result}")
+except Exception as e:
+    print(f"\n✗ Error importing SimBA CUDA functions: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "="*50)
+print("Environment check complete!")