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

simba/assets/lookups/yolo_schematics/yolo_mitra.csv

@@ -0,0 +1,9 @@
+left_ear
+right_ear
+nose
+left_side
+right_side
+tail_base
+center
+tail_center
+tail_tip

simba/mixins/train_model_mixin.py

@@ -1070,10 +1070,7 @@ class TrainModelMixin(object):
                 MissingUserInputWarning(msg=f'Skipping {str(config.get("SML settings", "target_name_" + str(n + 1)))} classifier analysis: missing information (e.g., no discrimination threshold and/or minimum bout set in the project_config.ini',source=self.__class__.__name__)
 
         if len(model_dict.keys()) == 0:
-            raise NoDataError(
-                msg=f"There are no models with accurate data specified in the RUN MODELS menu. Specify the model information to SimBA RUN MODELS menu to use them to analyze videos",
-                source=self.get_model_info.__name__,
-            )
+            raise NoDataError(msg=f"There are no models with accurate data specified in the RUN MODELS menu. Specify the model information to SimBA RUN MODELS menu to use them to analyze videos. PLease check the model paths, thresholds, and minimum bout lengths.", source=self.get_model_info.__name__)
         else:
             return model_dict
 

simba/model/inference_batch.py

@@ -101,7 +101,7 @@ class InferenceBatch(TrainModelMixin, ConfigReader):
             video_timer.stop_timer()
             print(f"Predictions created for {file_name} (frame count: {len(in_df)}, elapsed time: {video_timer.elapsed_time_str}) ...")
         self.timer.stop_timer()
-        stdout_success(msg=f"Machine predictions complete. Files saved in {self.save_dir} directory", elapsed_time=self.timer.elapsed_time_str, source=self.__class__.__name__)
+        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 SImAB project_config.ini.")

simba/model/yolo_fit.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from contextlib import redirect_stderr, redirect_stdout
 
 os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
 import argparse
@@ -21,7 +22,8 @@ from simba.utils.checks import (check_file_exist_and_readable,
                                 check_valid_boolean, check_valid_device)
 from simba.utils.enums import Options
 from simba.utils.errors import SimBAGPUError, SimBAPAckageVersionError
-from simba.utils.read_write import find_core_cnt
+from simba.utils.printing import stdout_information
+from simba.utils.read_write import find_core_cnt, get_current_time
 from simba.utils.yolo import load_yolo_model
 
 
@@ -108,20 +110,25 @@ class FitYolo():
 
 
     def run(self):
-        model = load_yolo_model(weights_path=self.weights_path,
-                                verbose=self.verbose,
-                                format=self.format,
-                                device=self.device)
-
-        model.train(data=self.model_yaml,
-                    epochs=self.epochs,
-                    project=self.save_path,
-                    batch=self.batch,
-                    plots=self.plots,
-                    imgsz=self.imgsz,
-                    workers=self.workers,
-                    device=self.device,
-                    patience=self.patience)
+        # Temporarily redirect stdout/stderr to terminal to ensure ultralytics output goes to terminal
+        # sys.__stdout__ and sys.__stderr__ are the original terminal streams
+        stdout_information(msg=f'[{get_current_time()}] Please follow the YOLO pose model training in the terminal from where SimBA was launched ...', source=self.__class__.__name__)
+        stdout_information(msg=f'[{get_current_time()}] Results will be stored in the {self.save_path} directory ..', source=self.__class__.__name__)
+        with redirect_stdout(sys.__stdout__), redirect_stderr(sys.__stderr__):
+            model = load_yolo_model(weights_path=self.weights_path,
+                                    verbose=self.verbose,
+                                    format=self.format,
+                                    device=self.device)
+
+            model.train(data=self.model_yaml,
+                        epochs=self.epochs,
+                        project=self.save_path,
+                        batch=self.batch,
+                        plots=self.plots,
+                        imgsz=self.imgsz,
+                        workers=self.workers,
+                        device=self.device,
+                        patience=self.patience)
 
 
 if __name__ == "__main__" and not hasattr(sys, 'ps1'):

simba/model/yolo_pose_inference.py

@@ -34,7 +34,7 @@ from simba.utils.errors import (CountError, InvalidFilepathError,
                                 InvalidFileTypeError, SimBAGPUError,
                                 SimBAPAckageVersionError)
 from simba.utils.lookups import get_current_time
-from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_video_meta_data, recursive_file_search)
 from simba.utils.warnings import FileExistWarning, NoDataFoundWarning
@@ -182,7 +182,12 @@ class YOLOPoseInference():
         results = {}
         class_dict = self.model.names
         timer = SimbaTimer(start=True)
-        print(f'Starting tracking inference for {len(self.video_path)} video(s) ({get_current_time()})... ')
+        if self.save_dir is not None:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s). Results will be saved in {self.save_dir} ... '
+        else:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s) ... '
+        stdout_information(msg=msg, source=self.__class__.__name__)
+        stdout_information(msg='Follow progress in OS terminal window ...', source=self.__class__.__name__)
         for video_cnt, path in enumerate(self.video_path):
             video_timer = SimbaTimer(start=True)
             _, video_name, _ = get_fn_ext(filepath=path)

simba/sandbox/convert_h264_to_mp4_lossless.py

@@ -0,0 +1,129 @@
+"""
+Convert .h264 files to lossless MP4 format using FFmpeg.
+
+This script converts H.264 raw video files to MP4 container format using
+lossless encoding (copy codec) to preserve quality.
+"""
+import os
+import subprocess
+import glob
+from pathlib import Path
+from typing import List, Union
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def convert_h264_to_mp4_lossless(input_path: Union[str, Path], 
+                                  output_path: Union[str, Path] = None) -> bool:
+    """
+    Convert a single .h264 file to lossless MP4.
+    
+    :param Union[str, Path] input_path: Path to input .h264 file
+    :param Union[str, Path] output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    :return: True if conversion successful, False otherwise
+    """
+    input_path = Path(input_path)
+    
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path}")
+        return False
+    
+    # FFmpeg command for lossless conversion (copy codec, no re-encoding)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -movflags +faststart: Optimize for web streaming (optional)
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',  # Overwrite output file if exists
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}: {e.stderr}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def convert_all_h264_files(directory: str, 
+                           pattern: str = None) -> None:
+    """
+    Convert all .h264 files in a directory to MP4.
+    
+    :param str directory: Directory containing .h264 files
+    :param str pattern: Optional pattern to match in filename (e.g., '4.03.001_6_2026_01_16_09_15_00_000')
+    """
+    dir_path = Path(directory)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Find all .h264 files
+    h264_files = list(dir_path.glob('*.h264'))
+    
+    if pattern:
+        h264_files = [f for f in h264_files if pattern in f.name]
+    
+    if not h264_files:
+        pattern_msg = f" matching pattern '{pattern}'" if pattern else ""
+        print(f"No .h264 files found{pattern_msg} in {directory}")
+        return
+    
+    print(f"Found {len(h264_files)} .h264 file(s) to convert...")
+    
+    successful = 0
+    failed = 0
+    
+    for h264_file in sorted(h264_files):
+        if convert_h264_to_mp4_lossless(h264_file):
+            successful += 1
+        else:
+            failed += 1
+    
+    print(f"\nConversion complete!")
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Total: {len(h264_files)}")
+
+if __name__ == "__main__":
+    # Convert all .h264 files in the directory
+    directory = r"E:\lp_videos_tar"
+    pattern = None  # Convert all .h264 files, not just matching a pattern
+    
+    convert_all_h264_files(directory, pattern=pattern)

simba/sandbox/extract_and_convert_videos.py

@@ -0,0 +1,257 @@
+"""
+Extract tar files and convert all videos to lossless MP4 format.
+
+This script:
+1. Extracts all .tar, .tar.gz, and .tgz files in a directory
+2. Finds all video files (various formats)
+3. Converts them to lossless MP4 using FFmpeg stream copy
+"""
+import os
+import tarfile
+import glob
+import subprocess
+from pathlib import Path
+from typing import List, Set
+
+# Common video file extensions
+VIDEO_EXTENSIONS = {'.h264', '.avi', '.mov', '.mkv', '.flv', '.m4v', '.mp4', 
+                    '.webm', '.wmv', '.mpg', '.mpeg', '.ts', '.mts', '.m2ts'}
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def extract_tar_files(directory_path: str, output_dir: str = None) -> List[Path]:
+    """
+    Extracts all .tar, .tar.gz, and .tgz files in a given directory.
+
+    Args:
+        directory_path (str): The path to the directory containing the tar files.
+        output_dir (str, optional): The directory where to extract the contents.
+                                    If None, extracts to the same directory as the tar file.
+                                    Defaults to None.
+    Returns:
+        List[Path]: List of directories where files were extracted
+    """
+    if output_dir is None:
+        output_dir = directory_path
+    
+    dir_path = Path(directory_path)
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    tar_files = []
+    for ext in ['*.tar', '*.tar.gz', '*.tgz']:
+        tar_files.extend(dir_path.glob(ext))
+
+    if not tar_files:
+        print(f"No tar file(s) found in {directory_path}")
+        return []
+
+    print(f"Found {len(tar_files)} tar file(s) to extract...")
+
+    extracted_dirs = []
+    for tar_file_path in tar_files:
+        tar_file = Path(tar_file_path)
+        print(f"Extracting {tar_file.name}...")
+        try:
+            # Extract to a subdirectory named after the tar file (without extension)
+            extract_dir = output_path / tar_file.stem
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            
+            with tarfile.open(tar_file_path, 'r:*') as f:
+                if hasattr(tarfile, 'data_filter'):  # Python 3.12+
+                    f.extractall(path=extract_dir, filter='data')
+                else:
+                    f.extractall(path=extract_dir)
+            print(f"  [OK] Extracted {tar_file.name} to {extract_dir}")
+            extracted_dirs.append(extract_dir)
+        except tarfile.ReadError as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e} (Not a valid tar file or corrupted)")
+        except Exception as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e}")
+    
+    print("\nExtraction complete!")
+    return extracted_dirs
+
+def find_video_files(directory: Path, recursive: bool = True) -> List[Path]:
+    """
+    Find all video files in a directory.
+    
+    Args:
+        directory: Directory to search
+        recursive: If True, search recursively in subdirectories
+    
+    Returns:
+        List of video file paths
+    """
+    video_files = []
+    
+    if recursive:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.rglob(f'*{ext}'))
+    else:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.glob(f'*{ext}'))
+    
+    return sorted(video_files)
+
+def convert_video_to_mp4_lossless(input_path: Path, output_path: Path = None) -> bool:
+    """
+    Convert a video file to lossless MP4 using FFmpeg stream copy.
+    
+    Args:
+        input_path: Path to input video file
+        output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    
+    Returns:
+        True if conversion successful, False otherwise
+    """
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    # Skip if already MP4
+    if input_path.suffix.lower() == '.mp4':
+        print(f"[SKIP] File is already MP4: {input_path.name}")
+        return False
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path.name}")
+        return False
+    
+    # FFmpeg command for lossless conversion (stream copy)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -y: Overwrite output file if exists
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}")
+        # Print first few lines of stderr for debugging
+        stderr_lines = e.stderr.split('\n')[:5]
+        for line in stderr_lines:
+            if line.strip():
+                print(f"    {line}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def extract_and_convert_videos(directory_path: str, 
+                               extract_to_subdirs: bool = True,
+                               convert_recursive: bool = True) -> None:
+    """
+    Extract all tar files and convert all videos to lossless MP4.
+    
+    Args:
+        directory_path: Directory containing tar files
+        extract_to_subdirs: If True, extract each tar to its own subdirectory
+        convert_recursive: If True, search for videos recursively in extracted directories
+    """
+    dir_path = Path(directory_path)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory_path}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Step 1: Extract tar files
+    print("=" * 60)
+    print("STEP 1: Extracting tar files...")
+    print("=" * 60)
+    extracted_dirs = extract_tar_files(directory_path, 
+                                       output_dir=directory_path if extract_to_subdirs else None)
+    
+    # Step 2: Find all video files
+    print("\n" + "=" * 60)
+    print("STEP 2: Finding video files...")
+    print("=" * 60)
+    
+    # Search in extracted directories and the main directory
+    search_dirs = extracted_dirs if extracted_dirs else [dir_path]
+    all_video_files = []
+    
+    for search_dir in search_dirs:
+        videos = find_video_files(search_dir, recursive=convert_recursive)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {search_dir}")
+    
+    # Also search in main directory if we extracted to subdirs
+    if extract_to_subdirs and dir_path not in search_dirs:
+        videos = find_video_files(dir_path, recursive=False)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {dir_path}")
+    
+    if not all_video_files:
+        print("No video files found to convert.")
+        return
+    
+    print(f"\nTotal video files found: {len(all_video_files)}")
+    
+    # Step 3: Convert videos to MP4
+    print("\n" + "=" * 60)
+    print("STEP 3: Converting videos to lossless MP4...")
+    print("=" * 60)
+    
+    successful = 0
+    failed = 0
+    skipped = 0
+    
+    for video_file in all_video_files:
+        result = convert_video_to_mp4_lossless(video_file)
+        if result is True:
+            successful += 1
+        elif result is False and video_file.suffix.lower() == '.mp4':
+            skipped += 1
+        else:
+            failed += 1
+    
+    print("\n" + "=" * 60)
+    print("Conversion complete!")
+    print("=" * 60)
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Skipped (already MP4): {skipped}")
+    print(f"  Total: {len(all_video_files)}")
+
+if __name__ == "__main__":
+    target_directory = r"E:\new_tars"
+    extract_and_convert_videos(target_directory, 
+                               extract_to_subdirs=True,
+                               convert_recursive=True)

simba/third_party_label_appenders/transform/simba_to_yolo.py

@@ -117,12 +117,15 @@ class SimBA2Yolo:
         annotations, timer, body_part_headers = [], SimbaTimer(start=True), []
         for file_cnt, video_name in enumerate(self.data_w_video):
             data = read_df(file_path=self.data_paths[video_name], file_type=self.config.file_type)
+            data.columns = [x.lower() for x in list(data.columns)]
+            bp_header_names = [x.lower() for x in self.config.bp_headers]
             check_valid_dataframe(df=data, source=f'{self.__class__.__name__} {self.data_paths[video_name]}', valid_dtypes=Formats.NUMERIC_DTYPES.value)
             video_path = self.video_paths[video_name]
             check_video_and_data_frm_count_align(video=video_path, data=data, name=self.data_paths[video_name], raise_error=True)
             p_data = data[data.columns[list(data.columns.str.endswith('_p'))]]
             data = data.loc[:, ~data.columns.str.endswith('_p')].reset_index(drop=True)
             data = data.iloc[(p_data[(p_data > self.threshold).all(axis=1)].index)]
+            data = data[[x for x in bp_header_names if not x.endswith('_p')]]
             body_part_headers = data.columns
             data['video'], frm_cnt = video_name, len(data)
             if self.sample_size is None:
@@ -155,7 +158,7 @@ class SimBA2Yolo:
             if frm_idx in train_idx:
                 img_save_path, lbl_save_path = os.path.join(self.img_train_dir, f'{file_name}.png'), os.path.join(self.lbl_train_dir, f'{file_name}.txt')
             else:
-                img_save_path, lbl_save_path = os.path.join(self.img_train_dir, f'{file_name}.png'), os.path.join(self.lb_val_dir, f'{file_name}.txt')
+                img_save_path, lbl_save_path = os.path.join(self.img_val_dir, f'{file_name}.png'), os.path.join(self.lb_val_dir, f'{file_name}.txt')
             img = read_frm_of_video(video_path=vid_path, frame_index=frm_idx, greyscale=self.greyscale, clahe=self.clahe)
             img_h, img_w = img.shape[0], img.shape[1]
             keypoints_with_id = {}
@@ -181,8 +184,8 @@ class SimBA2Yolo:
         timer.stop_timer()
         stdout_success(msg=f'YOLO formated data saved in {self.save_dir} directory', source=self.__class__.__name__, elapsed_time=timer.elapsed_time_str)
 
-
-# SAVE_DIR = r'D:\troubleshooting\mitra\mitra_yolo'
-# CONFIG_PATH = r"C:\troubleshooting\mitra\project_folder\project_config.ini"
-# runner = SimBA2Yolo(config_path=CONFIG_PATH, save_dir=SAVE_DIR, sample_size=10, verbose=True, names=('animal_1',))
+#
+# SAVE_DIR = r'E:\troubleshooting\mitra\yolo_0126\yolo_train_0126'
+# CONFIG_PATH = r"E:\troubleshooting\mitra\project_folder\project_config.ini"
+# runner = SimBA2Yolo(config_path=CONFIG_PATH, save_dir=SAVE_DIR, sample_size=50, verbose=True, names=('animal_1',), threshold=0.5)
 # runner.run()

simba/ui/pop_ups/run_machine_models_popup.py

@@ -8,8 +8,8 @@ from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
 from simba.model.inference_batch import InferenceBatch
 from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
-                                        FileSelect, SimbaButton, SimBADropDown,
-                                        SimBALabel)
+                                        FileSelect, SimbaButton, SimBALabel,
+                                        SimBASeperator)
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_int)
 from simba.utils.enums import ConfigKey, Dtypes, Formats, Keys, Links
@@ -31,34 +31,34 @@ class RunMachineModelsPopUp(PopUpMixin, ConfigReader):
     def __init__(self, config_path: Union[str, os.PathLike]):
         ConfigReader.__init__(self, config_path=config_path, read_video_info=False)
         PopUpMixin.__init__(self, title="SET MODEL PARAMETERS", icon='equation_small')
+        padx, self.config_path = (0, 25), config_path
         self.clf_table_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.SET_RUN_ML_PARAMETERS.value)
-        clf_header = SimBALabel(parent=self.clf_table_frm, txt="CLASSIFIER", font=Formats.FONT_HEADER.value)
-        mdl_path_header = SimBALabel(parent=self.clf_table_frm, txt="MODEL PATH (.SAV)", font=Formats.FONT_HEADER.value)
-        threshold_header = SimBALabel(parent=self.clf_table_frm, txt="THRESHOLD (0.0 - 1.0)", font=Formats.FONT_HEADER.value)
-        min_bout_header = SimBALabel(parent=self.clf_table_frm, txt="MINIMUM BOUT LENGTH (MS)", font=Formats.FONT_HEADER.value)
-        clf_header.grid(row=0, column=0, sticky=W, padx=(0, 10))
-        mdl_path_header.grid(row=0, column=1, sticky=NW)
-        threshold_header.grid(row=0, column=2, sticky=NW)
-        min_bout_header.grid(row=0, column=3, sticky=NW)
+        clf_header = SimBALabel(parent=self.clf_table_frm, txt="CLASSIFIER", font=Formats.FONT_HEADER.value, img='label')
+        mdl_path_header = SimBALabel(parent=self.clf_table_frm, txt="MODEL PATH (.SAV)", font=Formats.FONT_HEADER.value, img='file_type', justify='center')
+        threshold_header = SimBALabel(parent=self.clf_table_frm, txt="THRESHOLD (0.0 - 1.0)", font=Formats.FONT_HEADER.value, img='threshold', justify='center')
+        min_bout_header = SimBALabel(parent=self.clf_table_frm, txt="MINIMUM BOUT LENGTH (MS)", font=Formats.FONT_HEADER.value, img='timer_2', justify='center')
+        clf_header.grid(row=0, column=0, sticky=NW, padx=padx)
+        mdl_path_header.grid(row=0, column=1, sticky=NW, padx=padx)
+        threshold_header.grid(row=0, column=2, sticky=NW, padx=padx)
+        min_bout_header.grid(row=0, column=3, sticky=NW, padx=padx)
+
+        seperator = SimBASeperator(parent=self.clf_table_frm, color='grey', orient='horizontal', borderwidth=1)
+        seperator.grid(row=1, column=0, columnspan=4, rowspan=1, sticky="ew", pady=(0, 10))
 
         self.clf_data = {}
         for clf_cnt, clf_name in enumerate(self.clf_names):
             self.clf_data[clf_name] = {}
-            SimBALabel(parent=self.clf_table_frm, txt=clf_name, font=Formats.FONT_REGULAR_ITALICS.value).grid(row=clf_cnt + 1, column=0, sticky=W, padx=(0, 10))
+            SimBALabel(parent=self.clf_table_frm, txt=clf_name, font=Formats.FONT_REGULAR_ITALICS.value).grid(row=clf_cnt + 2, column=0, sticky=W, padx=padx)
             mdl_path = read_config_entry(config=self.config, section=ConfigKey.SML_SETTINGS.value, option=f"model_path_{clf_cnt + 1}", default_value='Select model (.sav) file', data_type=Dtypes.STR.value)
             self.clf_data[clf_name][PATH] = FileSelect(self.clf_table_frm, title="Select model (.sav) file", initialdir=self.project_path, file_types=[("SimBA Classifier", "*.sav")], initial_path=mdl_path)
             threshold = read_config_entry(config=self.config, section=ConfigKey.THRESHOLD_SETTINGS.value, option=f"threshold_{clf_cnt + 1}", default_value='', data_type=Dtypes.STR.value)
-            self.clf_data[clf_name][THRESHOLD] = Entry_Box(parent=self.clf_table_frm, fileDescription='', labelwidth=0, entry_box_width=20, value=threshold)
+            self.clf_data[clf_name][THRESHOLD] = Entry_Box(parent=self.clf_table_frm, fileDescription='', labelwidth=0, entry_box_width=20, value=threshold, justify='center')
             bout_length = read_config_entry(config=self.config, section=ConfigKey.MIN_BOUT_LENGTH.value, option=f"min_bout_{clf_cnt + 1}", default_value='', data_type=Dtypes.STR.value)
-            self.clf_data[clf_name][MIN_BOUT] = Entry_Box(parent=self.clf_table_frm, fileDescription='', labelwidth=0, entry_box_width=20, value=bout_length)
-            self.clf_data[clf_name][PATH].grid(row=clf_cnt + 1, column=1, sticky=NW, padx=(0, 5))
-            self.clf_data[clf_name][THRESHOLD].grid(row=clf_cnt + 1, column=2, sticky=NW, padx=(0, 5))
-            self.clf_data[clf_name][MIN_BOUT].grid(row=clf_cnt + 1, column=3, sticky=NW, padx=(0, 5))
+            self.clf_data[clf_name][MIN_BOUT] = Entry_Box(parent=self.clf_table_frm, fileDescription='', labelwidth=0, entry_box_width=20, value=bout_length, justify='center')
+            self.clf_data[clf_name][PATH].grid(row=clf_cnt + 2, column=1, sticky=NW, padx=padx)
+            self.clf_data[clf_name][THRESHOLD].grid(row=clf_cnt + 2, column=2, sticky=NW, padx=padx)
+            self.clf_data[clf_name][MIN_BOUT].grid(row=clf_cnt + 2, column=3, sticky=NW, padx=padx)
         self.clf_table_frm.grid(row=0, sticky=W, pady=5, padx=5)
-        # self.runtime_settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="RUNTIME SETTINGS", icon_name='run', icon_link=Links.SET_RUN_ML_PARAMETERS.value)
-        # self.core_cnt_dropdown = SimBADropDown(parent=self.runtime_settings_frm, dropdown_options=CORE_CNT_OPTIONS, label='CPU CORE COUNT:', label_width=30, dropdown_width=20, value=int(find_core_cnt()[0]/3))
-        # self.runtime_settings_frm.grid(row=1, sticky=W, pady=5, padx=5)
-        # self.core_cnt_dropdown.grid(row=0, sticky=W, pady=5, padx=5)
         run_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header=f"ANALYZE {len(self.feature_file_paths)} FILES(S)", icon_name='rocket')
         run_btn = SimbaButton(parent=run_frm, txt="RUN", img='rocket', txt_clr='red', font=Formats.FONT_REGULAR.value, hover_font=Formats.FONT_REGULAR.value, cmd=self.run)
         run_frm.grid(row=2, sticky=W, pady=5, padx=5)
@@ -95,7 +95,7 @@ class RunMachineModelsPopUp(PopUpMixin, ConfigReader):
         with open(self.config_path, "w") as f:
             self.config.write(f)
 
-        stdout_success(msg="Model paths/settings saved in project_config.ini", source=self.__class__.__name__)
+        stdout_success(msg=f"Model paths/settings saved in project_config.ini ({self.config_path})", source=self.__class__.__name__)
 
         if len(self.feature_file_paths) == 0:
             raise NoDataError(msg=f'Cannot run machine model predictions: No data files found in {self.features_dir} directory', source=self.__class__.__name__)
@@ -103,4 +103,4 @@ class RunMachineModelsPopUp(PopUpMixin, ConfigReader):
         inferencer = InferenceBatch(config_path=self.config_path, features_dir=None, save_dir=None, minimum_bout_length=None)
         inferencer.run()
 
-#_ = RunMachineModelsPopUp(config_path=r"D:\troubleshooting\mitra\project_folder\project_config.ini")
+#_ = RunMachineModelsPopUp(config_path=r"E:\troubleshooting\mitra_emergence\project_folder\project_config.ini")

simba/ui/pop_ups/simba_to_yolo_keypoints_popup.py

@@ -63,7 +63,7 @@ class SimBA2YoloKeypointsPopUp(PopUpMixin):
         animal_names = list(config.animal_bp_dict.keys())
         bps = [x[:-2] for x in config.animal_bp_dict[animal_names[0]]['X_bps']]
         flip_idx = get_yolo_keypoint_flip_idx(x=bps)
-        map_dict = {c: k for c, k in enumerate(animal_names)}
+        #map_dict = {c: k for c, k in enumerate(animal_names)}
         bp_id_idx = None
         if len(animal_names) > 1:
             bp_id_idx = get_yolo_keypoint_bp_id_idx(animal_bp_dict=config.animal_bp_dict)
@@ -85,7 +85,7 @@ class SimBA2YoloKeypointsPopUp(PopUpMixin):
                             greyscale=grey,
                             padding=padding,
                             flip_idx=flip_idx,
-                            names=map_dict,
+                            names=tuple(animal_names),
                             sample_size=sample_size,
                             bp_id_idx=bp_id_idx,
                             clahe=clahe)

simba/ui/pop_ups/yolo_inference_popup.py

@@ -30,7 +30,7 @@ SMOOTHING_OPTIONS = ['None', 50, 100, 200, 300, 400, 500]
 
 YOLO_FORMATS = Options.VALID_YOLO_FORMATS.value + ['None']
 devices = ['CPU']
-THRESHOLD_OPTIONS = list(np.arange(0.1, 1.1, 0.1).astype(np.float32))
+THRESHOLD_OPTIONS = list(np.arange(0.05, 1.05, 0.05).astype(np.float32))
 
 simba_dir = os.path.dirname(simba.__file__)
 YOLO_SCHEMATICS_DIR = os.path.join(simba_dir, Paths.YOLO_SCHEMATICS_DIR.value)

simba/ui/pop_ups/yolo_pose_train_popup.py

@@ -33,7 +33,7 @@ class YOLOPoseTrainPopUP(PopUpMixin):
         PopUpMixin.__init__(self, title="TRAIN YOLO POSE ESTIMATION MODEL", icon='ultralytics_2')
         settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="SETTINGS", icon_name='settings')
         devices.extend([f'{x} : {y["model"]}' for x, y in gpus.items()])
-        self.yolo_map_path = FileSelect(parent=settings_frm, fileDescription='YOLO MAP FILE (YAML):', lblwidth=35, entry_width=45, file_types=[("YOLO MODEL FILE", Options.ALL_YOLO_MODEL_FORMAT_STR_OPTIONS.value)], lbl_icon='file')
+        self.yolo_map_path = FileSelect(parent=settings_frm, fileDescription='YOLO MAP FILE (YAML):', lblwidth=35, entry_width=45, file_types=[("YOLO MODEL FILE", ".yaml")], lbl_icon='file')
         self.save_dir = FolderSelect(settings_frm, folderDescription="SAVE DIRECTORY:", lblwidth=35, entry_width=45, lbl_icon='save')
         self.weights_path = FileSelect(parent=settings_frm, fileDescription='INITIAL WEIGHT FILE (E.G., .PT):', lblwidth=35, entry_width=45, lbl_icon='file')