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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.3.6
+Version: 5.3.8
 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
@@ -57,7 +57,7 @@ If you use the code, please cite:
 ```
 
 ### Licence
-SimBA is licensed under GNU Lesser General Public License v3.0.
+SimBA is licensed under a modified BSD 3-Clause License, permitting use for academic and research purposes only. For commercial licensing inquiries, contact sronilsson@gmail.com.
 
 ### Contributors
 Contributers on Github https://github.com/sgoldenlab/simba#contributors

{simba_uw_tf_dev-5.3.6 → simba_uw_tf_dev-5.3.8}/README.md

@@ -4,7 +4,7 @@
 [![py3.10 tests](https://github.com/sgoldenlab/simba/actions/workflows/tests_py310.yml/badge.svg)](https://github.com/sgoldenlab/simba/actions/workflows/tests_py310.yml)
 [![py3.6 tests](https://github.com/sgoldenlab/simba/actions/workflows/tests_py36.yml/badge.svg)](https://github.com/sgoldenlab/simba/actions/workflows/tests_py36.yml)
 ![Docs](https://readthedocs.org/projects/simba-uw-tf-dev/badge/?version=latest&style=flat)
-[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![License: Modified BSD 3-Clause](https://img.shields.io/badge/License-Modified%20BSD%203--Clause%20(Academic%2FResearch)-blue.svg)](LICENSE)
 [![Gitter chat](https://badges.gitter.im/USER/REPO.png)](https://gitter.im/SimBA-Resource/community)
 [![Download: Weights](https://img.shields.io/badge/Download-Weights-orange.svg)](https://osf.io/5t4y9/)
 [![SimBA: listserv](https://img.shields.io/static/v1?label=SimBA&message=listserv&color=blue)](https://docs.google.com/forms/d/e/1FAIpQLSfjbjae0XqNcl7GYOxmqvRsCveG-cmf4p4hBNNJ8gu5vPLHng/viewform)

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

@@ -3,7 +3,8 @@ SimBA (Simple Behavioral Analysis)
 https://github.com/sgoldenlab/simba
 Contributors.
 https://github.com/sgoldenlab/simba#contributors-
-Licensed under GNU Lesser General Public License v3.0
+Licensed under a modified BSD 3-Clause License (academic and research use only).
+For commercial licensing inquiries, contact sronilsson@gmail.com.
 """
 
 import setuptools
@@ -29,7 +30,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.8",
     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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8/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()