megadetector 5.0.5__py3-none-any.whl → 5.0.7__py3-none-any.whl

data_management/resize_coco_dataset.py

@@ -49,6 +49,8 @@ def resize_coco_dataset(input_folder,input_filename,
     of the way there, due to what appears to be a slight bias inherent to MD.  If a box extends
     within [right_edge_quantization_threshold] (a small number, from 0 to 1, but probably around 
     0.02) of the right edge of the image, it will be extended to the far right edge.
+    
+    Returns the COCO database with resized images.
     """
     
     # Read input data
@@ -62,7 +64,9 @@ def resize_coco_dataset(input_folder,input_filename,
                                           
     # For each image
     
-    # im = d['images'][1]
+    # TODO: this is trivially parallelizable
+    #
+    # im = d['images'][0]
     for im in tqdm(d['images']):
     
         input_fn_relative = im['file_name']
@@ -143,6 +147,8 @@ def resize_coco_dataset(input_folder,input_filename,
     with open(output_filename,'w') as f:
         json.dump(d,f,indent=1)
     
+    return d
+
 # ...def resize_coco_dataset(...)
     
 
@@ -153,17 +159,13 @@ if False:
     pass
 
     #%% Test resizing
-    
-    # input_filename = os.path.expanduser('~/tmp/labelme_to_coco_test.json')
-    # input_folder = os.path.expanduser('~/data/labelme-json-test')
-    # target_size = (600,-1)
-    
-    input_folder = os.path.expanduser('~/data/usgs-kissel-training')
-    input_filename = os.path.expanduser('~/data/usgs-tegus.json')
+        
+    input_folder = os.path.expanduser('~/data/usgs-tegus/usgs-kissel-training')
+    input_filename = os.path.expanduser('~/data/usgs-tegus/usgs-kissel-training.json')
     target_size = (1600,-1)
     
-    output_filename = insert_before_extension(input_filename,'resized')
-    output_folder = input_folder + '-resized'    
+    output_filename = insert_before_extension(input_filename,'resized-test')
+    output_folder = input_folder + '-resized-test'
     
     correct_size_image_handling = 'rewrite'
     
@@ -184,7 +186,7 @@ if False:
     options.viz_size = (900, -1)
     options.num_to_visualize = 5000
 
-    html_file,_ = visualize_db.process_images(output_filename,
+    html_file,_ = visualize_db.visualize_db(output_filename,
                                               os.path.expanduser('~/tmp/resize_coco_preview'),
                                               output_folder,options)
     

data_management/yolo_output_to_md_output.py

@@ -42,8 +42,9 @@
 #%% Imports and constants
 
 import json
-import os
 import csv
+import os
+import re
 
 from collections import defaultdict
 from tqdm import tqdm
@@ -58,6 +59,42 @@ from detection.run_detector import CONF_DIGITS, COORD_DIGITS
 
 #%% Support functions
 
+def read_classes_from_yolo_dataset_file(fn):
+    """
+    Read a dictionary mapping integer class IDs to class names from a YOLOv5/YOLOv8
+    dataset.yaml file or a .json file.  A .json file should contain a dictionary mapping
+    integer category IDs to string category names.
+    """
+        
+    if fn.endswith('.yml') or fn.endswith('.yaml'):
+        
+        with open(fn,'r') as f:
+            lines = f.readlines()
+                
+        category_id_to_name = {}
+        pat = '\d+:.+'
+        for s in lines:
+            if re.search(pat,s) is not None:
+                tokens = s.split(':')
+                assert len(tokens) == 2, 'Invalid token in category file {}'.format(fn)
+                category_id_to_name[int(tokens[0].strip())] = tokens[1].strip()
+                
+    elif fn.endswith('.json'):
+        
+        with open(fn,'r') as f:
+            d_in = json.load(f)
+            category_id_to_name = {}
+            for k in d_in.keys():
+                category_id_to_name[int(k)] = d_in[k]
+        
+    else:
+        
+        raise ValueError('Unrecognized category file type: {}'.format(fn))
+        
+    assert len(category_id_to_name) > 0, 'Failed to read class mappings from {}'.format(fn)
+    return category_id_to_name
+    
+
 def yolo_json_output_to_md_output(yolo_json_file, image_folder,
                                   output_file, yolo_category_id_to_name,                              
                                   detector_name='unknown',
@@ -68,23 +105,32 @@ def yolo_json_output_to_md_output(yolo_json_file, image_folder,
     """
     Convert a YOLOv5 .json file to MD .json format.
     
-    Args
-    - yolo_json_file: the .json file to convert from YOLOv5 format to MD output format
-    - image_folder: the .json file contains relative path names, this is the path base
+    Args:
+        
+    - yolo_json_file: the .json file to convert from YOLOv5 format to MD output format.
+    
+    - image_folder: the .json file contains relative path names, this is the path base.
+    
     - yolo_category_id_to_name: the .json file contains only numeric identifiers for
       categories, but we want names and numbers for the output format; this is a 
-      dict mapping numbers to names
-    - detector_name: a string put in the output file, not otherwise used here
+      dict mapping numbers to names.  Can also be a YOLOv5 dataset.yaml file.
+    
+    - detector_name: a string that gets put in the output file, not otherwise used within
+      this function.
+    
     - image_id_to_relative_path: YOLOv5 .json uses only basenames (e.g. abc1234.JPG);
       by default these will be appended to the input path to create pathnames, so if you
       have a flat folder, this is fine.  If you want to map base names to relative paths, use
       this dict.
+    
     - offset_yolo_class_ids: YOLOv5 class IDs always start at zero; if you want to make the 
-      output classes start at 1, set offset_yolo_class_ids
+      output classes start at 1, set offset_yolo_class_ids to True.
+    
     - truncate_to_standard_md_precision: YOLOv5 .json includes lots of (not-super-meaningful)
       precision, set this to truncate to COORD_DIGITS and CONF_DIGITS.
-    - image_id_to_error: if you want to include image IDs in the output file because you couldn't
-      prepare the input file in the first place, include them here.
+    
+    - image_id_to_error: if you want to include image IDs in the output file for which you couldn't
+      prepare the input file in the first place due to errors, include them here.
     """    
         
     assert os.path.isfile(yolo_json_file), \
@@ -95,7 +141,14 @@ def yolo_json_output_to_md_output(yolo_json_file, image_folder,
     if image_id_to_error is None:
         image_id_to_error = {}
             
-    print('Converting {} to MD format'.format(yolo_json_file))
+    print('Converting {} to MD format and writing results to {}'.format(
+        yolo_json_file,output_file))
+    
+    if isinstance(yolo_category_id_to_name,str):
+        assert os.path.isfile(yolo_category_id_to_name), \
+            'YOLO category mapping specified as a string, but file does not exist: {}'.format(
+                yolo_category_id_to_name)
+        yolo_category_id_to_name = read_classes_from_yolo_dataset_file(yolo_category_id_to_name)
     
     if image_id_to_relative_path is None:
         
@@ -158,6 +211,16 @@ def yolo_json_output_to_md_output(yolo_json_file, image_folder,
            
     # ...if image IDs are formatted as integers in YOLO output
     
+    # In a modified version of val.py, we use negative category IDs to indicate an error
+    # that happened during inference (typically truncated images with valid headers,
+    # so corruption was not detected during val.py's initial corruption check pass.
+    for det in detections:
+        if det['category_id'] < 0:
+            assert 'error' in det, 'Negative category ID present with no error string'
+            error_string = det['error']
+            print('Caught inference-time failure {} for image {}'.format(error_string,det['image_id']))
+            image_id_to_error[det['image_id']] = error_string
+            
     output_images = []
     
     # image_file_relative = image_files_relative[10]
@@ -238,7 +301,7 @@ def yolo_json_output_to_md_output(yolo_json_file, image_folder,
     d['images'] = output_images
     d['info'] = {'format_version':1.3,'detector':detector_name}
     d['detection_categories'] = {}
-    
+        
     for cat_id in yolo_category_id_to_name:
         yolo_cat_id = int(cat_id)
         if offset_yolo_class_ids:
@@ -248,9 +311,18 @@ def yolo_json_output_to_md_output(yolo_json_file, image_folder,
     with open(output_file,'w') as f:
         json.dump(d,f,indent=1)
             
+# ...def yolo_json_output_to_md_output(...)
     
+
 def yolo_txt_output_to_md_output(input_results_folder, image_folder,
                                  output_file, detector_tag=None):
+    """
+    Converts a folder of YOLO-outptu .txt files to MD .json format.
+    
+    Less finished than the .json conversion function; this .txt conversion assumes 
+    a hard-coded mapping representing the standard MD categories (in MD indexing, 
+    1/2/3=animal/person/vehicle; in YOLO indexing, 0/1/2=animal/person/vehicle).
+    """
     
     assert os.path.isdir(input_results_folder)
     assert os.path.isdir(image_folder)
@@ -339,7 +411,7 @@ def yolo_txt_output_to_md_output(input_results_folder, image_folder,
     with open(output_file,'w') as f:
         json.dump(output_content,f,indent=1)
     
-# ...def yolo_output_to_md_output()
+# ...def yolo_txt_output_to_md_output(...)
 
 
 #%% Interactive driver

data_management/yolo_to_coco.py

@@ -18,11 +18,19 @@ from PIL import Image
 from tqdm import tqdm
 
 from md_utils.path_utils import find_images
+from data_management.yolo_output_to_md_output import read_classes_from_yolo_dataset_file
 
 
 #%% Main conversion function
 
 def yolo_to_coco(input_folder,class_name_file,output_file=None):
+    """
+    Convert the YOLO-formatted data in [input_folder] to a COCO-formatted dictionary,
+    reading class names from [class_name_file], which can be a flat list with a .txt
+    extension or a YOLO dataset.yml file.  Optionally writes the output dataset to [output_file].
+    
+    Returns a COCO-formatted dictionary.
+    """
     
     # Validate input
     
@@ -30,29 +38,39 @@ def yolo_to_coco(input_folder,class_name_file,output_file=None):
     assert os.path.isfile(class_name_file)
     
     
-    # Class names
+    # Read class names
     
-    with open(class_name_file,'r') as f:
-        lines = f.readlines()
-    assert len(lines) > 0, 'Empty class name file {}'.format(class_name_file)
-    lines = [s.strip() for s in lines]
-    assert len(lines[0]) > 0, 'Empty class name file {} (empty first line)'.format(class_name_file)
+    ext = os.path.splitext(class_name_file)[1][1:]
+    assert ext in ('yml','txt','yaml'), 'Unrecognized class name file type {}'.format(
+        class_name_file)
     
-    # Blank lines should only appear at the end
-    b_found_blank = False
-    for s in lines:
-        if len(s) == 0:
-            b_found_blank = True
-        elif b_found_blank:
-            raise ValueError('Invalid class name file {}, non-blank line after the last blank line'.format(
-                class_name_file))
-            
-    category_id_to_name = {}
+    if ext == 'txt':
         
-    for i_category_id,category_name in enumerate(lines):
-        assert len(category_name) > 0
-        category_id_to_name[i_category_id] = category_name
+        with open(class_name_file,'r') as f:
+            lines = f.readlines()
+        assert len(lines) > 0, 'Empty class name file {}'.format(class_name_file)
+        class_names = [s.strip() for s in lines]
+        assert len(lines[0]) > 0, 'Empty class name file {} (empty first line)'.format(class_name_file)
         
+        # Blank lines should only appear at the end
+        b_found_blank = False
+        for s in lines:
+            if len(s) == 0:
+                b_found_blank = True
+            elif b_found_blank:
+                raise ValueError('Invalid class name file {}, non-blank line after the last blank line'.format(
+                    class_name_file))
+    
+        category_id_to_name = {}        
+        for i_category_id,category_name in enumerate(class_names):
+            assert len(category_name) > 0
+            category_id_to_name[i_category_id] = category_name
+            
+    else:
+        
+        assert ext in ('yml','yaml')
+        category_id_to_name = read_classes_from_yolo_dataset_file(class_name_file)
+            
         
     # Enumerate images
     
@@ -209,7 +227,7 @@ if False:
     viz_options.parallelize_rendering = True
     viz_options.include_filename_links = True
 
-    html_output_file, _ = visualize_db.process_images(db_path=output_file,
+    html_output_file, _ = visualize_db.visualize_db(db_path=output_file,
                                                         output_dir=preview_folder,
                                                         image_base_dir=input_folder,
                                                         options=viz_options)

detection/process_video.py

@@ -26,12 +26,17 @@ from detection.video_utils import frame_results_to_video_results
 from detection.video_utils import video_folder_to_frames
 from uuid import uuid1
 
+from detection.video_utils import default_fourcc
+
 
 #%% Options classes
 
 class ProcessVideoOptions:
 
-    model_file = ''
+    # Can be a model filename (.pt or .pb) or a model name (e.g. "MDV5A")
+    model_file = 'MDV5A'
+    
+    # Can be a file or a folder
     input_video_file = ''
 
     output_json_file = None
@@ -72,9 +77,10 @@ class ProcessVideoOptions:
     
     recursive = False 
     verbose = False
+    
     fourcc = None
 
-    rendering_confidence_threshold = 0.15
+    rendering_confidence_threshold = None
     json_confidence_threshold = 0.005
     frame_sample = None
     
@@ -175,8 +181,14 @@ def process_video(options):
             confidence_threshold=options.rendering_confidence_threshold)
 
         # Combine into a video
-        print('Rendering video to {} at {} fps'.format(options.output_video_file,Fs))
-        frames_to_video(detected_frame_files, Fs, options.output_video_file, codec_spec=options.fourcc)
+        if options.frame_sample is None:
+            rendering_fs = Fs
+        else:
+            rendering_fs = Fs / options.frame_sample
+            
+        print('Rendering video to {} at {} fps (original video {} fps)'.format(
+            options.output_video_file,rendering_fs,Fs))
+        frames_to_video(detected_frame_files, rendering_fs, options.output_video_file, codec_spec=options.fourcc)
         
         # Delete the temporary directory we used for detection images
         if not options.keep_rendered_frames:
@@ -344,11 +356,19 @@ def process_video_folder(options):
             output_video_folder = options.input_video_file
                                 
         # For each video
+        #
+        # TODO: parallelize this loop
+        #
         # i_video=0; input_video_file_abs = video_filenames[i_video]
         for i_video,input_video_file_abs in enumerate(video_filenames):
             
             video_fs = Fs[i_video]
             
+            if options.frame_sample is None:                
+                rendering_fs = video_fs
+            else:
+                rendering_fs = video_fs / options.frame_sample
+            
             input_video_file_relative = os.path.relpath(input_video_file_abs,options.input_video_file)
             video_frame_output_folder = os.path.join(frame_rendering_output_dir,input_video_file_relative)
             assert os.path.isdir(video_frame_output_folder), \
@@ -371,11 +391,10 @@ def process_video_folder(options):
             os.makedirs(os.path.dirname(video_output_file),exist_ok=True)
             
             # Create the output video            
-            print('Rendering detections for video {} to {} at {} fps'.format(input_video_file_relative,
-                                                              video_output_file,video_fs))
-            frames_to_video(video_frame_files, video_fs, video_output_file, codec_spec=options.fourcc)
-            
-    
+            print('Rendering detections for video {} to {} at {} fps (original video {} fps)'.format(
+                input_video_file_relative,video_output_file,rendering_fs,video_fs))
+            frames_to_video(video_frame_files, rendering_fs, video_output_file, codec_spec=options.fourcc)
+                
         # ...for each video
         
         # Possibly clean up rendered frames
@@ -525,12 +544,14 @@ if False:
 
 def main():
 
+    default_options = ProcessVideoOptions()
+    
     parser = argparse.ArgumentParser(description=(
         'Run MegaDetector on each frame in a video (or every Nth frame), optionally '\
         'producing a new video with detections annotated'))
 
     parser.add_argument('model_file', type=str,
-                        help='MegaDetector model file')
+                        help='MegaDetector model file (.pt or .pb) or model name (e.g. "MDV5A")')
 
     parser.add_argument('input_video_file', type=str,
                         help='video file (or folder) to process')
@@ -567,8 +588,8 @@ def main():
     parser.add_argument('--render_output_video', action='store_true',
                         help='enable video output rendering (not rendered by default)')
 
-    parser.add_argument('--fourcc', default=None,
-                        help='fourcc code to use for video encoding, only used if render_output_video is True')
+    parser.add_argument('--fourcc', default=default_fourcc,
+                        help='fourcc code to use for video encoding (default {}), only used if render_output_video is True'.format(default_fourcc))
     
     parser.add_argument('--keep_rendered_frames',
                        action='store_true', help='Disable the deletion of rendered (w/boxes) frames')
@@ -586,11 +607,12 @@ def main():
                            'whether other files were present in the folder.')
         
     parser.add_argument('--rendering_confidence_threshold', type=float,
-                        default=0.8, help="don't render boxes with confidence below this threshold")
+                        default=None, help="don't render boxes with confidence below this threshold (defaults to choosing based on the MD version)")
 
     parser.add_argument('--json_confidence_threshold', type=float,
                         default=0.0, help="don't include boxes in the .json file with confidence "\
-                            'below this threshold')
+                            'below this threshold (default {})'.format(
+                                default_options.json_confidence_threshold))
 
     parser.add_argument('--n_cores', type=int,
                         default=1, help='number of cores to use for frame separation and detection. '\

detection/pytorch_detector.py

@@ -17,17 +17,31 @@ from md_utils import ct_utils
 
 # We support a few ways of accessing the YOLOv5 dependencies:
 #
-# * The standard configuration as of 9.2023 expects that the YOLOv5 repo is checked
+# * The standard configuration as of 2023.09 expects that the YOLOv5 repo is checked
 #   out and on the PYTHONPATH (import utils)
 #
-# * Experimental: pip install ultralytics (doesn't totally work yet)
+# * Supported but non-default (used for PyPI packaging):
 #
-# * Experimental but works so far: pip install yolov5
+#   pip install ultralytics-yolov5
+#
+# * Works, but not supported:
+#
+#   pip install yolov5
+#
+# * Unfinished:
+#
+#   pip install ultralytics
+#
+#   If try_ultralytics_import is True, we'll try to import all YOLOv5 dependencies from 
+#   ultralytics.utils and ultralytics.data.  But as of 2023.11, this results in a "No 
+#   module named 'models'" error when running MDv5, and there's no upside to this approach
+#   compared to using either of the YOLOv5 PyPI packages, so... punting on this for now.
 
 utils_imported = False
 try_yolov5_import = True
 
-# This still encounters some namespace issues
+# See above; this should remain as "False" unless we update the MegaDetector .pt file
+# to use more recent YOLOv5 namespace conventions.
 try_ultralytics_import = False
 
 # First try importing from the yolov5 package
@@ -77,7 +91,7 @@ if not utils_imported:
         except ImportError:
             from utils.general import scale_boxes as scale_coords
         utils_imported = True
-        print('Imported YOLOv5 from PYTHONPATH')
+        print('Imported YOLOv5 as utils.*')
     except ModuleNotFoundError:
         raise ModuleNotFoundError('Could not import YOLOv5 functions.')
 
@@ -220,7 +234,7 @@ class PTDetector:
             if self.device == 'mps':
                 # As of v1.13.0.dev20220824, nms is not implemented for MPS.
                 #
-                # Send predication back to the CPU to fix.
+                # Send prediction back to the CPU to fix.
                 pred = non_max_suppression(prediction=pred.cpu(), conf_thres=detection_threshold)
             else: 
                 pred = non_max_suppression(prediction=pred, conf_thres=detection_threshold)
@@ -295,10 +309,11 @@ if __name__ == '__main__':
     import md_visualization.visualization_utils as vis_utils
     import os
     
-    model_file = os.path.expanduser('~/models/camera_traps/megadetector/md_v5.0.0/md_v5a.0.0.pt')
-    im_file = r"G:\temp\coyote\DSCF0043.JPG"
+    model_file = 'MDV5A'
+    im_file = os.path.expanduser('~/git/MegaDetector/images/nacti.jpg')
 
     detector = PTDetector(model_file)
     image = vis_utils.load_image(im_file)
 
     res = detector.generate_detections_one_image(image, im_file, detection_threshold=0.00001)
+    print(res)

detection/run_detector.py

@@ -10,12 +10,7 @@
 # This script is not a good way to process lots of images (tens of thousands,
 # say). It does not facilitate checkpointing the results so if it crashes you
 # would have to start from scratch. If you want to run a detector (e.g., ours)
-# on lots of images, you should check out:
-# 
-# 1) run_detector_batch.py (for local execution)
-# 
-# 2) https://github.com/agentmorris/MegaDetector/tree/master/api/batch_processing
-#    (for running large jobs on Azure ML)
+# on lots of images, you should check out run_detector_batch.py.
 # 
 # To run this script, we recommend you set up a conda virtual environment
 # following instructions in the Installation section on the main README, using
@@ -136,6 +131,33 @@ downloadable_models = {
     'MDV5B':'https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5b.0.0.pt'
 }
 
+model_string_to_model_version = {
+    'v2':'v2.0.0',
+    'v3':'v3.0.0',
+    'v4.1':'v4.1.0',
+    'v5a.0.0':'v5a.0.0',
+    'v5b.0.0':'v5b.0.0',
+    'mdv5a':'v5a.0.0',
+    'mdv5b':'v5b.0.0',
+    'mdv4':'v4.1.0',
+    'mdv3':'v3.0.0'
+}
+
+# Approximate inference speeds (in images per second) for MDv5 based on 
+# benchmarks, only used for reporting very coarse expectations about inference time.
+device_token_to_mdv5_inference_speed = {
+    '4090':17.6,
+    '3090':11.4,
+    '3080':9.5,
+    '3050':4.2,
+    'P2000':2.1,
+    # These are written this way because they're MDv4 benchmarks, and MDv5
+    # is around 3.5x faster than MDv4.
+    'V100':2.79*3.5,
+    '2080':2.3*3.5,
+    '2060':1.6*3.5
+}
+    
 
 #%% Utility functions
 
@@ -164,7 +186,9 @@ def get_detector_metadata_from_version_string(detector_version):
     if detector_version not in DETECTOR_METADATA:
         print('Warning: no metadata for unknown detector version {}'.format(detector_version))
         default_detector_metadata = {
-            'megadetector_version':'unknown'
+            'megadetector_version':'unknown',
+            'typical_detection_threshold':0.5,
+            'conservative_detection_threshold':0.25
         }
         return default_detector_metadata
     else:
@@ -188,18 +212,9 @@ def get_detector_version_from_filename(detector_filename):
     "v4.1.0", "v5a.0.0", and "v5b.0.0", respectively.
     """
     
-    fn = os.path.basename(detector_filename)
-    known_model_versions = {'v2':'v2.0.0',
-                            'v3':'v3.0.0',
-                            'v4.1':'v4.1.0',
-                            'v5a.0.0':'v5a.0.0',
-                            'v5b.0.0':'v5b.0.0',
-                            'MDV5A':'v5a.0.0',
-                            'MDV5B':'v5b.0.0',
-                            'MDV4':'v4.1.0',
-                            'MDV3':'v3.0.0'}
+    fn = os.path.basename(detector_filename).lower()
     matches = []
-    for s in known_model_versions.keys():
+    for s in model_string_to_model_version.keys():
         if s in fn:
             matches.append(s)
     if len(matches) == 0:
@@ -209,9 +224,51 @@ def get_detector_version_from_filename(detector_filename):
         print('Warning: multiple MegaDetector versions for model file {}'.format(detector_filename))
         return 'multiple'
     else:
-        return known_model_versions[matches[0]]
+        return model_string_to_model_version[matches[0]]
     
 
+def estimate_md_images_per_second(model_file, device_name=None):
+    """
+    Estimate how fast MegaDetector will run based on benchmarks.  Defaults to querying
+    the current device.  Returns None if no data is available for the current card/model.
+    Estimates only available for a small handful of GPUs.
+    """
+    
+    if device_name is None:
+        try:
+            import torch
+            device_name = torch.cuda.get_device_name()
+        except Exception as e:
+            print('Error querying device name: {}'.format(e))
+            return None
+    
+    model_file = model_file.lower().strip()
+    if model_file in model_string_to_model_version.values():
+        model_version = model_file
+    else:
+        model_version = get_detector_version_from_filename(model_file)
+        if model_version not in model_string_to_model_version.values():
+            print('Error determining model version for model file {}'.format(model_file))
+            return None
+    
+    mdv5_inference_speed = None
+    for device_token in device_token_to_mdv5_inference_speed.keys():
+        if device_token in device_name:
+            mdv5_inference_speed = device_token_to_mdv5_inference_speed[device_token]
+            break
+    
+    if mdv5_inference_speed is None:
+        print('No speed estimate available for {}'.format(device_name))
+    
+    if 'v5' in model_version:
+        return mdv5_inference_speed
+    elif 'v2' in model_version or 'v3' in model_version or 'v4' in model_version:
+        return mdv5_inference_speed / 3.5
+    else:
+        print('Could not estimate inference speed for model file {}'.format(model_file))
+        return None
+    
+    
 def get_typical_confidence_threshold_from_results(results):
     """
     Given the .json data loaded from a MD results file, determine a typical confidence