megadetector 10.0.9__py3-none-any.whl → 10.0.11__py3-none-any.whl

megadetector/detection/run_md_and_speciesnet.py

@@ -32,6 +32,7 @@ from megadetector.utils.ct_utils import write_json
 from megadetector.utils.ct_utils import make_temp_folder
 from megadetector.utils.ct_utils import is_list_sorted
 from megadetector.utils.ct_utils import is_sphinx_build
+from megadetector.utils.ct_utils import args_to_object
 from megadetector.utils import path_utils
 from megadetector.visualization import visualization_utils as vis_utils
 from megadetector.postprocessing.validate_batch_results import \
@@ -61,8 +62,21 @@ 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
-DEAFULT_SECONDS_PER_VIDEO_FRAME = 1.0
+
+# This determines the maximum number of image filenames that can be assigned to
+# 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 = 30
+
+# 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
+
+# Default interval between frames we should process when processing video.
+# This is only used for the detection step.
+DEFAULT_SECONDS_PER_VIDEO_FRAME = 1.0
 
 # Max number of classification scores to include per detection
 DEFAULT_TOP_N_SCORES = 2
@@ -71,6 +85,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 +128,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):
@@ -152,6 +171,12 @@ def _process_image_detections(file_path: str,
 
     detections = detection_results['detections']
 
+    # Don't bother loading images that have no above-threshold detections
+    detections_above_threshold = \
+        [d for d in detections if d['conf'] >= detection_confidence_threshold]
+    if len(detections_above_threshold) == 0:
+        return
+
     # Load the image
     try:
         image = vis_utils.load_image(absolute_file_path)
@@ -173,6 +198,11 @@ def _process_image_detections(file_path: str,
         return
 
     # Process each detection above threshold
+    #
+    # detection_index needs to index into the original list of detections
+    # (this is how classification results will be associated with detections
+    # later), so iterate over "detections" here, rather than
+    # "detections_above_threshold".
     for detection_index, detection in enumerate(detections):
 
         conf = detection['conf']
@@ -192,6 +222,7 @@ def _process_image_detections(file_path: str,
 
         # Preprocess the crop
         try:
+
             preprocessed_crop = classifier.preprocess(
                 image,
                 bboxes=[speciesnet_bbox],
@@ -199,6 +230,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 +239,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 +259,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 +291,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 +303,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 +328,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 +399,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 +490,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 +500,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,
@@ -531,7 +576,7 @@ def _crop_consumer_func(batch_queue: Queue,
     taxonomy_map = {}
     geofence_map = {}
 
-    if (enable_rollup is not None) or (country is not None):
+    if (enable_rollup) or (country is not None):
 
         # Note to self: there are a number of reasons loading the ensemble
         # could fail here; don't catch this exception, this should be a
@@ -571,9 +616,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 +646,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 +874,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 +960,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 +984,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 +1011,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 +1036,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.
@@ -1091,7 +1160,7 @@ def _run_classification_step(detector_results_file: str,
 
                     # Add classifications to the detection
                     detection['classifications'] = classification_pairs
-                    detection['raw_classifications'] = raw_classification_pairs
+                    # detection['raw_classifications'] = raw_classification_pairs
 
                 # ...if this classification contains a failure
 
@@ -1126,6 +1195,196 @@ def _run_classification_step(detector_results_file: str,
 # ...def _run_classification_step(...)
 
 
+#%% Options class
+
+class RunMDSpeciesNetOptions:
+    """
+    Class controlling the behavior of run_md_and_speciesnet()
+    """
+
+    def __init__(self):
+
+        #: Folder containing images and/or videos to process
+        self.source = None
+
+        #: Output file for results (JSON format)
+        self.output_file = None
+
+        #: MegaDetector model identifier (MDv5a, MDv5b, MDv1000-redwood, etc.)
+        self.detector_model = DEFAULT_DETECTOR_MODEL
+
+        #: SpeciesNet classifier model identifier (e.g. kaggle:google/speciesnet/pyTorch/v4.0.1a)
+        self.classification_model = DEFAULT_CLASSIFIER_MODEL
+
+        #: Batch size for MegaDetector inference
+        self.detector_batch_size = DEFAULT_DETECTOR_BATCH_SIZE
+
+        #: Batch size for SpeciesNet classification
+        self.classifier_batch_size = DEFAULT_CLASSIFIER_BATCH_SIZE
+
+        #: Number of worker threads for preprocessing
+        self.loader_workers = DEFAULT_LOADER_WORKERS
+
+        #: Classify detections above this threshold
+        self.detection_confidence_threshold_for_classification = \
+            DEFAULT_DETECTION_CONFIDENCE_THRESHOLD_FOR_CLASSIFICATION
+
+        #: Include detections above this threshold in the output
+        self.detection_confidence_threshold_for_output = \
+            DEFAULT_DETECTION_CONFIDENCE_THRESHOLD_FOR_OUTPUT
+
+        #: Folder for intermediate files (default: system temp)
+        self.intermediate_file_folder = None
+
+        #: Keep intermediate files (e.g. detection-only results file)
+        self.keep_intermediate_files = False
+
+        #: Disable taxonomic rollup
+        self.norollup = False
+
+        #: Country code (ISO 3166-1 alpha-3) for geofencing (default None, no geoferencing)
+        self.country = None
+
+        #: Admin1 region/state code for geofencing
+        self.admin1_region = None
+
+        #: Path to existing MegaDetector output file (skips detection step)
+        self.detections_file = None
+
+        #: Ignore videos, only process images
+        self.skip_video = False
+
+        #: Ignore images, only process videos
+        self.skip_images = False
+
+        #: Sample every Nth frame from videos
+        #:
+        #: Mutually exclusive with time_sample
+        self.frame_sample = None
+
+        #: Sample frames every N seconds from videos
+        #:
+        #: Mutually exclusive with frame_sample
+        self.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+        #: Enable additional debug output
+        self.verbose = False
+
+        if self.time_sample is None and self.frame_sample is None:
+            self.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+# ...class RunMDSpeciesNetOptions
+
+
+#%% Main function
+
+def run_md_and_speciesnet(options):
+    """
+    Main entry point, runs MegaDetector and SpeciesNet on a folder.  See
+    RunMDSpeciesNetOptions for available arguments.
+
+    Args:
+        options (RunMDSpeciesNetOptions): options controlling MD and SN inference
+    """
+
+    # Set global verbose flag
+    global verbose
+    verbose = options.verbose
+
+    # Also set the run_detector_batch verbose flag
+    run_detector_batch.verbose = verbose
+
+    # Validate arguments
+    if not os.path.isdir(options.source):
+        raise ValueError(
+            'Source folder does not exist: {}'.format(options.source))
+
+    if (options.admin1_region is not None) and (options.country is None):
+        raise ValueError('--admin1_region requires --country to be specified')
+
+    if options.skip_images and options.skip_video:
+        raise ValueError('Cannot skip both images and videos')
+
+    if (options.frame_sample is not None) and (options.time_sample is not None):
+        raise ValueError('--frame_sample and --time_sample are mutually exclusive')
+    if (options.frame_sample is None) and (options.time_sample is None):
+        options.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+    # Set up intermediate file folder
+    if options.intermediate_file_folder:
+        temp_folder = options.intermediate_file_folder
+        os.makedirs(temp_folder, exist_ok=True)
+    else:
+        temp_folder = make_temp_folder(subfolder='run_md_and_speciesnet')
+
+    start_time = time.time()
+
+    print('Processing folder: {}'.format(options.source))
+    print('Output file: {}'.format(options.output_file))
+    print('Intermediate files: {}'.format(temp_folder))
+
+    # Determine detector output file path
+    if options.detections_file is not None:
+        detector_output_file = options.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 = options.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(options.detections_file))
+    else:
+        detector_output_file = os.path.join(temp_folder, 'detector_output.json')
+
+        # Run MegaDetector
+        _run_detection_step(
+            source_folder=options.source,
+            detector_output_file=detector_output_file,
+            detector_model=options.detector_model,
+            detector_batch_size=options.detector_batch_size,
+            detection_confidence_threshold=options.detection_confidence_threshold_for_output,
+            detector_worker_threads=options.loader_workers,
+            skip_images=options.skip_images,
+            skip_video=options.skip_video,
+            frame_sample=options.frame_sample,
+            time_sample=options.time_sample
+        )
+
+    # Run SpeciesNet
+    _run_classification_step(
+        detector_results_file=detector_output_file,
+        merged_results_file=options.output_file,
+        source_folder=options.source,
+        classifier_model=options.classification_model,
+        classifier_batch_size=options.classifier_batch_size,
+        classifier_worker_threads=options.loader_workers,
+        detection_confidence_threshold=options.detection_confidence_threshold_for_classification,
+        enable_rollup=(not options.norollup),
+        country=options.country,
+        admin1_region=options.admin1_region,
+    )
+
+    elapsed_time = time.time() - start_time
+    print(
+        'Processing complete in {}'.format(humanfriendly.format_timespan(elapsed_time)))
+    print('Results written to: {}'.format(options.output_file))
+
+    # Clean up intermediate files if requested
+    if (not options.keep_intermediate_files) and \
+       (not options.intermediate_file_folder) and \
+       (not options.detections_file):
+        try:
+            os.remove(detector_output_file)
+        except Exception as e:
+            print('Warning: error removing temporary output file {}: {}'.format(
+                detector_output_file, str(e)))
+
+# ...def run_md_and_speciesnet(...)
+
+
 #%% Command-line driver
 
 def main():
@@ -1181,7 +1440,7 @@ def main():
                         help='Folder for intermediate files (default: system temp)')
     parser.add_argument('--keep_intermediate_files',
                         action='store_true',
-                        help='Keep intermediate files for debugging')
+                        help='Keep intermediate files (e.g. detection-only results file)')
     parser.add_argument('--norollup',
                         action='store_true',
                         help='Disable taxonomic rollup')
@@ -1208,7 +1467,7 @@ def main():
                         type=float,
                         default=None,
                         help='Sample frames every N seconds from videos (default {})'.\
-                            format(DEAFULT_SECONDS_PER_VIDEO_FRAME) + \
+                            format(DEFAULT_SECONDS_PER_VIDEO_FRAME) + \
                             ' (mutually exclusive with --frame_sample)')
     parser.add_argument('--verbose',
                         action='store_true',
@@ -1220,97 +1479,10 @@ def main():
 
     args = parser.parse_args()
 
-    # Set global verbose flag
-    global verbose
-    verbose = args.verbose
-
-    # Also set the run_detector_batch verbose flag
-    run_detector_batch.verbose = verbose
+    options = RunMDSpeciesNetOptions()
+    args_to_object(args,options)
 
-    # Validate arguments
-    if not os.path.isdir(args.source):
-        raise ValueError(
-            'Source folder does not exist: {}'.format(args.source))
-
-    if args.admin1_region and not args.country:
-        raise ValueError('--admin1_region requires --country to be specified')
-
-    if args.skip_images and args.skip_video:
-        raise ValueError('Cannot skip both images and videos')
-
-    if (args.frame_sample is not None) and (args.time_sample is not None):
-        raise ValueError('--frame_sample and --time_sample are mutually exclusive')
-    if (args.frame_sample is None) and (args.time_sample is None):
-        args.time_sample = DEAFULT_SECONDS_PER_VIDEO_FRAME
-
-    # Set up intermediate file folder
-    if args.intermediate_file_folder:
-        temp_folder = args.intermediate_file_folder
-        os.makedirs(temp_folder, exist_ok=True)
-    else:
-        temp_folder = make_temp_folder(subfolder='run_md_and_speciesnet')
-
-    start_time = time.time()
-
-    print('Processing folder: {}'.format(args.source))
-    print('Output file: {}'.format(args.output_file))
-    print('Intermediate files: {}'.format(temp_folder))
-
-    # Determine detector output file path
-    if args.detections_file:
-        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')
-    else:
-        detector_output_file = os.path.join(temp_folder, 'detector_output.json')
-
-        # Run MegaDetector
-        _run_detection_step(
-            source_folder=args.source,
-            detector_output_file=detector_output_file,
-            detector_model=args.detector_model,
-            detector_batch_size=args.detector_batch_size,
-            detection_confidence_threshold=args.detection_confidence_threshold_for_output,
-            detector_worker_threads=args.loader_workers,
-            skip_images=args.skip_images,
-            skip_video=args.skip_video,
-            frame_sample=args.frame_sample,
-            time_sample=args.time_sample
-        )
-
-    # Run SpeciesNet
-    _run_classification_step(
-        detector_results_file=detector_output_file,
-        merged_results_file=args.output_file,
-        source_folder=args.source,
-        classifier_model=args.classification_model,
-        classifier_batch_size=args.classifier_batch_size,
-        classifier_worker_threads=args.loader_workers,
-        detection_confidence_threshold=args.detection_confidence_threshold_for_classification,
-        enable_rollup=(not args.norollup),
-        country=args.country,
-        admin1_region=args.admin1_region,
-    )
-
-    elapsed_time = time.time() - start_time
-    print(
-        'Processing complete in {}'.format(humanfriendly.format_timespan(elapsed_time)))
-    print('Results written to: {}'.format(args.output_file))
-
-    # Clean up intermediate files if requested
-    if (not args.keep_intermediate_files) and \
-       (not args.intermediate_file_folder) and \
-       (not args.detections_file):
-        try:
-            os.remove(detector_output_file)
-        except Exception as e:
-            print('Warning: error removing temporary output file {}: {}'.format(
-                detector_output_file, str(e)))
+    run_md_and_speciesnet(options)
 
 # ...def main(...)
 

megadetector/detection/run_tiled_inference.py

@@ -510,9 +510,9 @@ def run_tiled_inference(model_file,
                 try:
                     fn_relative = os.path.relpath(fn,image_folder)
                 except ValueError:
-                    'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
-                        fn,image_folder)
-                    raise
+                    raise ValueError(
+                        'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
+                        fn,image_folder))
                 assert not fn_relative.startswith('..'), \
                     'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
                         fn,image_folder)
@@ -619,12 +619,12 @@ def run_tiled_inference(model_file,
     else:
 
         patch_file_names = []
-        for im in all_image_patch_info:
+        for patch_info in all_image_patch_info:
             # If there was a patch generation error, don't run inference
             if patch_info['error'] is not None:
-                assert im['image_fn'] in images_with_patch_errors
+                assert patch_info['image_fn'] in images_with_patch_errors
                 continue
-            for patch in im['patches']:
+            for patch in patch_info['patches']:
                 patch_file_names.append(patch['patch_fn'])
 
         inference_results = load_and_run_detector_batch(model_file,
@@ -952,7 +952,7 @@ def main():
     parser.add_argument(
         '--tile_size_y',
         type=int,
-        default=default_tile_size[0],
+        default=default_tile_size[1],
         help=('Tile height (defaults to {})'.format(default_tile_size[1])))
     parser.add_argument(
         '--tile_overlap',

megadetector/detection/tf_detector.py

@@ -42,7 +42,7 @@ class TFDetector:
         input and output tensor handles.
 
         Args:
-            model_path (str): path to .pdb file
+            model_path (str): path to .pb file
             detector_options (dict, optional): key-value pairs that control detector
                 options; currently not used by TFDetector
         """
@@ -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: