megadetector 5.0.6__py3-none-any.whl → 5.0.8__py3-none-any.whl

api/batch_processing/data_preparation/manage_video_batch.py

@@ -249,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')
 
@@ -320,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/combine_api_outputs.py

@@ -48,7 +48,7 @@ def combine_api_output_files(input_files: List[str],
         input_files: list of str, paths to JSON detection files
         output_file: optional str, path to write merged JSON
         require_uniqueness: bool, whether to require that the images in
-            each input_dict be unique
+            each list of images be unique
     """
     
     def print_if_verbose(s):
@@ -84,7 +84,7 @@ def combine_api_output_dictionaries(input_dicts: Iterable[Mapping[str, Any]],
         input_dicts: list of dicts, each dict is the JSON of the detections
             output file from the Batch Processing API
         require_uniqueness: bool, whether to require that the images in
-            each input_dict be unique
+            each input dict be unique
 
     Returns: dict, represents the merged JSON
     """

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']:
@@ -273,7 +291,7 @@ def pairwise_compare_batch_results(options,output_index,pairwise_options):
     filenames_b_set = set([im['file'] for im in images_b])
     
     if len(images_a) != len(images_b):
-        s = 'set A has {} iamges, set B has {}'.format(len(images_a),len(images_b))
+        s = 'set A has {} images, set B has {}'.format(len(images_a),len(images_b))
         if options.error_on_non_matching_lists:
             raise ValueError(s)
         else:
@@ -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()
-    

api/batch_processing/postprocessing/convert_output_format.py

@@ -4,8 +4,8 @@
 #
 # Converts between file formats output by our batch processing API.  Currently
 # supports json <--> csv conversion, but this should be the landing place for any
-# conversion - including between future .json versions - that we support in the 
-# future.
+# conversion - including between hypothetical alternative .json versions - that we support 
+# in the future.
 #
 ########
 
@@ -30,10 +30,13 @@ CONF_DIGITS = 3
 #%% Conversion functions
 
 def convert_json_to_csv(input_path,output_path=None,min_confidence=None,
-                        omit_bounding_boxes=False,output_encoding=None):
+                        omit_bounding_boxes=False,output_encoding=None,
+                        overwrite=True):
     """
     Convert .json to .csv
     
+    If output_path is None, will convert x.json to x.csv.
+    
     TODO: this function should obviously be using Pandas or some other sensible structured
     representation of tabular data.  Even a list of dicts.  This implementation is quite
     brittle and depends on adding fields to every row in exactly the right order.
@@ -42,6 +45,10 @@ def convert_json_to_csv(input_path,output_path=None,min_confidence=None,
     if output_path is None:
         output_path = os.path.splitext(input_path)[0]+'.csv'
         
+    if os.path.isfile(output_path) and (not overwrite):
+        print('File {} exists, skipping json --> csv conversion'.format(output_path))
+        return
+    
     print('Loading json results from {}...'.format(input_path))
     json_output = json.load(open(input_path))
 
@@ -73,7 +80,7 @@ def convert_json_to_csv(input_path,output_path=None,min_confidence=None,
 
         n_classification_categories = len(classification_category_ids)
     
-    # There are several fields for which we add columns, other random bespoke fields
+    # There are several .json fields for which we add .csv columns; other random bespoke fields
     # will be ignored.
     optional_fields = ['width','height','datetime','exif_metadata']
     optional_fields_present = set()
@@ -104,7 +111,7 @@ def convert_json_to_csv(input_path,output_path=None,min_confidence=None,
         if 'failure' in im and im['failure'] is not None:
             row = [image_id, 'failure', im['failure']]
             rows.append(row)
-            print('Skipping failed image {} ({})'.format(im['file'],im['failure']))
+            # print('Skipping failed image {} ({})'.format(im['file'],im['failure']))
             continue
 
         max_conf = ct_utils.get_max_conf(im)
@@ -193,12 +200,21 @@ def convert_json_to_csv(input_path,output_path=None,min_confidence=None,
         writer.writerow(header)
         writer.writerows(rows)
 
+# ...def convert_json_to_csv(...)
+
     
-def convert_csv_to_json(input_path,output_path=None):
+def convert_csv_to_json(input_path,output_path=None,overwrite=True):
+    """
+    Convert .csv to .json.  If output_path is None, will convert x.csv to x.json.
+    """
     
     if output_path is None:
         output_path = os.path.splitext(input_path)[0]+'.json'
         
+    if os.path.isfile(output_path) and (not overwrite):
+        print('File {} exists, skipping csv --> json conversion'.format(output_path))
+        return
+            
     # Format spec:
     #
     # https://github.com/agentmorris/MegaDetector/tree/master/api/batch_processing
@@ -259,6 +275,8 @@ def convert_csv_to_json(input_path,output_path=None):
     json_out['images'] = images
     
     json.dump(json_out,open(output_path,'w'),indent=1)
+    
+# ...def convert_csv_to_json(...)
 
 
 #%% Interactive driver