simba-uw-tf-dev 5.3.6__tar.gz → 5.3.7__tar.gz

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.3.6
+Version: 5.3.7
 Summary: Toolkit for computer classification and analysis of behaviors in experimental animals
 Home-page: https://github.com/sgoldenlab/simba
 Author: Simon Nilsson, Jia Jie Choong, Sophia Hwang

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/setup.py

@@ -29,7 +29,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="5.3.6",
+    version="5.3.7",
     author="Simon Nilsson, Jia Jie Choong, Sophia Hwang",
     author_email="sronilsson@gmail.com",
     description="Toolkit for computer classification and analysis of behaviors in experimental animals",

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/__init__.py

@@ -3,6 +3,7 @@ SimBA (Simple Behavioral Analysis)
 Toolkit for computer classification and analysis of behaviors in experimental animals
 """
 import matplotlib
+
 matplotlib.use("Agg")
 
 import multiprocessing

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/assets/.recent_projects.txt

@@ -1,3 +1,4 @@
+G:/projects/jason_zhang/jason_project/project_folder/project_config.ini
 G:/projects/edmayelle/superanimal_multianimal_project/project_folder/project_config.ini
 D:/troubleshooting/open_field_rearing/project_folder/project_config.ini
 F:/troubleshooting/varsha/project_folder/project_config.ini

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/data_processors/agg_clf_calculator.py

@@ -68,6 +68,7 @@ class AggregateClfCalculator(ConfigReader):
     :param bool median_interval_duration: If True, calculates median interval between bouts for each classifier. Default: True.
     :param bool frame_count: If True, includes total frame count in the output. Default: False.
     :param bool video_length: If True, includes video length in seconds in the output. Default: False.
+    :param Optional[Union[str, os.PathLike]] save_dir: Optional directory in which to save the output CSVs (``data_summary_*.csv`` and, if requested, ``detailed_bout_data_summary_*.csv``). If None, defaults to the project's ``logs_path``. Default: None.
 
     :raises NoChoosenMeasurementError: If no measurement types are selected (all measurement booleans are False).
 
@@ -87,7 +88,7 @@ class AggregateClfCalculator(ConfigReader):
                  classifiers: List[str],
                  data_dir: Optional[Union[str, os.PathLike]] = None,
                  detailed_bout_data: bool = False,
-                 transpose: bool = False,
+                 transpose: bool = True,
                  first_occurrence: bool = True,
                  event_count: bool = True,
                  total_event_duration: bool = True,
@@ -97,14 +98,16 @@ class AggregateClfCalculator(ConfigReader):
                  mean_interval_duration: bool = True,
                  median_interval_duration: bool = True,
                  frame_count: bool = False,
-                 video_length: bool = False):
+                 video_length: bool = False,
+                 save_dir: Optional[Union[str, os.PathLike]] = None):
 
         super().__init__(config_path=config_path)
         log_event(logger_name=str(self.__class__.__name__), log_type=TagNames.CLASS_INIT.value, msg=self.create_log_msg_from_init_args(locals=locals()))
-        check_valid_lst(data=classifiers, source=f'{self.__class__.__name__} classifiers', min_len=1, valid_dtypes=(str,), valid_values=self.clf_names)
         if data_dir is None:
+            check_valid_lst(data=classifiers, source=f'{self.__class__.__name__} classifiers', min_len=1, valid_dtypes=(str,), valid_values=self.clf_names)
             data_dir = self.machine_results_dir
         else:
+            check_valid_lst(data=classifiers, source=f'{self.__class__.__name__} classifiers', min_len=1, valid_dtypes=(str,))
             check_if_dir_exists(in_dir=data_dir)
         self.data_paths = find_files_of_filetypes_in_directory(directory=data_dir, extensions=[f'.{self.file_type}'], raise_error=True)
 
@@ -130,15 +133,20 @@ class AggregateClfCalculator(ConfigReader):
         self.median_interval_duration = median_interval_duration
         self.frame_count = frame_count
         self.video_length = video_length
-        self.save_path = os.path.join(self.logs_path, f"data_summary_{self.datetime}.csv")
-        self.detailed_save_path = os.path.join(self.logs_path, f"detailed_bout_data_summary_{self.datetime}.csv")
+        if save_dir is not None:
+            check_if_dir_exists(in_dir=save_dir, source=f'{self.__class__.__name__} save_dir')
+            self.save_dir = save_dir
+        else:
+            self.save_dir = self.logs_path
+        self.save_path = os.path.join(self.save_dir, f"data_summary_{self.datetime}.csv")
+        self.detailed_save_path = os.path.join(self.save_dir, f"detailed_bout_data_summary_{self.datetime}.csv")
 
     def run(self):
         self.results_df, self.bouts_df_lst = pd.DataFrame(), []
-        check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.machine_results_paths)
+        check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.data_paths)
         for file_cnt, file_path in enumerate(self.data_paths):
             _, file_name, _ = get_fn_ext(file_path)
-            stdout_information(msg=f"Analyzing classifier descriptive statistics for video {file_name} ({file_cnt+1}/{len(self.machine_results_paths)})...")
+            stdout_information(msg=f"Analyzing classifier descriptive statistics for video {file_name} ({file_cnt+1}/{len(self.data_paths)})...")
             _, _, fps = self.read_video_info(video_name=file_name)
             check_file_exist_and_readable(file_path)
             data_df = read_df(file_path, self.file_type)

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/data_processors/agg_clf_counter_mp.py

@@ -286,18 +286,18 @@ class AggregateClfCalculatorMultiprocess(ConfigReader):
 #     clf_calculator.run()
 #     clf_calculator.save()
 
-if __name__ == "__main__":
-    test = AggregateClfCalculatorMultiprocess(config_path=r"D:\troubleshooting\maplight_ri\project_folder\project_config.ini",
-                                  classifiers=['attack'],
-                                  transpose=True,
-                                  mean_event_duration = True,
-                                  median_event_duration = True,
-                                  mean_interval_duration = True,
-                                  median_interval_duration = True,
-                                  detailed_bout_data=True,
-                                  core_cnt=12)
-    test.run()
-    test.save()
+#if __name__ == "__main__":
+    # test = AggregateClfCalculatorMultiprocess(config_path=r"D:\troubleshooting\maplight_ri\project_folder\project_config.ini",
+    #                               classifiers=['attack'],
+    #                               transpose=True,
+    #                               mean_event_duration = True,
+    #                               median_event_duration = True,
+    #                               mean_interval_duration = True,
+    #                               median_interval_duration = True,
+    #                               detailed_bout_data=True,
+    #                               core_cnt=12)
+    # test.run()
+    # test.save()
 
 
 # test = AggregateClfCalculator(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini",

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/data_processors/freezing_detector.py

@@ -163,6 +163,16 @@ class FreezingDetector(ConfigReader):
         agg_results.to_csv(agg_results_path)
         self.timer.stop_timer(); stdout_success(msg=f'Results saved in {self.save_dir} directory.', elapsed_time=self.timer.elapsed_time_str)
 
+#
+# FreezingDetector(
+#     data_dir=r'G:\projects\jason_zhang\jason_project\project_folder\csv\outlier_corrected_movement_location',
+#     config_path=r"G:\projects\jason_zhang\jason_project\project_folder\project_config.ini",
+#     time_window=3,
+#     movement_threshold=3,
+#     shortest_bout=100
+# ).run()
+
+
 
 # FreezingDetector(
 #     data_dir=r'F:\troubleshooting\sam\sam\project_folder\csv\outlier_corrected_movement_location',

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/feature_extractors/mitra_feature_extractor.py

@@ -22,13 +22,13 @@ from simba.utils.read_write import (SimbaTimer, get_fn_ext, read_df,
                                     write_df)
 
 NOSE = 'nose'
-LEFT_SIDE = 'left_side'
-RIGHT_SIDE = 'right side'
+LEFT_SIDE = 'lat_left'
+RIGHT_SIDE = 'lat_right'
 LEFT_EAR = 'left_ear'
 RIGHT_EAR = 'right_ear'
 CENTER = 'center'
 TAIL_BASE = 'tail_base'
-TAIL_CENTER = 'tail_mid'
+TAIL_CENTER = 'tail_center'
 TAIL_TIP = 'tail_end'
 
 TIME_WINDOWS = np.array([0.25, 0.5, 1.0, 2.0])
@@ -231,8 +231,8 @@ class MitraFeatureExtractor(ConfigReader,
 #     feature_extractor = MitraFeatureExtractor(config_path=args.config_path)
 #     feature_extractor.run()
 #
-#feature_extractor = MitraFeatureExtractor(config_path=r"F:\troubleshooting\sam\sam\project_folder\project_config.ini")
-#feature_extractor.run()
+# feature_extractor = MitraFeatureExtractor(config_path=r"G:\projects\jason_zhang\jason_project\project_folder\project_config.ini")
+# feature_extractor.run()
 
 
 # feature_extractor = MitraFeatureExtractor(config_path=r"E:\troubleshooting\mitra_pbn\mitra_pbn\project_folder\project_config.ini")

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/mixins/geometry_mixin.py

@@ -1169,7 +1169,7 @@ class GeometryMixin(object):
             check_int(name=f'{GeometryMixin.__name__} minimum_rotated_rectangle buffer', min_value=1, value=buffer)
             shape = shape.buffer(distance=buffer)
         rotated_rectangle = shape.minimum_rotated_rectangle
-        if isinstance(rotated_rectangle, Point):
+        if isinstance(rotated_rectangle, (Point, LineString)):
             rotated_rectangle = Polygon([(0, 0), (0, 0), (0, 0)])
         if return_type == 'array':
             rotated_rectangle = np.round(np.array(rotated_rectangle.exterior.coords)).astype(np.int32)

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/model/inference_batch.py

@@ -8,10 +8,12 @@ from typing import Dict, List, Optional, Union
 
 import numpy as np
 
+from simba.data_processors.agg_clf_calculator import AggregateClfCalculator
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.train_model_mixin import TrainModelMixin
 from simba.utils.checks import (
-    check_all_file_names_are_represented_in_video_log, check_if_dir_exists,
+    check_all_file_names_are_represented_in_video_log,
+    check_file_exist_and_readable, check_float, check_if_dir_exists,
     check_if_keys_exist_in_dict, check_int, check_that_column_exist,
     check_valid_dict, check_valid_lst)
 from simba.utils.data import plug_holes_shortest_bout
@@ -41,6 +43,8 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
     :param Optional[Union[str, os.PathLike]] save_dir: Optional directory to save the data for the analyzed videos. If None, then the `project_folder/csv/machine_results` directory of the project will be used.
     :param Optional[int] minimum_bout_length: Optional minimum bout length (milliseconds) override. If None, classifier-specific minimum bout settings from project configuration are used.
     :param Optional[Dict[str, Dict[str, List[str]]]] feature_subsets_by_clf: Optional per-classifier feature subsets to use during inference. Format: ``{classifier_name: {subset_name: [feature_col_1, feature_col_2, ...]}}``. If provided, each classifier is applied once per subset and outputs are suffixed with the subset name.
+    :param Optional[Dict[str, Dict[str, Union[str, int, float]]]] model_dict: Optional override of the classifiers to run. Format: ``{model_name: {'model_path': '/path/to/clf.sav', 'minimum_bout_length': 100, 'threshold': 0.5}}``. If None, classifier definitions are read from the project config (current behavior). When provided, these models replace the project-config classifiers for this run.
+    :param Optional[Union[str, os.PathLike]] save_agg_stats: Optional directory in which to save aggregate classifier statistics. If None, no aggregate statistics are computed. If a directory is provided, :class:`simba.data_processors.agg_clf_calculator.AggregateClfCalculator` is run after inference completes, reading from this class's ``save_dir`` and writing its CSV outputs to ``save_agg_stats``.
     :param bool verbose: If True, print progress and status messages during inference. Default: True.
 
     :example I:
@@ -58,6 +62,8 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
                  save_dir: Optional[Union[str, os.PathLike]] = None,
                  minimum_bout_length: Optional[int] = None,
                  feature_subsets_by_clf: Optional[Dict[str, Dict[str, List[str]]]] = None,
+                 model_dict: Optional[Dict[str, Dict[str, Union[str, int, float]]]] = None,
+                 save_agg_stats: Optional[Union[str, os.PathLike]] = None,
                  verbose: bool = True):
 
         ConfigReader.__init__(self, config_path=config_path)
@@ -74,6 +80,20 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
         log_event(logger_name=str(self.__class__.__name__), log_type=TagNames.CLASS_INIT.value, msg=self.create_log_msg_from_init_args(locals=locals()))
         if len(self.feature_file_paths) == 0:
             raise NoFilesFoundError(msg=f"Zero files found in the {self.features_dir}. Create features before running classifier.", source=self.__class__.__name__,)
+        if model_dict is not None:
+            check_valid_dict(x=model_dict, valid_key_dtypes=(str,), valid_values_dtypes=(dict,), min_len_keys=1, source=f'{self.__class__.__name__} model_dict')
+            translated_model_dict = {}
+            for cnt, (model_name, m_hyp) in enumerate(model_dict.items()):
+                check_if_keys_exist_in_dict(data=m_hyp, key=[MODEL_PATH, THRESHOLD, MINIMUM_BOUT_LENGTH], name=f'{self.__class__.__name__} model_dict[{model_name}]', raise_error=True)
+                check_file_exist_and_readable(file_path=m_hyp[MODEL_PATH])
+                check_float(name=f'{self.__class__.__name__} model_dict[{model_name}] {THRESHOLD}', value=m_hyp[THRESHOLD], min_value=0.0, max_value=1.0)
+                check_int(name=f'{self.__class__.__name__} model_dict[{model_name}] {MINIMUM_BOUT_LENGTH}', value=m_hyp[MINIMUM_BOUT_LENGTH], min_value=0)
+                translated_model_dict[cnt] = {MODEL_PATH: m_hyp[MODEL_PATH], MODEL_NAME: model_name, THRESHOLD: float(m_hyp[THRESHOLD]), MINIMUM_BOUT_LENGTH: int(m_hyp[MINIMUM_BOUT_LENGTH])}
+            self.clf_names = list(model_dict.keys())
+            self.clf_cnt = len(self.clf_names)
+            self._override_model_dict = translated_model_dict
+        else:
+            self._override_model_dict = None
         if feature_subsets_by_clf is not None:
             check_valid_dict(x=feature_subsets_by_clf, valid_key_dtypes=(str,), source=f'{self.__class__.__name__} feature_subsets_by_clf')
             for cnt, (k, v) in enumerate(feature_subsets_by_clf.items()):
@@ -83,10 +103,13 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
                 for subset_name, feature_names in v.items():
                     check_valid_lst(data=feature_names, source=f'{self.__class__.__name__} feature_subsets_by_clf {k} {subset_name}', valid_dtypes=(str,), min_len=1, raise_error=True)
         if minimum_bout_length is not None: check_int(name=f'{self.__class__.__name__} minimum_bout_length', value=minimum_bout_length, allow_zero=False, allow_negative=False, raise_error=True)
+        if save_agg_stats is not None:
+            check_if_dir_exists(in_dir=save_agg_stats, source=f'{self.__class__.__name__} save_agg_stats')
+        self.save_agg_stats = save_agg_stats
         self.verbose, self.feature_subsets_by_clf, self.minimum_bout_length = verbose, feature_subsets_by_clf, minimum_bout_length
         if verbose: stdout_information(msg=f"Analyzing {len(self.feature_file_paths)} file(s) with {self.clf_cnt} classifier(s)...")
         self.timer = SimbaTimer(start=True)
-        self.model_dict = self.get_model_info(config=self.config, model_cnt=self.clf_cnt)
+        self.model_dict = self._override_model_dict if self._override_model_dict is not None else self.get_model_info(config=self.config, model_cnt=self.clf_cnt)
 
     def run(self):
         check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=self.feature_file_paths)
@@ -133,19 +156,27 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
             write_df(df=out_df, file_type=self.file_type, save_path=file_save_path)
             video_timer.stop_timer()
             if self.verbose: stdout_information(msg=f"Predictions created for {file_name} (frame count: {len(in_df)}, elapsed time: {video_timer.elapsed_time_str}) ...")
+        if self.save_agg_stats is not None:
+            if self.verbose: stdout_information(msg=f"Computing aggregate classifier statistics into {self.save_agg_stats}...")
+            agg = AggregateClfCalculator(config_path=self.config_path, classifiers=list(self.clf_names), data_dir=self.save_dir, save_dir=self.save_agg_stats)
+            agg.run()
+            agg.save()
         self.timer.stop_timer()
         stdout_success(msg=f"Machine predictions complete for {len(self.feature_file_paths)} file(s). Files saved in {self.save_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
 
-if __name__ == "__main__" and not hasattr(sys, 'ps1'):
-    parser = argparse.ArgumentParser(description="Perform classifications according to rules defined in SimBA project_config.ini.")
-    parser.add_argument('--config_path', type=str, required=True, help='Path to SimBA Project config.')
-    args = parser.parse_args()
-    runner = InferenceBatch(config_path=args.config_path)
-    runner.run()
-
+# if __name__ == "__main__" and not hasattr(sys, 'ps1'):
+#     parser = argparse.ArgumentParser(description="Perform classifications according to rules defined in SimBA project_config.ini.")
+#     parser.add_argument('--config_path', type=str, required=True, help='Path to SimBA Project config.')
+#     args = parser.parse_args()
+#     runner = InferenceBatch(config_path=args.config_path)
+#     runner.run()
 
 
-# test = InferenceBatch(config_path=r"F:\troubleshooting\sam\sam\project_folder\project_config.ini")
+#
+# test = InferenceBatch(config_path=r"G:\projects\jason_zhang\jason_project\project_folder\project_config.ini",
+#                       save_dir=r'G:\projects\jason_zhang\jason_project\project_folder\csv\REARING\REARING_DATA',
+#                       model_dict={'REARING': {'model_path': r"G:\projects\jason_zhang\jason_project\models\REARING.sav", 'minimum_bout_length': 100, 'threshold': 0.25}},
+#                       save_agg_stats=r'G:\projects\jason_zhang\jason_project\project_folder\csv\REARING\REARING_DATA')
 # test.run()
 
 #

simba_uw_tf_dev-5.3.7/simba/model/inference_multi_animal_batch.py

@@ -0,0 +1,86 @@
+__author__ = "Simon Nilsson; sronilsson@gmail.com"
+
+import os
+from typing import Dict, List, Union
+
+from simba.mixins.config_reader import ConfigReader
+from simba.mixins.train_model_mixin import TrainModelMixin
+from simba.model.inference_batch import InferenceBatch
+from simba.utils.checks import check_file_exist_and_readable, check_str
+from simba.utils.errors import (InvalidInputError, NoDataError,
+                                NoFilesFoundError)
+from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
+from simba.utils.read_write import read_df
+
+
+class InferenceMultiAnimalBatch(TrainModelMixin, ConfigReader):
+    """
+    Run a single trained behavior classifier across every animal in a SimBA project, producing per-animal predictions in the output CSVs.
+
+    .. seealso::
+       Training counterpart: :class:`simba.model.grid_search_rf.GridSearchRandomForestClassifier` with ``feature_subset_suffix='_animal_<N>'``.
+
+    :param Union[str, os.PathLike] config_path: Path to the SimBA project_config.ini.
+    :param str clf_name: Name of the configured classifier to run multi-animal inference for.
+
+    :example:
+    >>> InferenceMultiAnimalBatch(config_path=r'/path/project_folder/project_config.ini', clf_name='wing_wave').run()
+    """
+
+    def __init__(self,
+                 config_path: Union[str, os.PathLike],
+                 clf_name: str):
+
+        check_file_exist_and_readable(file_path=config_path)
+        check_str(name=f'{self.__class__.__name__} clf_name', value=clf_name)
+        ConfigReader.__init__(self, config_path=os.fspath(config_path), create_logger=False)
+        TrainModelMixin.__init__(self)
+
+        if self.animal_cnt < 2:
+            raise InvalidInputError(
+                msg=f'{self.__class__.__name__} requires a project with 2 or more animals (project animal_cnt={self.animal_cnt}). '
+                    f'Use simba.model.inference_batch.InferenceBatch for single-animal projects.',
+                source=self.__class__.__name__)
+        if clf_name not in self.clf_names:
+            raise InvalidInputError(
+                msg=f'Classifier "{clf_name}" is not configured in the project. Available classifiers: {self.clf_names}.',
+                source=self.__class__.__name__)
+        if len(self.feature_file_paths) == 0:
+            raise NoFilesFoundError(
+                msg=f'No feature files found in {self.features_dir}. Run feature extraction before inference.',
+                source=self.__class__.__name__)
+
+        model_dict = self.get_model_info(config=self.config, model_cnt=self.clf_cnt)
+        clfs_with_valid_models = [v['model_name'] for v in model_dict.values()]
+        if clf_name not in clfs_with_valid_models:
+            raise NoFilesFoundError(
+                msg=f'No valid trained model file is registered for classifier "{clf_name}". '
+                    f'Check that "model_path_N" for "{clf_name}" in the [SML settings] section of the project config points to an existing .sav file. '
+                    f'Classifiers with valid model files: {clfs_with_valid_models}.',
+                source=self.__class__.__name__)
+
+        features_df = read_df(file_path=self.feature_file_paths[0], file_type=self.file_type)
+        feature_subset_dict: Dict[str, List[str]] = {}
+        for animal_id in range(1, self.animal_cnt + 1):
+            suffix = f'_animal_{animal_id}'
+            cols = [c for c in features_df.columns if c.endswith(suffix)]
+            if len(cols) == 0:
+                raise NoDataError(
+                    msg=f'No feature columns ending in "{suffix}" found in {self.feature_file_paths[0]}. '
+                        f'Multi-animal inference requires features named with "_animal_<N>" suffixes for every animal.',
+                    source=self.__class__.__name__)
+            feature_subset_dict[suffix[1:]] = cols
+
+        self.clf_name = clf_name
+        self.feature_subsets_by_clf = {clf_name: feature_subset_dict}
+
+    def run(self) -> None:
+        timer = SimbaTimer(start=True)
+        stdout_information(msg=f'Running multi-animal inference for classifier "{self.clf_name}" across {self.animal_cnt} animals...')
+        InferenceBatch(config_path=self.config_path, feature_subsets_by_clf=self.feature_subsets_by_clf).run()
+        timer.stop_timer()
+        stdout_success(msg=f'Multi-animal inference complete for classifier "{self.clf_name}" (elapsed: {timer.elapsed_time_str}s).', source=self.__class__.__name__)
+
+
+# if __name__ == "__main__":
+#     InferenceMultiAnimalBatch(config_path=r"F:\troubleshooting\sophiaa\project_folder\project_config.ini", clf_name="wing_wave").run()

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/plotting/plot_clf_results_mp.py

@@ -20,11 +20,13 @@ from simba.mixins.config_reader import ConfigReader
 from simba.mixins.geometry_mixin import GeometryMixin
 from simba.mixins.plotting_mixin import PlottingMixin
 from simba.mixins.train_model_mixin import TrainModelMixin
-from simba.utils.checks import (check_float, check_if_valid_rgb_tuple,
-                                check_int, check_nvidea_gpu_available,
-                                check_str, check_that_column_exist,
+from simba.utils.checks import (check_float, check_if_dir_exists,
+                                check_if_valid_rgb_tuple, check_int,
+                                check_nvidea_gpu_available, check_str,
+                                check_that_column_exist,
                                 check_that_hhmmss_start_is_before_end,
                                 check_valid_boolean, check_valid_dict,
+                                check_valid_lst,
                                 check_video_and_data_frm_count_align)
 from simba.utils.data import (check_if_string_value_is_valid_video_timestamp,
                               create_color_palette, detect_bouts,
@@ -212,7 +214,7 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
     :param Union[str, os.PathLike] config_path: Path to SimBA project config file in Configparser format.
     :param bool video_setting: If True, creates compressed MP4 videos. Default True.
     :param bool frame_setting: If True, saves individual annotated frames as PNG images. Default False.
-    :param Optional[Union[List[Union[str, os.PathLike]], Union[str, os.PathLike]]] video_paths: Path(s) to video file(s) to process. If None, processes all videos found in the project's video directory. Default None.
+    :param Optional[Union[List[Union[str, os.PathLike]], Union[str, os.PathLike]]] video_paths: Path(s) to video file(s) to process. Accepts a single video file path, a list of video file paths, or a path to a directory containing videos (in which case all videos in that directory are processed). If None, processes all videos found in the project's video directory. Default None.
     :param bool rotate: If True, rotates output videos 90 degrees clockwise. Default False.
     :param bool animal_names: If True, displays animal names on the video frames. Default False.
     :param bool show_pose: If True, overlays pose-estimation keypoints on the video. Default True.
@@ -233,6 +235,9 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
     :param bool gpu: If True, uses GPU acceleration for video concatenation (requires CUDA-capable GPU). Default False.
     :param bool verbose: If True, prints progress and status messages during processing. Default True.
     :param int core_cnt: Number of CPU cores to use for parallel processing. Pass -1 to use all available cores. Default -1.
+    :param Optional[Union[str, os.PathLike]] data_dir: Directory containing the classification data files (one per video, named ``<video_name>.<file_type>``) to overlay on the videos. If None, defaults to the project's ``machine_results_dir``. Default None.
+    :param Optional[Union[str, os.PathLike]] save_dir: Directory in which to write annotated videos/frames. Created if it does not exist. If None, defaults to the project's ``sklearn_plot_dir``. Default None.
+    :param Optional[Union[List[str], Tuple[str, ...]]] clf_names: Optional subset of classifier names to visualize. Each entry must match a classifier defined in the project config. If None, all project classifiers are plotted (current behavior). Default None.
 
     :example:
     >>> clf_plotter = PlotSklearnResultsMultiProcess(
@@ -274,7 +279,10 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
                  text_bg_clr: Tuple[int, int, int] = (0, 0, 0),
                  gpu: bool = False,
                  verbose: bool = True,
-                 core_cnt: int = -1):
+                 core_cnt: int = -1,
+                 data_dir: Optional[Union[str, os.PathLike]] = None,
+                 save_dir: Optional[Union[str, os.PathLike]] = None,
+                 clf_names: Optional[Union[List[str], Tuple[str, ...]]] = None):
 
 
         ConfigReader.__init__(self, config_path=config_path)
@@ -314,23 +322,43 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
         self.gpu = True if check_nvidea_gpu_available() and gpu else False
         self.pose_threshold = read_config_entry(self.config, ConfigKey.THRESHOLD_SETTINGS.value, ConfigKey.SKLEARN_BP_PROB_THRESH.value, Dtypes.FLOAT.value, 0.00)
         self.time_slice, self.overwrite, self.print_timer = time_slice, overwrite, print_timer
-        if not os.path.exists(self.sklearn_plot_dir):
-            os.makedirs(self.sklearn_plot_dir)
-        if isinstance(video_paths, str): self.video_paths = [video_paths]
+        if save_dir is not None:
+            check_if_dir_exists(in_dir=save_dir, source=f'{self.__class__.__name__} save_dir', create_if_not_exist=True, raise_error=True)
+            self.save_dir = save_dir
+        else:
+            self.save_dir = self.sklearn_plot_dir
+        if not os.path.exists(self.save_dir):
+            os.makedirs(self.save_dir)
+        if isinstance(video_paths, str):
+            if os.path.isdir(video_paths):
+                self.video_paths = find_all_videos_in_project(videos_dir=video_paths, raise_error=False)
+                if len(self.video_paths) == 0:
+                    raise NoDataError(msg=f'Cannot create classification videos. No videos exist in {video_paths} directory', source=self.__class__.__name__)
+            else:
+                self.video_paths = [video_paths]
         elif isinstance(video_paths, list): self.video_paths = video_paths
         elif video_paths is None:
             self.video_paths = find_all_videos_in_project(videos_dir=self.video_dir)
             if len(self.video_paths) == 0:
                 raise NoDataError(msg=f'Cannot create classification videos. No videos exist in {self.video_dir} directory', source=self.__class__.__name__)
         else:
-            raise InvalidInputError(msg=f'video_paths has to be a path of a list of paths. Got {type(video_paths)}', source=self.__class__.__name__)
+            raise InvalidInputError(msg=f'video_paths has to be a path, directory, or a list of paths. Got {type(video_paths)}', source=self.__class__.__name__)
 
+        if data_dir is not None:
+            check_if_dir_exists(in_dir=data_dir, source=f'{self.__class__.__name__} data_dir', raise_error=True)
+            self.data_dir = data_dir
+        else:
+            self.data_dir = self.machine_results_dir
         for video_path in self.video_paths:
             video_name = get_fn_ext(filepath=video_path)[1]
-            data_path = os.path.join(self.machine_results_dir, f'{video_name}.{self.file_type}')
+            data_path = os.path.join(self.data_dir, f'{video_name}.{self.file_type}')
             if not os.path.isfile(data_path): raise NoDataError(msg=f'Cannot create classification videos for {video_name}. Expected classification data at location {data_path} but file does not exist', source=self.__class__.__name__)
         check_int(name=f'{self.__class__.__name__} core_cnt', value=core_cnt, min_value=-1, unaccepted_vals=[0])
         self.core_cnt = find_core_cnt()[0] if int(core_cnt) == -1 or int(core_cnt) > find_core_cnt()[0] else int(core_cnt)
+        if clf_names is not None:
+            if isinstance(clf_names, tuple): clf_names = list(clf_names)
+            check_valid_lst(data=clf_names, source=f'{self.__class__.__name__} clf_names', valid_dtypes=(str,), valid_values=self.clf_names, min_len=1)
+            self.clf_names = clf_names
         self.conf_cols = [f'Probability_{x}' for x in self.clf_names]
         if platform.system() == "Darwin":
             multiprocessing.set_start_method("spawn", force=True)
@@ -338,8 +366,9 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
     def __get_print_settings(self):
         optimal_circle_size = self.get_optimal_circle_size(frame_size=(self.video_meta_data["width"], self.video_meta_data["height"]), circle_frame_ratio=100)
         longest_str = str(max(['TIMERS:', 'ENSEMBLE PREDICTION:'] + self.clf_names, key=len))
-        self.video_text_thickness = TextOptions.TEXT_THICKNESS.value if self.text_thickness is None else int(max(self.text_thickness, 1))
-        optimal_font_size, _, optimal_spacing_scale = self.get_optimal_font_scales(text=longest_str, accepted_px_width=int(self.video_meta_data["width"] / 4), accepted_px_height=int(self.video_meta_data["height"] / 8), text_thickness=self.video_text_thickness)
+        auto_thickness = max(TextOptions.TEXT_THICKNESS.value, int(round(min(self.video_meta_data["width"], self.video_meta_data["height"]) / 500)))
+        self.video_text_thickness = auto_thickness if self.text_thickness is None else int(max(self.text_thickness, 1))
+        optimal_font_size, _, optimal_spacing_scale = self.get_optimal_font_scales(text=longest_str, accepted_px_width=int(self.video_meta_data["width"] / 2.5), accepted_px_height=int(self.video_meta_data["height"] / 5), text_thickness=self.video_text_thickness)
         self.video_circle_size = optimal_circle_size if self.circle_size is None else int(max(1, self.circle_size))
         self.video_font_size = optimal_font_size if self.font_size is None else self.font_size
         self.video_space_size = optimal_spacing_scale if self.space_size is None else int(max(self.space_size, 1))
@@ -352,7 +381,7 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
             video_timer = SimbaTimer(start=True)
             _, self.video_name, _ = get_fn_ext(video_path)
             if self.verbose: stdout_information(msg=f"Creating classification visualization for video {self.video_name}...")
-            self.data_path = os.path.join(self.machine_results_dir, f'{self.video_name}.{self.file_type}')
+            self.data_path = os.path.join(self.data_dir, f'{self.video_name}.{self.file_type}')
             self.data_df = read_df(self.data_path, self.file_type).reset_index(drop=True).fillna(0)
             if self.show_pose: check_that_column_exist(df=self.data_df, column_name=self.bp_col_names, file_name=self.data_path)
             if self.show_confidence: check_that_column_exist(df=self.data_df, column_name=self.conf_cols, file_name=self.data_path)
@@ -363,17 +392,17 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
                 frm_ids = find_frame_numbers_from_time_stamp(start_time=self.time_slice[START_TIME], end_time=self.time_slice[END_TIME], fps=int(self.video_meta_data['fps']))
                 self.data_df = self.data_df.loc[frm_ids]
             height, width = deepcopy(self.video_meta_data["height"]), deepcopy(self.video_meta_data["width"])
-            self.save_path = os.path.join(self.sklearn_plot_dir, f"{self.video_name}.mp4")
+            self.save_path = os.path.join(self.save_dir, f"{self.video_name}.mp4")
             self.video_frame_dir, self.video_temp_dir = None, None
             if self.video_setting:
                 if os.path.isfile(self.save_path) and not self.overwrite:
                     FileExistWarning(msg=f'Skipping video {self.video_name}: The output video exist ({self.save_path}) and overwrite is FALSE', source=self.__class__.__name__)
                     continue
-                self.video_save_path = os.path.join(self.sklearn_plot_dir, f"{self.video_name}.mp4")
-                self.video_temp_dir = os.path.join(self.sklearn_plot_dir, self.video_name, "temp")
+                self.video_save_path = os.path.join(self.save_dir, f"{self.video_name}.mp4")
+                self.video_temp_dir = os.path.join(self.save_dir, self.video_name, "temp")
                 create_directory(paths=self.video_temp_dir, overwrite=True)
             if self.frame_setting:
-                self.video_frame_dir = os.path.join(self.sklearn_plot_dir, self.video_name)
+                self.video_frame_dir = os.path.join(self.save_dir, self.video_name)
                 create_directory(paths=self.video_temp_dir, overwrite=True)
             if self.rotate:
                 self.video_meta_data["height"], self.video_meta_data["width"] = (width, height)
@@ -452,11 +481,54 @@ class PlotSklearnResultsMultiProcess(ConfigReader, TrainModelMixin, PlottingMixi
         terminate_cpu_pool(pool=self.pool, force=False, source=self.__class__.__name__)
         self.timer.stop_timer()
         if self.video_setting:
-            stdout_success(msg=f"{len(self.video_paths)} video(s) saved in {self.sklearn_plot_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
+            stdout_success(msg=f"{len(self.video_paths)} video(s) saved in {self.save_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
         if self.frame_setting:
-            stdout_success(f"Frames for {len(self.video_paths)} videos saved in sub-folders within {self.sklearn_plot_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
+            stdout_success(f"Frames for {len(self.video_paths)} videos saved in sub-folders within {self.save_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
+
+
+
+
+# if __name__ == "__main__":
+#     clf_plotter = PlotSklearnResultsMultiProcess(config_path=r"G:\projects\jason_zhang\jason_project\project_folder\project_config.ini",
+#                                                  video_paths=r"G:\projects\jason_zhang\jason_project\project_folder\videos\2025-10-22 12-01-34_box2.mp4",
+#                                                  data_dir=r"G:\projects\jason_zhang\jason_project\project_folder\csv\REARING\REARING_DATA",
+#                                                  save_dir=r'G:\projects\jason_zhang\jason_project\project_folder\csv\REARING\REARING_VIDEOS',
+#                                                  clf_names=('REARING',),
+#                                                  video_setting=True,
+#                                                  frame_setting=False,
+#                                                  rotate=False,
+#                                                  show_confidence=True,
+#                                                  core_cnt=8,
+#                                                  show_pose=True,
+#                                                  animal_names=False,
+#                                                  print_timer=HHMMSSSSSS,
+#                                                  overwrite=True,
+#                                                  time_slice=None, #{START_TIME: '00:00:00', END_TIME: '00:01:00'}, #,{START_TIME: '00:00:00', END_TIME: '00:01:00'}
+#                                                  bbox='animal-aligned',
+#                                                  text_opacity=0.6,
+#                                                  show_gantt=None)
+#     clf_plotter.run()
+
 
 
+# if __name__ == "__main__":
+#     clf_plotter = PlotSklearnResultsMultiProcess(config_path=r"E:\troubleshooting\mitra_emergence_hour\project_folder\project_config.ini",
+#                                                  video_paths=r"E:\troubleshooting\mitra_emergence_hour\project_folder\videos\Box3_180mISOcontrol_Females.mp4", #,#,
+#                                                  video_setting=True,
+#                                                  frame_setting=False,
+#                                                  rotate=False,
+#                                                  show_confidence=False,
+#                                                  core_cnt=12,
+#                                                  show_pose=False,
+#                                                  animal_names=False,
+#                                                  print_timer=HHMMSSSSSS,
+#                                                  overwrite=False,
+#                                                  time_slice=None, #,{START_TIME: '00:00:00', END_TIME: '00:01:00'}
+#                                                  bbox=None,
+#                                                  text_opacity=0.6,
+#                                                  show_gantt=None)
+#     clf_plotter.run()
+
 
 
 # if __name__ == "__main__":

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba/requirements.txt

@@ -31,8 +31,6 @@ tabulate == 0.8.3; python_version=="3.6"
 tabulate == 0.9.0; python_version>="3.9"
 tqdm == 4.30.0
 xgboost == 0.90
-yellowbrick==0.9.1; python_version=="3.6"
-yellowbrick==1.5.0; python_version>="3.9"
 kaleido == 0.2.1; python_version=="3.6"
 kaleido; python_version>="3.9"
 psutil == 5.9.8; python_version=="3.6"

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba_uw_tf_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 5.3.6
+Version: 5.3.7
 Summary: Toolkit for computer classification and analysis of behaviors in experimental animals
 Home-page: https://github.com/sgoldenlab/simba
 Author: Simon Nilsson, Jia Jie Choong, Sophia Hwang

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.7}/simba_uw_tf_dev.egg-info/SOURCES.txt

@@ -651,6 +651,7 @@ simba/model/__init__.py
 simba/model/grid_search_multiclass_rf.py
 simba/model/grid_search_rf.py
 simba/model/inference_batch.py
+simba/model/inference_multi_animal_batch.py
 simba/model/inference_multiclass_batch.py
 simba/model/inference_validation.py
 simba/model/ordinal_clf.py