simba-uw-tf-dev 4.5.8__py3-none-any.whl → 4.7.1__py3-none-any.whl

simba/mixins/plotting_mixin.py

@@ -39,7 +39,7 @@ from simba.utils.data import create_color_palette, detect_bouts
 from simba.utils.enums import Formats, Keys, Options, Paths
 from simba.utils.errors import InvalidInputError
 from simba.utils.lookups import (get_categorical_palettes, get_color_dict,
-                                 get_named_colors)
+                                 get_fonts, get_named_colors)
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_fn_ext, get_video_meta_data, read_df,
@@ -342,16 +342,28 @@ class PlottingMixin(object):
                         height: int = 480,
                         font_size: int = 8,
                         font_rotation: int = 45,
+                        font: Optional[str] = None,
                         save_path: Optional[str] = None,
+                        edge_clr: Optional[str] = 'black',
                         hhmmss: bool = False) -> Union[None, np.ndarray]:
 
         video_timer = SimbaTimer(start=True)
         colour_tuple_x = list(np.arange(3.5, 203.5, 5))
+        original_font_family = copy(plt.rcParams['font.family']) if isinstance(plt.rcParams['font.family'], list) else plt.rcParams['font.family']
+        
+        if font is not None:
+            available_fonts = get_fonts()
+            if font in available_fonts:
+                matplotlib.font_manager._get_font.cache_clear()
+                plt.rcParams['font.family'] = font
+            else:
+                matplotlib.font_manager._get_font.cache_clear()
+                plt.rcParams['font.family'] = [font, 'sans-serif']
+        
         fig, ax = plt.subplots()
-        fig.patch.set_facecolor('#fafafa')
-        ax.set_facecolor('#ffffff')
         fig.patch.set_facecolor('white')
-        plt.title(video_name, fontsize=font_size + 6, pad=15, fontweight='bold')
+        
+        plt.title(video_name, fontsize=font_size + 6, pad=25, fontweight='bold')
         ax.spines['top'].set_visible(False)
         ax.spines['right'].set_visible(False)
         ax.spines['left'].set_color('#666666')
@@ -367,7 +379,7 @@ class PlottingMixin(object):
                 if event[0] == x:
                     ix = clf_names.index(x)
                     data_event = event[1][["Start_time", "Bout_time"]]
-                    ax.broken_barh(data_event.values, (colour_tuple_x[ix], 3), facecolors=palette[ix])
+                    ax.broken_barh(data_event.values, (colour_tuple_x[ix], 3), facecolors=palette[ix], edgecolor=edge_clr, linewidth=0.5, alpha=0.9)
 
         x_ticks_seconds = np.round(np.linspace(0, x_length / fps, 6))
         x_ticks_locs = x_ticks_seconds
@@ -375,18 +387,19 @@ class PlottingMixin(object):
         if hhmmss:
             x_lbls = [seconds_to_timestamp(sec) for sec in x_ticks_seconds]
         else:
-            x_lbls = x_ticks_seconds
+            x_lbls = [int(x) for x in x_ticks_seconds]
 
-        #x_ticks_locs = x_lbls = np.round(np.linspace(0, x_length / fps, 6))
         ax.set_xticks(x_ticks_locs)
         ax.set_xticklabels(x_lbls)
         ax.set_ylim(0, colour_tuple_x[len(clf_names)])
         ax.set_yticks(np.arange(5, 5 * len(clf_names) + 1, 5))
-        ax.set_yticklabels(clf_names, rotation=font_rotation)
+        ax.set_yticklabels(clf_names, rotation=font_rotation, ha='right', va='center')
         ax.tick_params(axis="both", labelsize=font_size)
         plt.xlabel(x_label, fontsize=font_size + 3)
-        ax.yaxis.grid(True, linewidth=1.5, color='gray', alpha=0.4, linestyle='--')
-        #ax.yaxis.grid(True)
+        ax.grid(True, axis='both', linewidth=1.0, color='gray', alpha=0.2, linestyle='--', which='major')
+
+        plt.subplots_adjust(left=0.1, right=0.95, top=0.9, bottom=0.15)
+        plt.tight_layout()
         buffer_ = io.BytesIO()
         plt.savefig(buffer_, format="png")
         buffer_.seek(0)
@@ -397,6 +410,11 @@ class PlottingMixin(object):
         frame = np.uint8(open_cv_image)
         buffer_.close()
         plt.close('all')
+
+        if font is not None:
+            plt.rcParams['font.family'] = original_font_family
+            matplotlib.font_manager._get_font.cache_clear()
+        
         if save_path is not None:
             cv2.imwrite(save_path, frame)
             video_timer.stop_timer()

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

@@ -67,7 +67,7 @@ from simba.utils.checks import (check_all_dfs_in_list_has_same_cols,
                                 check_valid_boolean, check_valid_dataframe,
                                 check_valid_lst, is_lxc_container)
 from simba.utils.data import (detect_bouts, detect_bouts_multiclass,
-                              get_library_version)
+                              get_library_version, terminate_cpu_pool)
 from simba.utils.enums import (OS, ConfigKey, Defaults, Dtypes, Formats, Links,
                                Methods, MLParamKeys, Options)
 from simba.utils.errors import (ClassifierInferenceError, CorruptedFileError,
@@ -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
 
@@ -1859,7 +1897,7 @@ class TrainModelMixin(object):
                     shap_raw.append(shap_data[result[1]][1].drop(clf_name, axis=1))
                     if verbose: print(f"Completed SHAP care batch (Batch {result[1] + 1}/{len(shap_data)}).")
 
-            pool.terminate(); pool.join()
+            terminate_cpu_pool(pool=pool, force=False)
             shap_df = pd.DataFrame(data=np.row_stack(shap_results), columns=list(x_names) + ["Expected_value", "Sum", "Prediction_probability", clf_name])
             raw_df = pd.DataFrame(data=np.row_stack(shap_raw), columns=list(x_names))
             out_shap_path, out_raw_path, img_save_path, df_save_paths, summary_dfs, img = None, None, None, None, None, None
@@ -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/outlier_tools/skip_outlier_correction.py

@@ -47,5 +47,5 @@ class OutlierCorrectionSkipper(ConfigReader):
         self.timer.stop_timer()
         stdout_success(msg=f"Skipped outlier correction for {len(self.input_csv_paths)} files", elapsed_time=self.timer.elapsed_time_str)
 
-# test = OutlierCorrectionSkipper(config_path='/Users/simon/Desktop/envs/troubleshooting/naresh/project_folder/project_config.ini')
+# test = OutlierCorrectionSkipper(config_path=r"E:\troubleshooting\mitra_emergence\project_folder\project_config.ini")
 # test.run()

simba/plotting/ROI_feature_visualizer_mp.py

@@ -24,10 +24,9 @@ from simba.utils.checks import (check_file_exist_and_readable,
                                 check_if_valid_rgb_tuple, check_int, check_str,
                                 check_valid_boolean, check_valid_lst,
                                 check_video_and_data_frm_count_align)
-from simba.utils.data import slice_roi_dict_for_video
+from simba.utils.data import slice_roi_dict_for_video, terminate_cpu_pool
 from simba.utils.enums import Formats, TextOptions
-from simba.utils.errors import (BodypartColumnNotFoundError, NoFilesFoundError,
-                                ROICoordinatesNotFoundError)
+from simba.utils.errors import BodypartColumnNotFoundError, NoFilesFoundError
 from simba.utils.printing import stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     find_core_cnt, get_fn_ext,
@@ -315,8 +314,7 @@ class ROIfeatureVisualizerMultiprocess(ConfigReader):
             print(f"Joining {self.video_name} multi-processed video...")
             concatenate_videos_in_folder(in_folder=self.save_temp_dir, save_path=self.save_path, video_format="mp4", remove_splits=True, gpu=self.gpu)
             self.timer.stop_timer()
-            pool.terminate()
-            pool.join()
+            terminate_cpu_pool(pool=pool, force=False)
             stdout_success(msg=f"Video {self.video_name} complete. Video saved in directory {self.roi_features_save_dir}.", elapsed_time=self.timer.elapsed_time_str)
 
 

simba/plotting/clf_validator_mp.py

@@ -14,9 +14,9 @@ from simba.mixins.plotting_mixin import PlottingMixin
 from simba.utils.checks import (check_float, check_if_valid_rgb_tuple,
                                 check_int, check_str, check_that_column_exist,
                                 check_valid_lst)
-from simba.utils.data import detect_bouts
-from simba.utils.enums import Formats, TagNames, TextOptions
-from simba.utils.errors import NoFilesFoundError, NoSpecifiedOutputError
+from simba.utils.data import detect_bouts, terminate_cpu_pool
+from simba.utils.enums import Formats, TextOptions
+from simba.utils.errors import NoSpecifiedOutputError
 from simba.utils.printing import SimbaTimer, log_event, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     find_core_cnt, get_fn_ext,
@@ -218,8 +218,7 @@ class ClassifierValidationClipsMultiprocess(ConfigReader):
                 for cnt, result in enumerate(
                     pool.imap(constants, clip_data, chunksize=self.multiprocess_chunksize)):
                     print(f"Bout {cnt+1} complete...")
-                pool.terminate()
-                pool.join()
+                terminate_cpu_pool(pool=pool, force=False)
 
             if self.concat_video:
                 print(f"Joining {file_name} multiprocessed video...")

simba/plotting/cue_light_visualizer.py

@@ -1,10 +1,9 @@
 __author__ = "Simon Nilsson; sronilsson@gmail.com"
 
 import functools
-import itertools
 import multiprocessing
 import os
-from typing import List, Optional, Union
+from typing import List, Union
 
 import cv2
 import numpy as np
@@ -16,14 +15,15 @@ from simba.utils.checks import (check_file_exist_and_readable, check_int,
                                 check_valid_boolean, check_valid_dataframe,
                                 check_valid_lst)
 from simba.utils.data import (create_color_palettes, detect_bouts,
-                              slice_roi_dict_from_attribute)
-from simba.utils.enums import Defaults, Formats, Keys, TextOptions
+                              slice_roi_dict_from_attribute,
+                              terminate_cpu_pool)
+from simba.utils.enums import Defaults, Formats, TextOptions
 from simba.utils.errors import NoROIDataError, NoSpecifiedOutputError
 from simba.utils.printing import stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory, find_core_cnt,
                                     get_fn_ext, get_video_meta_data, read_df,
-                                    read_frm_of_video, remove_a_folder)
+                                    read_frm_of_video)
 
 
 def _plot_cue_light_data(frm_idxs: list,
@@ -197,8 +197,7 @@ class CueLightVisualizer(ConfigReader):
             for cnt, result in enumerate(pool.imap(constants, self.frame_chunks, chunksize=self.multiprocess_chunksize)):
                 if self.verbose:
                     print(f'Batch {int(result+1/self.core_cnt)} complete...')
-            pool.terminate()
-            pool.join()
+            terminate_cpu_pool(pool=pool, force=False)
         self.timer.stop_timer()
         if self.video_setting:
             print(f"Joining {self.video_name} multiprocessed video...")

simba/plotting/directing_animals_visualizer_mp.py

@@ -19,7 +19,7 @@ from simba.utils.checks import (check_file_exist_and_readable,
                                 check_if_valid_rgb_tuple, check_int,
                                 check_valid_lst,
                                 check_video_and_data_frm_count_align)
-from simba.utils.data import create_color_palettes
+from simba.utils.data import create_color_palettes, terminate_cpu_pool
 from simba.utils.enums import OS, Formats, Keys, TextOptions
 from simba.utils.errors import (AnimalNumberError, InvalidInputError,
                                 NoFilesFoundError)
@@ -226,8 +226,7 @@ class DirectingOtherAnimalsVisualizerMultiprocess(ConfigReader, PlottingMixin):
             print(f"Joining {self.video_name} multi-processed video...")
             concatenate_videos_in_folder(in_folder=self.save_temp_path, save_path=self.save_path, video_format="mp4", remove_splits=True)
             self.timer.stop_timer()
-            pool.terminate()
-            pool.join()
+            terminate_cpu_pool(pool=pool, force=False)
             stdout_success(msg=f"Video {self.video_name} complete. Video saved in {self.directing_animals_video_output_path} directory", elapsed_time=self.timer.elapsed_time_str)