megadetector 5.0.18__tar.gz → 5.0.19__tar.gz

{megadetector-5.0.18/megadetector.egg-info → megadetector-5.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.18
+Version: 5.0.19
 Summary: MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images.
 Author-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
 Maintainer-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/data_management/cct_to_md.py

@@ -79,7 +79,7 @@ def cct_to_md(input_filename,output_filename=None):
     results = {}
     
     info = {}
-    info['format_version'] = "1.3"
+    info['format_version'] = '1.4'
     info['detector'] = 'cct_to_md'
     results['info'] = info
     results['detection_categories'] = category_id_to_name

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/data_management/yolo_output_to_md_output.py

@@ -301,7 +301,7 @@ def yolo_json_output_to_md_output(yolo_json_file,
     
     d = {}
     d['images'] = output_images
-    d['info'] = {'format_version':1.3,'detector':detector_name}
+    d['info'] = {'format_version':'1.4','detector':detector_name}
     d['detection_categories'] = {}
         
     for cat_id in yolo_category_id_to_name:
@@ -411,7 +411,7 @@ def yolo_txt_output_to_md_output(input_results_folder,
         'info': {
             'detector': detector_string,
             'detector_metadata': {},
-            'format_version': '1.3'
+            'format_version': '1.4'
         },
         'detection_categories': {
             '1': 'animal',

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/detection/process_video.py

@@ -578,6 +578,7 @@ def process_video_folder(options):
         video_results = md_results['results']
         
         for i_video,video_filename in enumerate(md_results['video_filenames']):
+            video_filename = video_filename.replace('\\','/')
             assert video_filename not in video_filename_to_fs
             video_filename_to_fs[video_filename] = md_results['frame_rates'][i_video]
         
@@ -621,9 +622,11 @@ def process_video_folder(options):
                                    frames_to_extract=options.frames_to_extract,
                                    allow_empty_videos=options.allow_empty_videos)
         
-        for i_video,video_filename in enumerate(video_filenames):
-            assert video_filename not in video_filename_to_fs
-            video_filename_to_fs[video_filename] = Fs[i_video]
+        for i_video,video_filename_abs in enumerate(video_filenames):
+            video_filename_relative = os.path.relpath(video_filename_abs,options.input_video_file)
+            video_filename_relative = video_filename_relative.replace('\\','/')
+            assert video_filename_relative not in video_filename_to_fs
+            video_filename_to_fs[video_filename_relative] = Fs[i_video]
                 
         print('Extracted frames for {} videos'.format(len(set(video_filenames))))
         image_file_names = list(itertools.chain.from_iterable(frame_filenames))

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/detection/run_detector_batch.py

@@ -886,7 +886,7 @@ def write_results_to_file(results,
         
         info = { 
             'detection_completion_time': datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S'),
-            'format_version': '1.3' 
+            'format_version': '1.4' 
         }
         
         if detector_file is not None:

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/detection/video_utils.py

@@ -781,7 +781,9 @@ class FrameToVideoOptions:
         self.non_video_behavior = 'error'
     
 
-def frame_results_to_video_results(input_file,output_file,options=None,
+def frame_results_to_video_results(input_file,
+                                   output_file,
+                                   options=None,
                                    video_filename_to_frame_rate=None):
     """
     Given an MD results file produced at the *frame* level, corresponding to a directory 

megadetector-5.0.19/megadetector/postprocessing/validate_batch_results.py

@@ -0,0 +1,186 @@
+"""
+
+validate_batch_results.py
+
+Given a .json file containing MD results, validate that it's compliant with the format spec:
+
+https://lila.science/megadetector-output-format
+
+"""
+
+#%% Constants and imports
+
+import os
+import sys
+import json
+import argparse
+
+from megadetector.detection.video_utils import is_video_file
+from megadetector.utils.ct_utils import args_to_object
+
+typical_info_fields = ['detector','detection_completion_time',
+                       'classifier','classification_completion_time',
+                       'detection_metadata','classifier_metadata']
+required_keys = ['info','images','detection_categories']
+typical_keys = ['classification_categories']
+
+
+#%% Classes
+
+class ValidateBatchResultsOptions:
+    """
+    Options controlling the behavior of validate_bach_results()
+    """
+    
+    def __init__(self):
+        
+        #: Should we verify that images exist?  If this is True, and the .json
+        #: file contains relative paths, relative_path_base needs to be specified.
+        self.check_image_existence = False
+        
+        #: If check_image_existence is True, where do the images live?
+        #:
+        #: If None, assumes absolute paths.
+        self.relative_path_base = None
+    
+# ...class ValidateBatchResultsOptions
+
+
+
+#%% Main function
+
+def validate_batch_results(json_filename,options=None):
+    """
+    Verify that [json_filename] is a valid MD output file.  Currently errors on invalid files.
+    
+    Args: 
+        json_filename (str): the filename to validate
+        options (ValidateBatchResultsOptions, optionsl): all the parameters used to control this 
+            process, see ValidateBatchResultsOptions for details
+            
+    Returns:
+        bool: reserved; currently always errors or returns True.
+    """
+    
+    if options is None:
+        options = ValidateBatchResultsOptions()
+    
+    with open(json_filename,'r') as f:
+        d = json.load(f)
+    
+    ## Info validation
+    
+    assert 'info' in d
+    info = d['info']
+    
+    assert isinstance(info,dict)
+    assert 'format_version' in info 
+    format_version = float(info['format_version'])
+    assert format_version >= 1.3, 'This validator can only be used with format version 1.3 or later'
+            
+    print('Validating a .json results file with format version {}'.format(format_version))
+    
+    ## Category validation
+    
+    assert 'detection_categories' in d
+    for k in d['detection_categories'].keys():
+        # Categories should be string-formatted ints
+        assert isinstance(k,str)
+        _ = int(k)
+        assert isinstance(d['detection_categories'][k],str)
+        
+    if 'classification_categories' in d:
+        for k in d['classification_categories'].keys():
+            # Categories should be string-formatted ints
+            assert isinstance(k,str)
+            _ = int(k)
+            assert isinstance(d['classification_categories'][k],str)
+    
+    
+    ## Image validation
+    
+    assert 'images' in d
+    assert isinstance(d['images'],list)
+    
+    # im = d['images'][0]
+    for im in d['images']:
+        
+        assert isinstance(im,dict)
+        assert 'file' in im
+        
+        file = im['file']
+        
+        if options.check_image_existence:
+            if options.relative_path_base is None:
+                file_abs = file
+            else:
+                file_abs = os.path.join(options.relative_path_base,file)
+            assert os.path.isfile(file_abs), 'Cannot find file {}'.format(file_abs)
+            
+        if 'detections' not in im or im['detections'] is None:
+            assert 'failure' in im and isinstance(im['failure'],str)
+        else:
+            assert isinstance(im['detections'],list)
+            
+        if is_video_file(im['file']) and (format_version >= 1.4):
+            assert 'frame_rate' in im
+            if 'detections' in im and im['detections'] is not None:
+                for det in im['detections']:
+                    assert 'frame_number' in det
+            
+    # ...for each image
+        
+    
+    ## Checking on other keys
+    
+    for k in d.keys():
+        if k not in typical_keys and k not in required_keys:
+            print('Warning: non-standard key {} present at file level'.format(k))
+                  
+# ...def validate_batch_results(...)
+
+
+#%% Interactive driver(s)
+
+if False:
+
+    #%%
+    
+    options = ValidateBatchResultsOptions()
+    # json_filename = r'g:\temp\format.json'
+    # json_filename = r'g:\temp\test-videos\video_results.json'
+    json_filename = r'g:\temp\test-videos\image_results.json'
+    options.check_image_existence = True
+    options.relative_path_base = r'g:\temp\test-videos'
+    validate_batch_results(json_filename,options)
+    
+
+#%% Command-line driver
+
+def main():
+    
+    options = ValidateBatchResultsOptions()
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        'json_filename',
+        help='path to .json file containing MegaDetector results')
+    parser.add_argument(
+        '--check_image_existence', action='store_true',
+        help='check that all images referred to in the results file exist')
+    parser.add_argument(
+        '--relative_path_base', default=None,
+        help='if --check_image_existence is specified and paths are relative, use this as the base folder')
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+
+    args = parser.parse_args()
+    
+    args_to_object(args, options)    
+
+    validate_batch_results(args.json_filename,options)
+    
+    
+if __name__ == '__main__':
+    main()

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector/utils/md_tests.py

@@ -683,10 +683,16 @@ def run_python_tests(options):
     
     ## Verify results
     
+    # Verify format correctness
+    from megadetector.postprocessing.validate_batch_results import validate_batch_results 
+    validate_batch_results(inference_output_file)
+    
+    # Verify value correctness
     expected_results_file = get_expected_results_filename(is_gpu_available(verbose=False),
                                                           options=options)
     compare_results(inference_output_file,expected_results_file,options)
-        
+    
+    
     # Make note of this filename, we will use it again later
     inference_output_file_standard_inference = inference_output_file
     

{megadetector-5.0.18 → megadetector-5.0.19/megadetector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.18
+Version: 5.0.19
 Summary: MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images.
 Author-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
 Maintainer-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>

{megadetector-5.0.18 → megadetector-5.0.19}/megadetector.egg-info/SOURCES.txt

@@ -172,6 +172,7 @@ megadetector/postprocessing/render_detection_confusion_matrix.py
 megadetector/postprocessing/separate_detections_into_folders.py
 megadetector/postprocessing/subset_json_detector_output.py
 megadetector/postprocessing/top_folders_to_bottom.py
+megadetector/postprocessing/validate_batch_results.py
 megadetector/postprocessing/repeat_detection_elimination/find_repeat_detections.py
 megadetector/postprocessing/repeat_detection_elimination/remove_repeat_detections.py
 megadetector/postprocessing/repeat_detection_elimination/repeat_detections_core.py

{megadetector-5.0.18 → megadetector-5.0.19}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
 
 [project]
 name = "megadetector"
-version = "5.0.18"
+version = "5.0.19"
 description = "MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images."
 readme = "README-package.md"
 # As of 2023.10.10, PyTorch isn't installable on Python 3.12