megadetector 5.0.20__py3-none-any.whl → 5.0.22__py3-none-any.whl

megadetector/data_management/yolo_output_to_md_output.py

@@ -59,19 +59,21 @@ def read_classes_from_yolo_dataset_file(fn):
     integer category IDs to string category names.
     
     Args:
-        fn (str): YOLOv5/YOLOv8 dataset file with a .yml or .yaml extension, or a .json file 
-            mapping integer category IDs to category names.
+        fn (str): YOLOv5/YOLOv8 dataset file with a .yml or .yaml extension, a .json file 
+            mapping integer category IDs to category names, or a .txt file with a flat
+            list of classes.
             
     Returns:
         dict: a mapping from integer category IDs to category names
     """
-        
+    
+    category_id_to_name = {}
+    
     if fn.endswith('.yml') or fn.endswith('.yaml'):
         
         with open(fn,'r') as f:
             lines = f.readlines()
                 
-        category_id_to_name = {}
         pat = '\d+:.+'
         for s in lines:
             if re.search(pat,s) is not None:
@@ -83,10 +85,21 @@ def read_classes_from_yolo_dataset_file(fn):
         
         with open(fn,'r') as f:
             d_in = json.load(f)
-            category_id_to_name = {}
             for k in d_in.keys():
                 category_id_to_name[int(k)] = d_in[k]
         
+    elif fn.endswith('.txt'):
+        
+        with open(fn,'r') as f:
+            lines = f.readlines()
+        next_category_id = 0
+        for line in lines:
+            s = line.strip()
+            if len(s) == 0:
+                continue
+            category_id_to_name[next_category_id] = s
+            next_category_id += 1
+            
     else:
         
         raise ValueError('Unrecognized category file type: {}'.format(fn))

megadetector/detection/process_video.py

@@ -665,7 +665,7 @@ def process_video_folder(options):
                                    recursive=options.recursive, 
                                    overwrite=(not options.reuse_frames_if_available),
                                    n_threads=options.n_cores,
-                                   every_n_frames=options.frame_sample,
+                                   every_n_frames=every_n_frames_param,
                                    verbose=options.verbose,
                                    quality=options.quality,
                                    max_width=options.max_width,
@@ -702,11 +702,15 @@ def process_video_folder(options):
         
         if options.reuse_results_if_available and \
             os.path.isfile(frames_json):
+                
                 print('Bypassing inference, loading results from {}'.format(frames_json))
                 with open(frames_json,'r') as f:
                     results = json.load(f)
+                    
         else:
+            
             print('Running MegaDetector')
+            
             results = run_detector_batch.load_and_run_detector_batch(
                 options.model_file, 
                 image_file_names,
@@ -724,6 +728,8 @@ def process_video_folder(options):
                 frames_json,
                 relative_path_base=frame_output_folder,
                 detector_file=options.model_file)
+            
+        # ...if we're re-using existing results / running MD
         
     # ...if we're running MD on in-memory frames vs. extracting frames to disk
     
@@ -917,9 +923,14 @@ if False:
     #%% Process a folder of videos
     
     model_file = 'MDV5A'
-    input_dir = r'g:\temp\test-videos'
+    # input_dir = r'g:\temp\test-videos'
     # input_dir = r'G:\temp\md-test-package\md-test-images\video-samples'
+    input_dir = os.path.expanduser('~/AppData/Local/Temp/md-tests/md-test-images/video-samples')
+    assert os.path.isdir(input_dir)
+    
     output_base = r'g:\temp\video_test'
+    os.makedirs(output_base,exist_ok=True)
+    
     frame_folder = os.path.join(output_base,'frames')
     rendering_folder = os.path.join(output_base,'rendered-frames')
     output_json_file = os.path.join(output_base,'video-test.json')
@@ -949,7 +960,7 @@ if False:
     options.force_extracted_frame_folder_deletion = False
     options.force_rendered_frame_folder_deletion = False
     options.fourcc = 'mp4v'
-    options.force_on_disk_frame_extraction = True
+    options.force_on_disk_frame_extraction = False
     # options.rendering_confidence_threshold = 0.15
     
     cmd = options_to_command(options); print(cmd)

megadetector/detection/pytorch_detector.py

@@ -162,10 +162,22 @@ class PTDetector:
         use_map_location = (device != 'mps')        
         
         if use_map_location:
-            checkpoint = torch.load(model_pt_path, map_location=device)
+            try:            
+                checkpoint = torch.load(model_pt_path, map_location=device, weights_only=False)
+            except Exception as e:
+                if "'weights_only' is an invalid keyword" in str(e):
+                    checkpoint = torch.load(model_pt_path, map_location=device)
+                else:
+                    raise
         else:
-            checkpoint = torch.load(model_pt_path)
-        
+            try:
+                checkpoint = torch.load(model_pt_path, weights_only=False)
+            except Exception as e:
+                if "'weights_only' is an invalid keyword" in str(e):
+                    checkpoint = torch.load(model_pt_path)    
+                else:
+                    raise
+    
         # Compatibility fix that allows us to load older YOLOv5 models with 
         # newer versions of YOLOv5/PT
         for m in checkpoint['model'].modules():

megadetector/detection/run_detector.py

@@ -365,7 +365,8 @@ def load_detector(model_file, force_cpu=False, force_model_download=False):
     Loads a TF or PT detector, depending on the extension of model_file.
     
     Args:
-        model_file (str): model filename, e.g. c:/x/z/md_v5a.0.0.pt
+        model_file (str): model filename (e.g. c:/x/z/md_v5a.0.0.pt) or known model
+            name (e.g. "MDV5A")
         force_cpu (bool, optional): force the model to run on the CPU even if a GPU
             is available
         force_model_download (bool, optional): force downloading the model file if
@@ -380,6 +381,8 @@ def load_detector(model_file, force_cpu=False, force_model_download=False):
     model_file = try_download_known_detector(model_file, 
                                              force_download=force_model_download)
     
+    print('GPU available: {}'.format(is_gpu_available(model_file)))
+    
     start_time = time.time()
     if model_file.endswith('.pb'):
         from megadetector.detection.tf_detector import TFDetector
@@ -444,8 +447,6 @@ def load_and_run_detector(model_file,
     # Possibly automatically download the model
     model_file = try_download_known_detector(model_file, force_download=force_model_download)
 
-    print('GPU available: {}'.format(is_gpu_available(model_file)))
-    
     detector = load_detector(model_file)
 
     detection_results = []

megadetector/detection/run_inference_with_yolov5_val.py

@@ -121,7 +121,7 @@ class YoloInferenceOptions:
         self.device_string = '0'
         
         #: Should we enable test-time augmentation?
-        self.augment = True
+        self.augment = False
         
         #: Should we enable half-precision inference?
         self.half_precision_enabled = None
@@ -183,6 +183,11 @@ class YoloInferenceOptions:
         #: Maximum number of images to run in a single chunk
         self.checkpoint_frequency = None
         
+        #: By default, if we're creating symlinks to images, we append a unique job ID to the 
+        #: symlink folder.  If the caller is 100% sure that the symlink folder can be re-used
+        #: across calls, this can be set to False.
+        self.append_job_id_to_symlink_folder = True
+        
     # ...def __init__()
     
 # ...YoloInferenceOptions()
@@ -228,7 +233,10 @@ def run_inference_with_yolo_val(options):
     
     for k in options.__dict__.keys():
         if k not in default_options.__dict__:
-            print('Warning: unexpected variable {} in options object'.format(k))
+            # Print warnings about unexpected variables, except for things like
+            # "no_append_job_id_to_symlink_folder", which just negate existing objects
+            if not k.startswith('no_'):
+                print('Warning: unexpected variable {} in options object'.format(k))
             
     if options.model_type == 'yolov8':
         
@@ -318,8 +326,12 @@ def run_inference_with_yolo_val(options):
         yolo_results_folder = os.path.join(temporary_folder,'yolo_results')
         yolo_folder_is_temp_folder = True
         
-    # Attach a GUID to the symlink folder, regardless of whether we created it
-    symlink_folder_inner = os.path.join(symlink_folder,job_id)
+    if options.append_job_id_to_symlink_folder:
+        # Attach a GUID to the symlink folder, regardless of whether we created it        
+        symlink_folder_inner = os.path.join(symlink_folder,job_id)
+    else:
+        print('Re-using existing symlink folder {}'.format(symlink_folder))
+        symlink_folder_inner = symlink_folder
     
     os.makedirs(symlink_folder_inner,exist_ok=True)
     os.makedirs(yolo_results_folder,exist_ok=True)
@@ -771,7 +783,7 @@ def run_inference_with_yolo_val(options):
       
     if options.save_yolo_debug_output:
         
-        with open(os.path.join(yolo_results_folder,'yolo_console_output.txt'),'w') as f:
+        with open(os.path.join(yolo_results_folder,'yolo_console_output.txt'),'w',encoding='utf-8') as f:
             for s in yolo_console_output:
                 f.write(s + '\n')
         with open(os.path.join(yolo_results_folder,'image_id_to_file.json'),'w') as f:
@@ -805,17 +817,37 @@ def run_inference_with_yolo_val(options):
         # 
         # line = "test: WARNING: /tmp/md_to_yolo/md_to_yolo_xyz/symlinks/xyz/0000000004.jpg: ignoring corrupt image/label: cannot identify image file '/tmp/md-tests/md-test-images/corrupt-images/real-file.jpg'"
         #
+        # Windows example:
+        #
+        # line = "test: WARNING: g:\\temp\\md-test-images\\corrupt-images\\irfanview-can-still-read-me-caltech_camera_traps_5a0e37cc-23d2-11e8-a6a3-ec086b02610b.jpg: ignoring corrupt image/label: cannot identify image file 'g:\\\\temp\\\\md-test-images\\\\corrupt-images\\\\irfanview-can-still-read-me-caltech_camera_traps_5a0e37cc-23d2-11e8-a6a3-ec086b02610b.jpg'"
+        #
+        
         line = line.replace('⚠️',':')
         if 'ignoring corrupt image/label' in line:
                         
-            tokens = line.split('ignoring corrupt image/label')
-            assert len(tokens) == 2
-            tokens = tokens[0].split(':',maxsplit=3)
-            assert len(tokens) == 4
+            line_tokens = line.split('ignoring corrupt image/label')
+            assert len(line_tokens) == 2
+            
+            tokens = line_tokens[0].split(':') # ,maxsplit=3)
+            tokens = [s.strip() for s in tokens]
+            
+            # ['test', ' WARNING', ' a/b/c/d.jpg', ' ']
+            assert len(tokens[-1]) == 0
+            tokens = tokens[:-1]
             assert 'warning' in tokens[1].lower()
-            image_name = tokens[2].strip()
+            
+            if len(tokens) == 3:
+                image_name = tokens[2].strip()
+            else:
+                # Windows filenames have one extra colon
+                assert len(tokens) == 4
+                assert len(tokens[2]) == 1
+                image_name = ':'.join(tokens[2:4])
+                        
             yolo_read_failures.append(image_name)
             
+        # ...if this line indicated a corrupt image
+            
     # ...for each line in the console output
                     
     # image_file = yolo_read_failures[0]
@@ -960,10 +992,12 @@ def main():
         '--checkpoint_frequency', default=options.checkpoint_frequency, type=int,
         help='break the job into chunks with no more than this many images (default {})'.format(
             options.checkpoint_frequency))    
-    
+    parser.add_argument(
+        '--no_append_job_id_to_symlink_folder', action='store_true',
+        help="don't append a unique job ID to the symlink folder name")
     parser.add_argument(
         '--nonrecursive', action='store_true',
-        help='Disable recursive folder processing')
+        help='disable recursive folder processing')
     
     parser.add_argument(
         '--preview_yolo_command_only', action='store_true',
@@ -1014,6 +1048,7 @@ def main():
         options.input_folder = None        
         
     options.recursive = (not options.nonrecursive)
+    options.append_job_id_to_symlink_folder = (not options.no_append_job_id_to_symlink_folder)
     options.remove_symlink_folder = (not options.no_remove_symlink_folder)
     options.remove_yolo_results_folder = (not options.no_remove_yolo_results_folder)
     options.use_symlinks = (not options.no_use_symlinks)
@@ -1038,6 +1073,80 @@ if __name__ == '__main__':
 
 if False:
 
+
+    #%% Debugging
+
+    input_folder = r'g:\temp\md-test-images'    
+    model_filename = 'MDV5A'
+    output_folder = r'g:\temp\yolo-test-out'
+    yolo_working_folder = r'c:\git\yolov5-md'
+    dataset_file = r"g:\temp\md-test-images\dataset.yaml"
+    job_name = 'yolo-debug'
+    symlink_folder = os.path.join(output_folder,'symlinks')
+    yolo_results_folder = os.path.join(output_folder,'yolo_results')
+    model_name = os.path.splitext(os.path.basename(model_filename))[0]
+    
+    output_file = os.path.join(output_folder,'{}_{}-md_format.json'.format(
+        job_name,model_name))
+    
+    options = YoloInferenceOptions()
+    
+    options.yolo_working_folder = yolo_working_folder
+    options.input_folder = input_folder
+    options.output_file = output_file
+    
+    options.yolo_category_id_to_name = dataset_file
+    options.augment = False
+    options.conf_thres = '0.001'
+    options.batch_size = 1
+    options.device_string = '0'
+    options.unique_id_strategy = 'auto'
+    options.overwrite_handling = 'overwrite'
+
+    if options.augment:
+        options.image_size = round(1280 * 1.3)
+    else:
+        options.image_size = 1280
+    
+    options.model_filename = model_filename
+    
+    options.yolo_results_folder = yolo_results_folder # os.path.join(output_folder + 'yolo_results')        
+    options.symlink_folder = symlink_folder # os.path.join(output_folder,'symlinks')
+    options.use_symlinks = False
+    
+    options.remove_symlink_folder = True
+    options.remove_yolo_results_folder = True
+    
+    options.checkpoint_frequency = None
+    
+    cmd = f'python run_inference_with_yolov5_val.py {model_filename} {input_folder} ' + \
+          f'{output_file} --yolo_working_folder {yolo_working_folder} ' + \
+          f' --image_size {options.image_size} --conf_thres {options.conf_thres} ' + \
+          f' --batch_size {options.batch_size} ' + \
+          f' --symlink_folder {options.symlink_folder} --yolo_results_folder {options.yolo_results_folder} ' + \
+          f' --yolo_dataset_file {options.yolo_category_id_to_name} ' + \
+          f' --unique_id_strategy {options.unique_id_strategy} --overwrite_handling {options.overwrite_handling}'
+      
+    if not options.remove_symlink_folder:
+        cmd += ' --no_remove_symlink_folder'
+    if not options.remove_yolo_results_folder: 
+        cmd += ' --no_remove_yolo_results_folder'
+    if options.checkpoint_frequency is not None:
+        cmd += f' --checkpoint_frequency {options.checkpoint_frequency}'
+    if not options.use_symlinks:
+        cmd += ' --no_use_symlinks'
+    if not options.augment:
+        cmd += ' --augment_enabled 0'
+        
+    print(cmd)
+    execute_in_python = False
+    if execute_in_python:
+        run_inference_with_yolo_val(options)
+    else:
+        import clipboard; clipboard.copy(cmd)
+
+
+
     #%% Run inference on a folder
     
     input_folder = r'g:\temp\tegu-val-mini'.replace('\\','/')
@@ -1129,4 +1238,3 @@ if False:
         run_inference_with_yolo_val(options)
     else:
         import clipboard; clipboard.copy(cmd)
-

megadetector/detection/video_utils.py

@@ -30,7 +30,7 @@ default_fourcc = 'h264'
 
 #%% Path utilities
 
-VIDEO_EXTENSIONS = ('.mp4','.avi','.mpeg','.mpg')
+VIDEO_EXTENSIONS = ('.mp4','.avi','.mpeg','.mpg','.mov','.mkv')
 
 def is_video_file(s,video_extensions=VIDEO_EXTENSIONS):
     """
@@ -229,7 +229,7 @@ def run_callback_on_frames(input_video_file,
         frame_callback (function): callback to run on frames, should take an np.array and a string and 
             return a single value.  callback should expect PIL-formatted (RGB) images.
         every_n_frames (float, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is processed.  If this is a negative value, that's 
+            if this is None or 1, every frame is processed.  If this is a negative value, it's
             interpreted as a sampling rate in seconds, which is rounded to the nearest frame sampling 
             rate. Mutually exclusive with frames_to_process.
         verbose (bool, optional): enable additional debug console output
@@ -264,12 +264,12 @@ def run_callback_on_frames(input_video_file,
     frame_filenames = []
     results = []
     
-    if every_n_frames is not None and every_n_frames < 0:
+    if (every_n_frames is not None) and (every_n_frames < 0):
         every_n_seconds = abs(every_n_frames)
         every_n_frames = int(every_n_seconds * frame_rate)
         if verbose:
             print('Interpreting a time sampling rate of {} hz as a frame interval of {}'.format(
-                every_n_seconds,every_n_frames))        
+                every_n_seconds,every_n_frames))
         
     # frame_number = 0
     for frame_number in range(0,n_frames):
@@ -337,7 +337,9 @@ def run_callback_on_frames_for_folder(input_video_folder,
         frame_callback (function): callback to run on frames, should take an np.array and a string and 
             return a single value.  callback should expect PIL-formatted (RGB) images.
         every_n_frames (int, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is processed.
+            if this is None or 1, every frame is processed.  If this is a negative value, it's 
+            interpreted as a sampling rate in seconds, which is rounded to the nearest frame 
+            sampling rate.
         verbose (bool, optional): enable additional debug console output
         allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
             frames (by default, this is an error).
@@ -418,8 +420,9 @@ def video_to_frames(input_video_file,
         output_folder (str): folder to put frame images in
         overwrite (bool, optional): whether to overwrite existing frame images
         every_n_frames (int, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is extracted. Mutually exclusive with
-            frames_to_extract.
+            if this is None or 1, every frame is extracted.  If this is a negative value, it's
+            interpreted as a sampling rate in seconds, which is rounded to the nearest frame sampling 
+            rate.  Mutually exclusive with frames_to_extract.
         verbose (bool, optional): enable additional debug console output
         quality (int, optional): JPEG quality for frame output, from 0-100.  Defaults
             to the opencv default (typically 95).
@@ -452,6 +455,13 @@ def video_to_frames(input_video_file,
     n_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
     Fs = vidcap.get(cv2.CAP_PROP_FPS)
     
+    if (every_n_frames is not None) and (every_n_frames < 0):
+        every_n_seconds = abs(every_n_frames)
+        every_n_frames = int(every_n_seconds * Fs)
+        if verbose:
+            print('Interpreting a time sampling rate of {} hz as a frame interval of {}'.format(
+                every_n_seconds,every_n_frames))
+    
     # If we're not over-writing, check whether all frame images already exist
     if overwrite == False:
         
@@ -569,7 +579,7 @@ def video_to_frames(input_video_file,
             break
 
         if every_n_frames is not None:
-            if frame_number % every_n_frames != 0:
+            if (frame_number % every_n_frames) != 0:
                 continue
 
         if frames_to_extract is not None:
@@ -678,12 +688,18 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,
     return frame_filenames,fs
 
 
-def video_folder_to_frames(input_folder, output_folder_base, 
-                           recursive=True, overwrite=True,
-                           n_threads=1, every_n_frames=None,
-                           verbose=False, parallelization_uses_threads=True,
-                           quality=None, max_width=None, 
-                           frames_to_extract=None, allow_empty_videos=False):
+def video_folder_to_frames(input_folder,
+                           output_folder_base, 
+                           recursive=True, 
+                           overwrite=True,
+                           n_threads=1,
+                           every_n_frames=None,
+                           verbose=False,
+                           parallelization_uses_threads=True,
+                           quality=None,
+                           max_width=None, 
+                           frames_to_extract=None,
+                           allow_empty_videos=False):
     """
     For every video file in input_folder, creates a folder within output_folder_base, and 
     renders frame of that video to images in that folder.
@@ -697,8 +713,9 @@ def video_folder_to_frames(input_folder, output_folder_base,
         n_threads (int, optional): number of concurrent workers to use; set to <= 1 to disable
             parallelism
         every_n_frames (int, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is extracted. Mutually exclusive with 
-            frames_to_extract.
+            if this is None or 1, every frame is extracted.  If this is a negative value, it's
+            interpreted as a sampling rate in seconds, which is rounded to the nearest frame sampling 
+            rate.  Mutually exclusive with frames_to_extract.
         verbose (bool, optional): enable additional debug console output
         parallelization_uses_threads (bool, optional): whether to use threads (True) or
             processes (False) for parallelization; ignored if n_threads <= 1
@@ -709,6 +726,8 @@ def video_folder_to_frames(input_folder, output_folder_base,
             each video; mutually exclusive with every_n_frames.  If all values are beyond 
             the length of a video, no frames are extracted. Can also be a single int, 
             specifying a single frame number.
+        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
+            frames (by default, this is an error).
         
     Returns:
         tuple: a length-3 tuple containing:
@@ -719,8 +738,11 @@ def video_folder_to_frames(input_folder, output_folder_base,
     """
     
     # Recursively enumerate video files
+    if verbose:
+        print('Enumerating videos in {}'.format(input_folder))
     input_files_full_paths = find_videos(input_folder,recursive=recursive)
-    print('Found {} videos in folder {}'.format(len(input_files_full_paths),input_folder))
+    if verbose:
+        print('Found {} videos in folder {}'.format(len(input_files_full_paths),input_folder))
     if len(input_files_full_paths) == 0:
         return [],[],[]
     
@@ -974,6 +996,7 @@ if False:
     results_file = r'results.json'
     confidence_threshold = 0.75
         
+    
     #%% Load detector output    
     
     with open(results_file,'r') as f:

megadetector/postprocessing/classification_postprocessing.py

@@ -713,4 +713,4 @@ def smooth_classification_results_sequence_level(md_results,
             
     return md_results
 
-# ...smooth_classification_results_sequence_level(...)
+# ...smooth_classification_results_sequence_level(...)

megadetector/postprocessing/combine_api_outputs.py

@@ -192,7 +192,7 @@ def combine_api_shard_files(input_files, output_file=None):
     
     Args:
         input_files (list of str): files to merge
-        output_file (str, optiona): file to which we should write merged results
+        output_file (str, optional): file to which we should write merged results
         
     Returns:
         dict: merged results