megadetector 10.0.8__py3-none-any.whl → 10.0.10__py3-none-any.whl

megadetector/detection/run_md_and_speciesnet.py

@@ -61,7 +61,18 @@ DEFAULT_DETECTION_CONFIDENCE_THRESHOLD_FOR_OUTPUT = DEFAULT_OUTPUT_CONFIDENCE_TH
 DEFAULT_DETECTOR_BATCH_SIZE = 1
 DEFAULT_CLASSIFIER_BATCH_SIZE = 8
 DEFAULT_LOADER_WORKERS = 4
-MAX_QUEUE_SIZE_IMAGES_PER_WORKER = 10
+
+# This determines the maximum number of images that can get read from disk
+# on each of the producer workers before blocking.  The actual size of the queue
+# will be MAX_IMAGE_QUEUE_SIZE_PER_WORKER * n_workers.  This is only used for
+# the classification step.
+MAX_IMAGE_QUEUE_SIZE_PER_WORKER = 10
+
+# This determines the maximum number of crops that can accumulate in the queue
+# used to communicate between the producers (which read and crop images) and the
+# consumer (which runs the classifier).  This is only used for the classification step.
+MAX_BATCH_QUEUE_SIZE = 300
+
 DEAFULT_SECONDS_PER_VIDEO_FRAME = 1.0
 
 # Max number of classification scores to include per detection
@@ -71,6 +82,11 @@ DEFAULT_TOP_N_SCORES = 2
 # cumulative confidence is above this value
 ROLLUP_TARGET_CONFIDENCE = 0.5
 
+# When the called supplies an existing MD results file, should we validate it before
+# starting classification?  This tends
+VALIDATE_DETECTION_FILE = False
+
+
 verbose = False
 
 
@@ -109,10 +125,10 @@ class CropBatch:
     """
 
     def __init__(self):
-        # List of preprocessed images
+        #: List of preprocessed images
         self.crops = []
 
-        # List of CropMetadata objects
+        #: List of CropMetadata objects
         self.metadata = []
 
     def add_crop(self, crop_data, metadata):
@@ -192,6 +208,7 @@ def _process_image_detections(file_path: str,
 
         # Preprocess the crop
         try:
+
             preprocessed_crop = classifier.preprocess(
                 image,
                 bboxes=[speciesnet_bbox],
@@ -199,6 +216,7 @@ def _process_image_detections(file_path: str,
             )
 
             if preprocessed_crop is not None:
+
                 metadata = CropMetadata(
                     image_file=file_path,
                     detection_index=detection_index,
@@ -207,10 +225,11 @@ def _process_image_detections(file_path: str,
                     original_height=original_height
                 )
 
-                # Send individual crop immediately to consumer
+                # Send individual crop to the consumer
                 batch_queue.put(('crop', preprocessed_crop, metadata))
 
         except Exception as e:
+
             print('Warning: failed to preprocess crop from {}, detection {}: {}'.format(
                 file_path, detection_index, str(e)))
 
@@ -226,6 +245,8 @@ def _process_image_detections(file_path: str,
                              'Failed to preprocess crop: {}'.format(str(e)),
                              failure_metadata))
 
+        # ...try/except
+
     # ...for each detection in this image
 
 # ...def _process_image_detections(...)
@@ -256,6 +277,7 @@ def _process_video_detections(file_path: str,
     frame_to_detections = {}
 
     for detection_index, detection in enumerate(detections):
+
         conf = detection['conf']
         if conf < detection_confidence_threshold:
             continue
@@ -267,6 +289,8 @@ def _process_video_detections(file_path: str,
             frame_to_detections[frame_number] = []
         frame_to_detections[frame_number].append((detection_index, detection))
 
+    # ...for each detection in this video
+
     if len(frames_with_detections) == 0:
         return
 
@@ -290,6 +314,7 @@ def _process_video_detections(file_path: str,
             return
         frame_number = int(match.group(1))
 
+        # Only process frames for which we have detection results
         if frame_number not in frame_to_detections:
             return
 
@@ -360,13 +385,16 @@ def _process_video_detections(file_path: str,
 
     # Process the video frames
     try:
+
         run_callback_on_frames(
             input_video_file=absolute_file_path,
             frame_callback=frame_callback,
             frames_to_process=frames_to_process,
             verbose=verbose
         )
+
     except Exception as e:
+
         print('Warning: failed to process video {}: {}'.format(file_path, str(e)))
 
         # Send failure information to consumer for the whole video
@@ -448,6 +476,7 @@ def _crop_producer_func(image_queue: JoinableQueue,
         is_video = is_video_file(file_path)
 
         if is_video:
+
             # Process video
             _process_video_detections(
                 file_path=file_path,
@@ -457,7 +486,9 @@ def _crop_producer_func(image_queue: JoinableQueue,
                 detection_confidence_threshold=detection_confidence_threshold,
                 batch_queue=batch_queue
             )
+
         else:
+
             # Process image
             _process_image_detections(
                 file_path=file_path,
@@ -571,9 +602,9 @@ def _crop_consumer_func(batch_queue: Queue,
         item_type, data, metadata = item
 
         if metadata.image_file not in all_results:
-                all_results[metadata.image_file] = {}
+            all_results[metadata.image_file] = {}
 
-        # We should never be processing the same detetion twice
+        # We should never be processing the same detection twice
         assert metadata.detection_index not in all_results[metadata.image_file]
 
         if item_type == 'failure':
@@ -601,6 +632,7 @@ def _crop_consumer_func(batch_queue: Queue,
 
     # ...while (we have items to process)
 
+    # Send all the results at once back to the main process
     results_queue.put(all_results)
 
     if verbose:
@@ -828,7 +860,7 @@ def _run_detection_step(source_folder: str,
             batch_size=detector_batch_size,
             include_image_size=False,
             include_image_timestamp=False,
-            include_exif_data=False,
+            include_exif_tags=None,
             loader_workers=detector_worker_threads,
             preprocess_on_image_queue=True
         )
@@ -914,9 +946,11 @@ def _run_classification_step(detector_results_file: str,
         top_n_scores (int, optional): maximum number of scores to include for each detection
     """
 
-    print('Starting SpeciesNet classification step...')
+    print('Starting classification step...')
 
     # Load MegaDetector results
+    print('Reading detection results from {}'.format(detector_results_file))
+
     with open(detector_results_file, 'r') as f:
         detector_results = json.load(f)
 
@@ -936,10 +970,22 @@ def _run_classification_step(detector_results_file: str,
         print('Set multiprocessing start method to spawn (was {})'.format(
             original_start_method))
 
-    # Set up multiprocessing queues
-    max_queue_size = classifier_worker_threads * MAX_QUEUE_SIZE_IMAGES_PER_WORKER
-    image_queue = JoinableQueue(max_queue_size)
-    batch_queue = Queue()
+    ## Set up multiprocessing queues
+
+    # This queue receives lists of image filenames (and associated detection results)
+    # from the "main" thread (the one you're reading right now).  Items are pulled off
+    # of this queue by producer workers (on _crop_producer_func), where the corresponding
+    # images are loaded from disk and preprocessed into crops.
+    image_queue = JoinableQueue(maxsize= \
+                                classifier_worker_threads * MAX_IMAGE_QUEUE_SIZE_PER_WORKER)
+
+    # This queue receives cropped images from producers (on _crop_producer_func); those
+    # crops are pulled off of this queue by the consumer (on _crop_consumer_func).
+    batch_queue = Queue(maxsize=MAX_BATCH_QUEUE_SIZE)
+
+    # This is not really used as a queue, rather it's just used to send all the results
+    # at once from the consumer process to the main process (the one you're reading right
+    # now).
     results_queue = Queue()
 
     # Start producer workers
@@ -951,7 +997,9 @@ def _run_classification_step(detector_results_file: str,
         p.start()
         producers.append(p)
 
-    # Start consumer worker
+
+    ## Start consumer worker
+
     consumer = Process(target=_crop_consumer_func,
                        args=(batch_queue, results_queue, classifier_model,
                              classifier_batch_size, classifier_worker_threads,
@@ -974,16 +1022,23 @@ def _run_classification_step(detector_results_file: str,
 
     print('Finished waiting for input queue')
 
-    # Wait for results
+
+    ## Wait for results
+
     classification_results = results_queue.get()
 
-    # Clean up processes
+
+    ## Clean up processes
+
     for p in producers:
         p.join()
     consumer.join()
 
     print('Finished waiting for workers')
 
+
+    ## Format results and write output
+
     class CategoryState:
         """
         Helper class to manage classification category IDs.
@@ -1257,15 +1312,18 @@ def main():
     print('Intermediate files: {}'.format(temp_folder))
 
     # Determine detector output file path
-    if args.detections_file:
+    if args.detections_file is not None:
         detector_output_file = args.detections_file
-        print('Using existing detections file: {}'.format(detector_output_file))
-        validation_options = ValidateBatchResultsOptions()
-        validation_options.check_image_existence = True
-        validation_options.relative_path_base = args.source
-        validation_options.raise_errors = True
-        validate_batch_results(detector_output_file,options=validation_options)
-        print('Validated detections file')
+        if VALIDATE_DETECTION_FILE:
+            print('Using existing detections file: {}'.format(detector_output_file))
+            validation_options = ValidateBatchResultsOptions()
+            validation_options.check_image_existence = True
+            validation_options.relative_path_base = args.source
+            validation_options.raise_errors = True
+            validate_batch_results(detector_output_file,options=validation_options)
+            print('Validated detections file')
+        else:
+            print('Bypassing validation of {}'.format(args.detections_file))
     else:
         detector_output_file = os.path.join(temp_folder, 'detector_output.json')
 

megadetector/detection/run_tiled_inference.py

@@ -39,7 +39,7 @@ from torchvision import ops
 from megadetector.detection.run_inference_with_yolov5_val import \
     YoloInferenceOptions,run_inference_with_yolo_val
 from megadetector.detection.run_detector_batch import \
-    load_and_run_detector_batch,write_results_to_file
+    load_and_run_detector_batch,write_results_to_file,default_loaders
 from megadetector.detection.run_detector import \
     try_download_known_detector, CONF_DIGITS, COORD_DIGITS
 from megadetector.utils import path_utils
@@ -406,7 +406,9 @@ def run_tiled_inference(model_file,
                         detector_options=None,
                         use_image_queue=True,
                         preprocess_on_image_queue=True,
-                        inference_size=None):
+                        loader_workers=default_loaders,
+                        inference_size=None,
+                        verbose=False):
     """
     Runs inference using [model_file] on the images in [image_folder], fist splitting each image up
     into tiles of size [tile_size_x] x [tile_size_y], writing those tiles to [tiling_folder],
@@ -451,16 +453,17 @@ def run_tiled_inference(model_file,
         image_list (list, optional): .json file containing a list of specific images to process.  If
             this is supplied, and the paths are absolute, [image_folder] will be ignored. If this is supplied,
             and the paths are relative, they should be relative to [image_folder]
-        augment (bool, optional): apply test-time augmentation, only relevant if yolo_inference_options
-            is None
+        augment (bool, optional): apply test-time augmentation
         detector_options (dict, optional): parameters to pass to run_detector, only relevant if
             yolo_inference_options is None
         use_image_queue (bool, optional): whether to use a loader worker queue, only relevant if
             yolo_inference_options is None
         preprocess_on_image_queue (bool, optional): whether the image queue should also be responsible
             for preprocessing
+        loader_workers (int, optional): number of preprocessing loader workers to use
         inference_size (int, optional): override the default inference image size, only relevant if
             yolo_inference_options is None
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         dict: MD-formatted results dictionary, identical to what's written to [output_file]
@@ -522,7 +525,8 @@ def run_tiled_inference(model_file,
 
     all_image_patch_info = None
 
-    print('Extracting patches from {} images'.format(len(image_files_relative)))
+    print('Extracting patches from {} images on {} workers'.format(
+        len(image_files_relative),n_patch_extraction_workers))
 
     n_workers = n_patch_extraction_workers
 
@@ -632,7 +636,9 @@ def run_tiled_inference(model_file,
                                                         detector_options=detector_options,
                                                         use_image_queue=use_image_queue,
                                                         preprocess_on_image_queue=preprocess_on_image_queue,
-                                                        image_size=inference_size)
+                                                        image_size=inference_size,
+                                                        verbose_output=verbose,
+                                                        loader_workers=loader_workers)
 
         patch_level_output_file = os.path.join(tiling_folder,folder_name + '_patch_level_results.json')
 
@@ -847,12 +853,12 @@ if False:
         yolo_inference_options.yolo_working_folder = os.path.expanduser('~/git/yolov5')
 
     run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
-                            tile_size_x=tile_size_x, tile_size_y=tile_size_y,
-                            tile_overlap=tile_overlap,
-                            checkpoint_path=checkpoint_path,
-                            checkpoint_frequency=checkpoint_frequency,
-                            remove_tiles=remove_tiles,
-                            yolo_inference_options=yolo_inference_options)
+                        tile_size_x=tile_size_x, tile_size_y=tile_size_y,
+                        tile_overlap=tile_overlap,
+                        checkpoint_path=checkpoint_path,
+                        checkpoint_frequency=checkpoint_frequency,
+                        remove_tiles=remove_tiles,
+                        yolo_inference_options=yolo_inference_options)
 
 
     #%% Run tiled inference (generate a command)
@@ -930,6 +936,14 @@ def main():
         '--no_remove_tiles',
         action='store_true',
         help='Tiles are removed by default; this option suppresses tile deletion')
+    parser.add_argument(
+        '--augment',
+        action='store_true',
+        help='Enable test-time augmentation')
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Enable additional debug output')
     parser.add_argument(
         '--tile_size_x',
         type=int,
@@ -960,6 +974,21 @@ def main():
         type=str,
         default=None,
         help=('A list of detector options (key-value pairs)'))
+    parser.add_argument(
+        '--inference_size',
+        type=int,
+        default=None,
+        help=('Run inference at a non-default size'))
+    parser.add_argument(
+        '--n_patch_extraction_workers',
+        type=int,
+        default=1,
+        help=('Number of workers to use for patch extraction'))
+    parser.add_argument(
+        '--loader_workers',
+        type=int,
+        default=default_loaders,
+        help=('Number of workers to use for image loading and preprocessing (0 to disable)'))
 
     # detector_options = parse_kvp_list(args.detector_options)
 
@@ -987,11 +1016,23 @@ def main():
 
     remove_tiles = (not args.no_remove_tiles)
 
-    run_tiled_inference(model_file, args.image_folder, args.tiling_folder, args.output_file,
-                        tile_size_x=args.tile_size_x, tile_size_y=args.tile_size_y,
+    use_image_queue = (args.loader_workers > 0)
+
+    run_tiled_inference(model_file,
+                        args.image_folder,
+                        args.tiling_folder,
+                        args.output_file,
+                        tile_size_x=args.tile_size_x,
+                        tile_size_y=args.tile_size_y,
                         tile_overlap=args.tile_overlap,
                         remove_tiles=remove_tiles,
-                        image_list=args.image_list)
+                        image_list=args.image_list,
+                        augment=args.augment,
+                        inference_size=args.inference_size,
+                        verbose=args.verbose,
+                        n_patch_extraction_workers=args.n_patch_extraction_workers,
+                        loader_workers=args.loader_workers,
+                        use_image_queue=use_image_queue)
 
 if __name__ == '__main__':
     main()

megadetector/detection/tf_detector.py

@@ -138,8 +138,8 @@ class TFDetector:
                                       image_id,
                                       detection_threshold,
                                       image_size=None,
-                                      skip_image_resizing=False,
-                                      augment=False):
+                                      augment=False,
+                                      verbose=False):
         """
         Runs the detector on an image.
 
@@ -152,10 +152,9 @@ class TFDetector:
             image_size (tuple, optional): image size to use for inference, only mess with this
                 if (a) you're using a model other than MegaDetector or (b) you know what you're
                 doing
-            skip_image_resizing (bool, optional): whether to skip internal image resizing (and rely on external
-                resizing).  Not currently supported, but included here for compatibility with PTDetector.
             augment (bool, optional): enable image augmentation.  Not currently  supported, but included
                 here for compatibility with PTDetector.
+            verbose (bool, optional): enable additional debug output
 
         Returns:
             dict: a dictionary with the following fields:
@@ -166,7 +165,6 @@ class TFDetector:
         """
 
         assert image_size is None, 'Image sizing not supported for TF detectors'
-        assert not skip_image_resizing, 'Image sizing not supported for TF detectors'
         assert not augment, 'Image augmentation is not supported for TF detectors'
 
         if detection_threshold is None:

megadetector/postprocessing/classification_postprocessing.py

@@ -1168,7 +1168,7 @@ def restrict_to_taxa_list(taxa_list,
     # Convert all NaN values in the "common" column to empty strings
     taxa_list_df['common'] = taxa_list_df['common'].fillna('')
 
-    # Create a dictionary mapping latin names to common names
+    # Create a dictionary mapping source Latin names to target common names
     target_latin_to_common = {}
 
     for i_row,row in taxa_list_df.iterrows():
@@ -1332,7 +1332,7 @@ def restrict_to_taxa_list(taxa_list,
         _insert_taxonomy_string(new_taxon_string)
 
 
-    ##%% Make sure all species on the allow-list are in the taxonomy
+    ##%% Make sure all taxa on the allow-list are in the taxonomy
 
     n_failed_mappings = 0
 
@@ -1498,7 +1498,8 @@ def restrict_to_taxa_list(taxa_list,
         if (protected_common_names is not None) and \
             (common_name in protected_common_names):
             if verbose:
-                print('Not messing with protected category {}'.format(common_name))
+                print('Not messing with protected category {}:\n{}'.format(
+                    common_name,input_taxon_string))
             input_category_id_to_output_taxon_string[input_category_id] = \
                 input_taxon_string
             continue
@@ -1578,12 +1579,13 @@ def restrict_to_taxa_list(taxa_list,
             output_taxon_string = speciesnet_latin_name_to_taxon_string[target_taxon]
         input_category_id_to_output_taxon_string[input_category_id] = output_taxon_string
 
-    # ...for each category
+    # ...for each category (mapping input category IDs to output taxon strings)
 
 
-    ##%% Build the new tables
+    ##%% Map input category IDs to output category IDs
 
-    speciesnet_taxon_string_to_latin_name = invert_dictionary(speciesnet_latin_name_to_taxon_string)
+    speciesnet_taxon_string_to_latin_name = \
+        invert_dictionary(speciesnet_latin_name_to_taxon_string)
 
     input_category_id_to_output_category_id = {}
     output_taxon_string_to_category_id = {}
@@ -1604,7 +1606,8 @@ def restrict_to_taxa_list(taxa_list,
             if speciesnet_latin_name in speciesnet_latin_name_to_output_common_name:
                 custom_common_name = speciesnet_latin_name_to_output_common_name[speciesnet_latin_name]
                 if custom_common_name != output_common_name:
-                    print('Substituting common name {} for {}'.format(custom_common_name,output_common_name))
+                    if verbose:
+                        print('Substituting common name {} for {}'.format(custom_common_name,output_common_name))
                     output_common_name = custom_common_name
 
         # Do we need to create a new output category?
@@ -1625,20 +1628,16 @@ def restrict_to_taxa_list(taxa_list,
         if False:
             original_common_name = \
               input_category_id_to_common_name[input_category_id]
-
             original_taxon_string = \
                 input_category_id_to_taxonomy_string[input_category_id]
-
             print('Mapping {} ({}) to:\n{} ({})\n'.format(
                 original_common_name,original_taxon_string,
                 output_common_name,output_taxon_string))
-            print('Mapping {} to {}'.format(
-                original_common_name,output_common_name,))
 
-    # ...for each category
+    # ...for each category (mapping input category IDs to output category IDs)
 
 
-    #%% Remap all category labels
+    ##%% Remap all category labels
 
     assert len(set(output_taxon_string_to_category_id.keys())) == \
            len(set(output_taxon_string_to_category_id.values())), \