megadetector 5.0.5__py3-none-any.whl → 5.0.7__py3-none-any.whl

api/batch_processing/data_preparation/manage_video_batch.py

@@ -151,6 +151,80 @@ if False:
     
     pass
 
+    #%% Render one or more sample videos...
+        
+    # ...while we still have the frames and detections around
+    
+    ## Imports
+    
+    from md_visualization import visualize_detector_output
+    from detection.video_utils import frames_to_video    
+    
+    
+    ## Constants and paths
+    
+    confidence_threshold = 0.2
+    input_fs = 30
+    
+    filtered_output_filename = '/a/b/c/blah_detections.filtered_rde_0.150_0.850_10_1.000.json'
+    video_fn_relative = '4.10cam6/IMG_0022.MP4'
+    output_video_base = os.path.expanduser('~/tmp/video_preview')
+    
+    
+    ## Filename handling
+    
+    video_fn_relative = video_fn_relative.replace('\\','/')
+    video_fn_flat = video_fn_relative.replace('/','#')
+    video_name = os.path.splitext(video_fn_flat)[0]
+    output_video = os.path.join(output_video_base,'{}_detections.mp4'.format(video_name))        
+    output_fs = input_fs / every_n_frames
+    
+    rendered_detections_folder = os.path.join(output_video_base,'rendered_detections_{}'.format(video_name))
+    os.makedirs(rendered_detections_folder,exist_ok=True)
+    
+    
+    ## Find frames corresponding to this video
+    
+    with open(filtered_output_filename,'r') as f:
+        frame_results = json.load(f)
+    
+    frame_results_this_video = []
+    
+    # im = frame_results['images'][0]
+    for im in frame_results['images']:
+        if im['file'].replace('\\','/').startswith(video_fn_relative):
+            frame_results_this_video.append(im)
+
+    assert len(frame_results_this_video) > 0, \
+        'No frame results matched {}'.format(video_fn_relative)
+    print('Found {} matching frame results'.format(len(frame_results_this_video)))
+    
+    frame_results['images'] = frame_results_this_video
+    
+    frames_json = os.path.join(rendered_detections_folder,video_fn_flat + '.json')
+    
+    with open(frames_json,'w') as f:
+        json.dump(frame_results,f,indent=1)        
+        
+        
+    ## Render detections on those frames    
+    
+    detected_frame_files = visualize_detector_output.visualize_detector_output(
+        detector_output_path=frames_json,
+        out_dir=rendered_detections_folder,
+        images_dir=output_folder_base,
+        confidence_threshold=confidence_threshold,
+        preserve_path_structure=True,
+        output_image_width=-1)
+        
+    
+    ## Render the output video
+    
+    frames_to_video(detected_frame_files, output_fs, output_video, codec_spec='h264')
+    
+    # from md_utils.path_utils import open_file; open_file(output_video)
+
+
     #%% Test a possibly-broken video
     
     fn = '/datadrive/tmp/video.AVI'
@@ -175,8 +249,12 @@ if False:
 import os
 import nbformat as nbf
 
-input_py_file = os.path.expanduser(
-    '~/git/MegaDetector/api/batch_processing/data_preparation/manage_video_batch.py')
+if os.name == 'nt':
+    git_base = r'c:\git'
+else:
+    git_base = os.path.expanduer('~/git')
+
+input_py_file = git_base + '/MegaDetector/api/batch_processing/data_preparation/manage_video_batch.py'
 assert os.path.isfile(input_py_file)
 output_ipynb_file = input_py_file.replace('.py','.ipynb')
 
@@ -246,3 +324,4 @@ while(True):
 write_code_cell(current_cell)
 
 nbf.write(nb,output_ipynb_file)
+

api/batch_processing/postprocessing/add_max_conf.py

@@ -61,3 +61,4 @@ def main():
 
 if __name__ == '__main__':
     main()
+

api/batch_processing/postprocessing/categorize_detections_by_size.py

@@ -3,7 +3,7 @@
 # categorize_detections_by_size.py
 #
 # Given an API output .json file, creates a separate category for bounding boxes
-# above a size threshold.
+# above one or more size thresholds.
 # 
 ########
 
@@ -11,12 +11,16 @@
 
 import json
 
+from collections import defaultdict
+from tqdm import tqdm
+
 
 #%% Support classes
 
 class SizeCategorizationOptions:
 
-    threshold = 0.95
+    # Should be sorted from smallest to largest
+    size_thresholds = [0.95]
     
     # List of category numbers to use in separation; uses all categories if None
     categories_to_separate = None
@@ -24,12 +28,13 @@ class SizeCategorizationOptions:
     # Can be "size", "width", or "height"
     measurement = 'size'
     
-    output_category_name = 'large_detection'
+    # Should have the same length as "size_thresholds"
+    size_category_names = ['large_detection']
     
-
+                                                 
 #%% Main functions
     
-def categorize_detections_by_size(input_file,output_file,options=None):
+def categorize_detections_by_size(input_file,output_file=None,options=None):
     
     if options is None:
         options = SizeCategorizationOptions()
@@ -38,6 +43,14 @@ def categorize_detections_by_size(input_file,output_file,options=None):
         options.categories_to_separate = \
             [str(c) for c in options.categories_to_separate]
     
+    assert len(options.size_thresholds) == len(options.size_category_names), \
+        'Options struct should have the same number of category names and size thresholds'
+
+    # Sort size thresholds and names from largest to smallest
+    options.size_category_names = [x for _,x in sorted(zip(options.size_thresholds,
+                                                             options.size_category_names),reverse=True)]
+    options.size_thresholds = sorted(options.size_thresholds,reverse=True)
+    
     with open(input_file) as f:
         data = json.load(f)
     
@@ -45,12 +58,18 @@ def categorize_detections_by_size(input_file,output_file,options=None):
     category_keys = list(detection_categories.keys())
     category_keys = [int(k) for k in category_keys]
     max_key = max(category_keys)
-    large_detection_category_id = str(max_key+1)
-    detection_categories[large_detection_category_id] = options.output_category_name    
-    
-    print('Creating large-box category for {} with ID {}'.format(
-        options.output_category_name,large_detection_category_id))
     
+    threshold_to_category_id = {}
+    for i_threshold,threshold in enumerate(options.size_thresholds):
+        
+        category_id = str(max_key+1)
+        max_key += 1
+        detection_categories[category_id] = options.size_category_names[i_threshold]
+        threshold_to_category_id[i_threshold] = category_id
+        
+        print('Creating category for {} with ID {}'.format(
+            options.size_category_names[i_threshold],category_id))
+        
     images = data['images']
     
     print('Loaded {} images'.format(len(images)))
@@ -58,10 +77,10 @@ def categorize_detections_by_size(input_file,output_file,options=None):
     # For each image...
     #
     # im = images[0]
+        
+    category_id_to_count = defaultdict(int)
     
-    n_large_detections = 0
-    
-    for im in images:
+    for im in tqdm(images):
         
         if im['detections'] is None:
             assert im['failure'] is not None and len(im['failure']) > 0
@@ -95,19 +114,31 @@ def categorize_detections_by_size(input_file,output_file,options=None):
                 metric = h                
             assert metric is not None
             
-            if metric >= options.threshold:
+            for i_threshold,threshold in enumerate(options.size_thresholds):
                 
-                d['category'] = large_detection_category_id
-                n_large_detections += 1                
+                if metric >= threshold:
+                    
+                    category_id = threshold_to_category_id[i_threshold]
+                    
+                    category_id_to_count[category_id] += 1
+                    d['category'] = category_id                    
+                    
+                    break
                 
+            # ...for each threshold
         # ...for each detection
         
     # ...for each image
     
-    print('Found {} large detections'.format(n_large_detections))
+    for i_threshold in range(0,len(options.size_thresholds)):
+        category_name = options.size_category_names[i_threshold]
+        category_id = threshold_to_category_id[i_threshold]
+        category_count = category_id_to_count[category_id]
+        print('Found {} detections in category {}'.format(category_count,category_name))
     
-    with open(output_file,'w') as f:
-        json.dump(data,f,indent=1)
+    if output_file is not None:
+        with open(output_file,'w') as f:
+            json.dump(data,f,indent=1)
         
     return data
     

api/batch_processing/postprocessing/compare_batch_results.py

@@ -4,7 +4,7 @@
 # 
 # Compare sets of batch results; typically used to compare:
 #
-# * MegaDetector versions
+# * Results from different MegaDetector versions
 # * Results before/after RDE
 # * Results with/without augmentation
 #
@@ -36,9 +36,6 @@ from md_utils import path_utils
 
 
 #%% Constants and support classes
-
-# We will confirm that this matches what we load from each file
-default_detection_categories = {'1': 'animal', '2': 'person', '3': 'vehicle'}
     
 class PairwiseBatchComparisonOptions:
     """
@@ -52,8 +49,8 @@ class PairwiseBatchComparisonOptions:
     results_description_a = None
     results_description_b = None
     
-    detection_thresholds_a = {'animal':0.15,'person':0.15,'vehicle':0.15}
-    detection_thresholds_b = {'animal':0.15,'person':0.15,'vehicle':0.15}
+    detection_thresholds_a = {'animal':0.15,'person':0.15,'vehicle':0.15,'default':0.15}
+    detection_thresholds_b = {'animal':0.15,'person':0.15,'vehicle':0.15,'default':0.15}
 
     rendering_confidence_threshold_a = 0.1
     rendering_confidence_threshold_b = 0.1
@@ -71,16 +68,26 @@ class BatchComparisonOptions:
     job_name = ''
     
     max_images_per_category = 1000
+    max_images_per_page = None
     colormap_a = ['Red']
     colormap_b = ['RoyalBlue']
 
     # Process-based parallelization isn't supported yet; this must be "True"
     parallelize_rendering_with_threads = True
     
+    # List of filenames to include in the comparison, or None to use all files
+    filenames_to_include = None
+    
+    # Compare only detections/non-detections, ignore categories (still renders categories)
+    class_agnostic_comparison = False
+    
     target_width = 800
     n_rendering_workers = 20
     random_seed = 0
     
+    # Default to sorting by filename
+    sort_by_confidence = False
+    
     error_on_non_matching_lists = True
     
     pairwise_options = []
@@ -90,7 +97,7 @@ class BatchComparisonOptions:
 
 class PairwiseBatchComparisonResults:
     """
-    The results from a single pairwise comparison
+    The results from a single pairwise comparison.
     """
     
     html_content = None
@@ -98,7 +105,7 @@ class PairwiseBatchComparisonResults:
     
     # A dictionary with keys including:
     #
-    # "common_detections"
+    # common_detections
     # common_non_detections
     # detections_a_only
     # detections_b_only
@@ -207,7 +214,8 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     # in the options object.
     assert options.pairwise_options is None
     
-    random.seed(options.random_seed)
+    if options.random_seed is not None:
+        random.seed(options.random_seed)
 
     # Warn the user if some "detections" might not get rendered
     max_classification_threshold_a = max(list(pairwise_options.detection_thresholds_a.values()))
@@ -241,10 +249,20 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     with open(pairwise_options.results_filename_b,'r') as f:
         results_b = json.load(f)
         
-    # assert results_a['detection_categories'] == default_detection_categories
-    # assert results_b['detection_categories'] == default_detection_categories
-    assert results_a['detection_categories'] == results_b['detection_categories']
-    detection_categories = results_a['detection_categories']
+    # Don't let path separators confuse things
+    for im in results_a['images']:
+        if 'file' in im:
+            im['file'] = im['file'].replace('\\','/')
+    for im in results_b['images']:
+        if 'file' in im:
+            im['file'] = im['file'].replace('\\','/')
+    
+    if not options.class_agnostic_comparison:
+        assert results_a['detection_categories'] == results_b['detection_categories'], \
+            "Cannot perform a class-sensitive comparison across results with different categories"
+            
+    detection_categories_a = results_a['detection_categories']
+    detection_categories_b = results_b['detection_categories']
     
     if pairwise_options.results_description_a is None:
         if 'detector' not in results_a['info']:
@@ -286,6 +304,10 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     assert len(filenames_a) == len(images_a)
     assert len(filenames_b_set) == len(images_b)    
     
+    if options.filenames_to_include is None:
+        filenames_to_compare = filenames_a
+    else:
+        filenames_to_compare = options.filenames_to_include
     
     ##%% Find differences
     
@@ -298,9 +320,9 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     detections_a_only = {}
     detections_b_only = {}
     class_transitions = {}
-    
-    # fn = filenames_a[0]
-    for fn in tqdm(filenames_a):
+        
+    # fn = filenames_to_compare[0]
+    for fn in tqdm(filenames_to_compare):
     
         if fn not in filename_to_image_b:
             
@@ -330,14 +352,19 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
             
             category_id = det['category']
             
-            if category_id not in detection_categories:
+            if category_id not in detection_categories_a:
                 print('Warning: unexpected category {} for model A on file {}'.format(category_id,fn))
                 invalid_category_error = True
                 break
                 
             conf = det['conf']
             
-            if conf >= pairwise_options.detection_thresholds_a[detection_categories[category_id]]:
+            if detection_categories_a[category_id] in pairwise_options.detection_thresholds_a:
+                conf_thresh = pairwise_options.detection_thresholds_a[detection_categories_a[category_id]]
+            else:
+                conf_thresh = pairwise_options.detection_thresholds_a['default']
+                
+            if conf >= conf_thresh:
                 categories_above_threshold_a.add(category_id)
                             
         if invalid_category_error:
@@ -349,14 +376,19 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
             
             category_id = det['category']
             
-            if category_id not in detection_categories:
+            if category_id not in detection_categories_b:
                 print('Warning: unexpected category {} for model B on file {}'.format(category_id,fn))
                 invalid_category_error = True
                 break
             
             conf = det['conf']
             
-            if conf >= pairwise_options.detection_thresholds_b[detection_categories[category_id]]:
+            if detection_categories_b[category_id] in pairwise_options.detection_thresholds_b:
+                conf_thresh = pairwise_options.detection_thresholds_b[detection_categories_b[category_id]]
+            else:
+                conf_thresh = pairwise_options.detection_thresholds_a['default']
+                
+            if conf >= conf_thresh:
                 categories_above_threshold_b.add(category_id)
                             
         if invalid_category_error:
@@ -368,7 +400,8 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
         detection_b = (len(categories_above_threshold_b) > 0)
                 
         if detection_a and detection_b:            
-            if categories_above_threshold_a == categories_above_threshold_b:
+            if (categories_above_threshold_a == categories_above_threshold_b) or \
+                options.class_agnostic_comparison:
                 common_detections[fn] = im_pair
             else:
                 class_transitions[fn] = im_pair
@@ -383,7 +416,7 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     # ...for each filename
     
     print('Of {} files:\n{} common detections\n{} common non-detections\n{} A only\n{} B only\n{} class transitions'.format(
-        len(filenames_a),len(common_detections),
+        len(filenames_to_compare),len(common_detections),
         len(common_non_detections),len(detections_a_only),
         len(detections_b_only),len(class_transitions)))
         
@@ -453,14 +486,16 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
         # Choose detection pairs we're going to render for this category
         image_pairs = categories_to_image_pairs[category]
         image_filenames = list(image_pairs.keys())
-        if len(image_filenames) > options.max_images_per_category:
-            print('Sampling {} of {} image pairs for category {}'.format(
-                options.max_images_per_category,
-                len(image_filenames),
-                category))
-            image_filenames = random.sample(image_filenames,
-                                            options.max_images_per_category)
-        assert len(image_filenames) <= options.max_images_per_category
+        
+        if options.max_images_per_category is not None and options.max_images_per_category > 0:
+            if len(image_filenames) > options.max_images_per_category:
+                print('Sampling {} of {} image pairs for category {}'.format(
+                    options.max_images_per_category,
+                    len(image_filenames),
+                    category))
+                image_filenames = random.sample(image_filenames,
+                                                options.max_images_per_category)
+            assert len(image_filenames) <= options.max_images_per_category
 
         input_image_absolute_paths = [os.path.join(options.image_folder,fn) for fn in image_filenames]
         
@@ -492,15 +527,34 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
             max_conf_b = maxempty([det['conf'] for det in image_b['detections']])
             
             title = input_path_relative + ' (max conf {:.2f},{:.2f})'.format(max_conf_a,max_conf_b)
+            
+            # Only used if sort_by_confidence is True
+            if category == 'common_detections':
+                sort_conf = max(max_conf_a,max_conf_b)
+            elif category == 'common_non_detections':
+                sort_conf = max(max_conf_a,max_conf_b)
+            elif category == 'detections_a_only':
+                sort_conf = max_conf_a
+            elif category == 'detections_b_only':
+                sort_conf = max_conf_b
+            elif category == 'class_transitions':
+                sort_conf = max(max_conf_a,max_conf_b)
+            else:
+                print('Warning: unknown sort category {}'.format(category))
+                sort_conf = max(max_conf_a,max_conf_b)
+                
             info = {
                 'filename': fn,
                 'title': title,
                 'textStyle': 'font-family:verdana,arial,calibri;font-size:' + \
                     '80%;text-align:left;margin-top:20;margin-bottom:5',
-                'linkTarget': urllib.parse.quote(input_image_absolute_paths[i_fn])
+                'linkTarget': urllib.parse.quote(input_image_absolute_paths[i_fn]),
+                'sort_conf':sort_conf
             }
             image_info.append(info)
     
+        # ...for each image
+        
         category_page_header_string = '<h1>{}</h1>'.format(categories_to_page_titles[category])
         category_page_header_string += '<p style="font-weight:bold;">\n'
         category_page_header_string += 'Model A: {}<br/>\n'.format(
@@ -521,11 +575,18 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
             str(pairwise_options.rendering_confidence_threshold_b))
         category_page_header_string += '</p>\n'        
         
+        # Default to sorting by filename
+        if options.sort_by_confidence:
+            image_info = sorted(image_info, key=lambda d: d['sort_conf'], reverse=True)
+        else:
+            image_info = sorted(image_info, key=lambda d: d['filename'])
+            
         write_html_image_list(
             category_html_filename,
             images=image_info,
             options={
-                'headerHtml': category_page_header_string
+                'headerHtml': category_page_header_string,
+                'maxFiguresPerHtmlFile': options.max_images_per_page
             })
         
     # ...for each category
@@ -559,7 +620,7 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     html_output_string += '<br/>'
     
     html_output_string += ('Of {} total files:<br/><br/><div style="margin-left:15px;">{} common detections<br/>{} common non-detections<br/>{} A only<br/>{} B only<br/>{} class transitions</div><br/>'.format(
-        len(filenames_a),len(common_detections),
+        len(filenames_to_compare),len(common_detections),
         len(common_non_detections),len(detections_a_only),
         len(detections_b_only),len(class_transitions)))
     
@@ -583,7 +644,7 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
             
     return pairwise_results
         
-# ...def compare_batch_results()
+# ...def pairwise_compare_batch_results()
 
 
 def compare_batch_results(options):
@@ -663,12 +724,9 @@ def n_way_comparison(filenames,options,detection_thresholds=None,rendering_thres
         pairwise_options.rendering_confidence_threshold_a = rendering_thresholds[i]
         pairwise_options.rendering_confidence_threshold_b = rendering_thresholds[j]
         
-        pairwise_options.detection_thresholds_a = {'animal':detection_thresholds[i],
-                                                   'person':detection_thresholds[i],
-                                                   'vehicle':detection_thresholds[i]}
-        pairwise_options.detection_thresholds_b = {'animal':detection_thresholds[j],
-                                                   'person':detection_thresholds[j],
-                                                   'vehicle':detection_thresholds[j]}
+        pairwise_options.detection_thresholds_a = {'default':detection_thresholds[i]}
+        pairwise_options.detection_thresholds_b = {'default':detection_thresholds[j]}
+        
         options.pairwise_options.append(pairwise_options)
 
     return compare_batch_results(options)
@@ -679,32 +737,25 @@ def n_way_comparison(filenames,options,detection_thresholds=None,rendering_thres
 #%% Interactive driver
 
 if False:
-    
-    #%% Running KGA test
-    
-    # CUDA_VISIBLE_DEVICES=0 python run_detector_batch.py  ~/models/camera_traps/megadetector/md_v5.0.0/md_v5a.0.0.pt ~/data/KGA/ ~/data/KGA-5a.json --recursive --output_relative_filenames --quiet
-    # CUDA_VISIBLE_DEVICES=1 python run_detector_batch.py  ~/models/camera_traps/megadetector/md_v5.0.0/md_v5b.0.0.pt ~/data/KGA/ ~/data/KGA-5b.json --recursive --output_relative_filenames --quiet
-    
-    # python run_detector_batch.py  ~/models/camera_traps/megadetector/md_v4.1.0/md_v4.1.0.pb ~/data/KGA ~/data/KGA-4.json --recursive --output_relative_filenames --quiet
-    
-    # CUDA_VISIBLE_DEVICES=0 python run_detector_batch.py  ~/models/camera_traps/megadetector/md_v5.0.0/md_v5a.0.0.pt ~/data/KGA/ ~/data/KGA-5a-pillow-9.2.0.json --recursive --output_relative_filenames --quiet
-
-
+        
     #%% Test two-way comparison
     
     options = BatchComparisonOptions()
 
-    options.parallelize_rendering_with_threads = False
+    options.parallelize_rendering_with_threads = True
+    
+    options.job_name = 'BCT'
+    options.output_folder = r'g:\temp\comparisons'
+    options.image_folder = r'g:\camera_traps\camera_trap_images'
+    options.max_images_per_category = 100
+    options.sort_by_confidence = True
     
-    options.job_name = 'KGA-test'
-    options.output_folder = os.path.expanduser('~/tmp/md-comparison-test')
-    options.image_folder = os.path.expanduser('~/data/KGA')
-
     options.pairwise_options = []
 
-    filenames = [
-        os.path.expanduser('~/data/KGA-5a.json'),
-        os.path.expanduser('~/data/KGA-5b.json')
+    results_base = os.path.expanduser('~/postprocessing/bellevue-camera-traps')
+    filenames = [                
+        os.path.join(results_base,r'bellevue-camera-traps-2023-12-05-v5a.0.0\combined_api_outputs\bellevue-camera-traps-2023-12-05-v5a.0.0_detections.json'),
+        os.path.join(results_base,r'bellevue-camera-traps-2023-12-05-aug-v5a.0.0\combined_api_outputs\bellevue-camera-traps-2023-12-05-aug-v5a.0.0_detections.json')
         ]
 
     detection_thresholds = [0.15,0.15]
@@ -835,4 +886,3 @@ def main():
 if __name__ == '__main__':
     
     main()
-