megadetector 5.0.6__py3-none-any.whl → 5.0.7__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/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()
-    

api/batch_processing/postprocessing/load_api_results.py

@@ -2,17 +2,18 @@
 #
 # load_api_results.py
 #
-# Loads the output of the batch processing API (json) into a pandas dataframe.
+# DEPRECATED
 #
-# Also functions to group entries by seq_id.
+# As of 2023.12, this module is used in postprocessing and RDE.  Not recommended
+# for new code.
 #
-# Includes the deprecated functions that worked with the old CSV API output format.
+# Loads the output of the batch processing API (json) into a Pandas dataframe.
+#
+# Includes functions to read/write the (very very old) .csv results format.
 #
 ########
 
-#%% Constants and imports
-
-from collections import defaultdict
+#%% Imports
 
 import json
 import os
@@ -23,72 +24,32 @@ import pandas as pd
 
 from md_utils import ct_utils
 
-headers = ['image_path', 'max_confidence', 'detections']
-
-
-#%% Functions for grouping by sequence_id
-
-def ss_file_to_file_name(f):
-    # example
-    # input 'file': 'SER/S1/F08/F08_R3/S1_F08_R3_PICT1150.JPG'
-    # output 'id': 'S1/F08/F08_R3/S1_F08_R3_PICT1150.JPG'
-    return f.split('SER/')[1].split('.JPG')[0]
-
-
-def caltech_file_to_file_name(f):
-    return f.split('cct_images/')[1].split('.')[0]
 
-
-def api_results_groupby(api_output_path, gt_db_indexed, file_to_image_id, field='seq_id'):
-    """
-    Given the output file of the API, groupby (currently only seq_id).
-
-    Args:
-        api_output_path: path to the API output json file
-        gt_db_indexed: an instance of IndexedJsonDb so we know the seq_id to image_id mapping
-        file_to_image_id: a function that takes in the 'file' field in 'images' in the detector
-            output file and converts it to the 'id' field in the gt DB.
-        field: which field in the 'images' array to group by
-
-    Returns:
-    A dict where the keys are of the field requested, each points to an array
-    containing entries in the 'images' section of the output file
-    """
-
-    with open(api_output_path) as f:
-        detection_results = json.load(f)
-
-    res = defaultdict(list)
-    for i in detection_results['images']:
-        image_id = file_to_image_id(i['file'])
-        field_val = gt_db_indexed.image_id_to_image[image_id][field]
-        res[field_val].append(i)
-    return res
-
-
-#%% Functions for loading the result as a Pandas DataFrame
+#%% Functions for loading .json results into a Pandas DataFrame, and writing back to .json
 
 def load_api_results(api_output_path: str, normalize_paths: bool = True,
-                     filename_replacements: Optional[Mapping[str, str]] = None
+                     filename_replacements: Optional[Mapping[str, str]] = None,
+                     force_forward_slashes: bool = True
                      ) -> Tuple[pd.DataFrame, Dict]:
     """
-    Loads the json formatted results from the batch processing API to a
-    Pandas DataFrame, mainly useful for various postprocessing functions.
+    Loads json-formatted MegaDetector results to a Pandas DataFrame.
 
     Args:
-        api_output_path: path to the API output json file
+        api_output_path: path to the output json file
         normalize_paths: whether to apply os.path.normpath to the 'file' field
             in each image entry in the output file
         filename_replacements: replace some path tokens to match local paths to
             the original blob structure
+        force_forward_slashes: whether to convert backslashes to forward slashes
+            in filenames
 
     Returns:
         detection_results: pd.DataFrame, contains at least the columns:
-                ['file', 'detections','failure']            
+                ['file', 'detections','failure']
         other_fields: a dict containing fields in the results other than 'images'
     """
     
-    print('Loading API results from {}'.format(api_output_path))
+    print('Loading results from {}'.format(api_output_path))
 
     with open(api_output_path) as f:
         detection_results = json.load(f)
@@ -97,7 +58,7 @@ def load_api_results(api_output_path: str, normalize_paths: bool = True,
     for s in ['info', 'detection_categories', 'images']:
         assert s in detection_results, 'Missing field {} in detection results'.format(s)
 
-    # Fields in the API output json other than 'images'
+    # Fields in the output json other than 'images'
     other_fields = {}
     for k, v in detection_results.items():
         if k != 'images':
@@ -109,6 +70,10 @@ def load_api_results(api_output_path: str, normalize_paths: bool = True,
             image['file'] = os.path.normpath(image['file'])
             # image['file'] = image['file'].replace('\\','/')
 
+    if force_forward_slashes:
+        for image in detection_results['images']:
+            image['file'] = image['file'].replace('\\','/')
+            
     # Replace some path tokens to match local paths to original blob structure
     if filename_replacements is not None:
         for string_to_replace in filename_replacements.keys():
@@ -127,9 +92,7 @@ def load_api_results(api_output_path: str, normalize_paths: bool = True,
     # Pack the json output into a Pandas DataFrame
     detection_results = pd.DataFrame(detection_results['images'])
     
-        
-
-    print('Finished loading API results for {} images from {}'.format(
+    print('Finished loading MegaDetector results for {} images from {}'.format(
             len(detection_results),api_output_path))
 
     return detection_results, other_fields
@@ -137,7 +100,7 @@ def load_api_results(api_output_path: str, normalize_paths: bool = True,
 
 def write_api_results(detection_results_table, other_fields, out_path):
     """
-    Writes a Pandas DataFrame back to a json that is compatible with the API output format.
+    Writes a Pandas DataFrame to the MegaDetector .json format.
     """
 
     print('Writing detection results to {}'.format(out_path))
@@ -148,6 +111,27 @@ def write_api_results(detection_results_table, other_fields, out_path):
                                              double_precision=3)
     images = json.loads(images)
     fields['images'] = images
+    
+    # Convert the 'version' field back to a string as per format convention
+    try:
+        version = other_fields['info']['format_version']
+        if not isinstance(version,str):
+            other_fields['info']['format_version'] = str(version)
+    except Exception:
+        print('Warning: error determining format version')
+        pass
+    
+    # Remove 'max_detection_conf' as per newer file convention (format >= v1.3)
+    try:
+        version = other_fields['info']['format_version']
+        version = float(version)
+        if version >= 1.3:
+            for im in images:
+                if 'max_detection_conf' in im:
+                    del im['max_detection_conf']
+    except Exception:
+        print('Warning: error removing max_detection_conf from output')
+        pass
 
     with open(out_path, 'w') as f:
         json.dump(fields, f, indent=1)
@@ -157,15 +141,16 @@ def write_api_results(detection_results_table, other_fields, out_path):
 
 def load_api_results_csv(filename, normalize_paths=True, filename_replacements={}, nrows=None):
     """
-    DEPRECATED
-    Loads .csv-formatted results from the batch processing API to a pandas table
+    [DEPRECATED]
+    
+    Loads .csv-formatted MegaDetector results to a pandas table
     """
 
-    print('Loading API results from {}'.format(filename))
+    print('Loading MegaDetector results from {}'.format(filename))
 
     detection_results = pd.read_csv(filename,nrows=nrows)
 
-    print('De-serializing API results from {}'.format(filename))
+    print('De-serializing MegaDetector results from {}'.format(filename))
 
     # Confirm that this is really a detector output file
     for s in ['image_path','max_confidence','detections']:
@@ -191,17 +176,18 @@ def load_api_results_csv(filename, normalize_paths=True, filename_replacements={
             fn = fn.replace(string_to_replace,replacement_string)
             detection_results.at[iRow,'image_path'] = fn
 
-    print('Finished loading and de-serializing API results for {} images from {}'.format(
+    print('Finished loading and de-serializing MD results for {} images from {}'.format(
         len(detection_results),filename))
 
     return detection_results
 
 
 def write_api_results_csv(detection_results, filename):
-    """
-    DEPRECATED
-    Writes a pandas table to csv in a way that's compatible with the .csv API output
-    format.  Currently just a wrapper around to_csv that just forces output writing
+    """    
+    [DEPRECATED]
+    
+    Writes a Pandas table to csv in a way that's compatible with the .csv output
+    format.  Currently just a wrapper around to_csv that forces output writing
     to go through a common code path.
     """
 

api/batch_processing/postprocessing/md_to_labelme.py

@@ -48,6 +48,7 @@ def get_labelme_dict_for_image(im,image_base_name,category_id_to_name,info=None,
     output_dict['imageHeight'] = im['height']
     output_dict['imageWidth'] = im['width']
     output_dict['imageData'] = None
+    output_dict['detections'] = im['detections']
     
     for det in im['detections']: