megadetector 5.0.25__py3-none-any.whl → 5.0.26__py3-none-any.whl

megadetector/data_management/cct_json_utils.py

@@ -300,7 +300,10 @@ class SequenceOptions:
     def __init__(self):
         #: Images separated by <= this duration will be grouped into the same sequence.
         self.episode_interval_seconds = 60.0
-
+        
+        #: How to handle invalid datetimes: 'error' or 'none'
+        self.datetime_conversion_failure_behavior = 'none'
+        
     
 #%% Functions
 
@@ -445,7 +448,17 @@ def create_sequences(image_info,options=None):
         raise ValueError('Unrecognized type for [image_info]')
         
     # Modifies the images in place
-    _ = parse_datetimes_from_cct_image_list(image_info)
+    _ = parse_datetimes_from_cct_image_list(image_info, 
+            conversion_failure_behavior=options.datetime_conversion_failure_behavior)
+    
+    n_invalid_datetimes = 0
+    for im in image_info:
+        if not isinstance(im['datetime'],datetime.datetime):
+            assert im['datetime'] is None, 'At this point, datetimes should be valid or None'
+            n_invalid_datetimes += 1
+    if n_invalid_datetimes > 0:
+        print('Warning: {} of {} images have invalid datetimes'.format(
+            n_invalid_datetimes,len(image_info)))
     
     # Find all unique locations
     locations = set()

megadetector/data_management/coco_to_yolo.py

@@ -47,6 +47,9 @@ def write_yolo_dataset_file(yolo_dataset_file,
         class_list (list or str): an ordered list of class names (the first item will be class 0, 
             etc.), or the name of a text file containing an ordered list of class names (one per 
             line, starting from class zero).
+        train_folder_relative (str, optional): train folder name, used only to populate dataset.yaml
+        val_folder_relative (str, optional): val folder name, used only to populate dataset.yaml
+        test_folder_relative (str, optional): test folder name, used only to populate dataset.yaml        
     """
     
     # Read class names
@@ -97,7 +100,7 @@ def coco_to_yolo(input_image_folder,
                  category_names_to_exclude=None,
                  category_names_to_include=None,
                  write_output=True,
-                 flatten_paths=True):
+                 flatten_paths=False):
     """
     Converts a COCO-formatted dataset to a YOLO-formatted dataset, optionally flattening the 
     dataset to a single folder in the process.
@@ -116,17 +119,21 @@ def coco_to_yolo(input_image_folder,
             images are left alone.
         source_format (str, optional): can be 'coco' (default) or 'coco_camera_traps'.  The only difference
             is that when source_format is 'coco_camera_traps', we treat an image with a non-bbox
-            annotation with a category id of 0 as a special case, i.e. that's how an empty image
-            is indicated.  The original COCO standard is a little ambiguous on this issue.  If
-            source_format is 'coco', we either treat images as empty or error, depending on the value
-            of [allow_empty_annotations].  [allow_empty_annotations] has no effect if source_format is
-            'coco_camera_traps'.
+            annotation as a special case, i.e. that's how an empty image is indicated.  The original 
+            COCO standard is a little ambiguous on this issue.  If source_format is 'coco', we 
+            either treat images as empty or error, depending on the value of [allow_empty_annotations].
+            [allow_empty_annotations] has no effect if source_format is 'coco_camera_traps'.
+        overwrite_images (bool, optional): over-write images in the output folder if they exist
         create_image_and_label_folder (bool, optional): whether to create separate folders called 'images' and
             'labels' in the YOLO output folder.  If create_image_and_label_folders is False, 
             a/b/c/image001.jpg will become a#b#c#image001.jpg, and the corresponding text file will 
             be a#b#c#image001.txt.  If create_image_and_label_folders is True, a/b/c/image001.jpg will become 
             images/a#b#c#image001.jpg, and the corresponding text file will be 
             labels/a#b#c#image001.txt.    
+        class_file_name (str, optional): .txt file (relative to the output folder) that we should 
+            populate with a list of classes (or None to omit)
+        allow_empty_annotations (bool, optional): if this is False and [source_format] is 'coco', 
+            we'll error on annotations that have no 'bbox' field
         clip_boxes (bool, optional): whether to clip bounding box coordinates to the range [0,1] before
             converting to YOLO xywh format
         image_id_to_output_image_json_file (str, optional): an optional *output* file, to which we will write
@@ -139,12 +146,14 @@ def coco_to_yolo(input_image_folder,
         category_names_to_exclude (str, optional): category names that should not be represented in the
             YOLO output; only impacts annotations, does not prevent copying images.  There's almost no reason
             you would want to specify this and [category_names_to_include]. 
-        category_names_to_include (str, optional): allow-list of category names that should be represented in the
-            YOLO output; only impacts annotations, does not prevent copying images.  There's almost no reason
-            you would want to specify this and [category_names_to_exclude]. 
+        category_names_to_include (str, optional): allow-list of category names that should be represented 
+            in the YOLO output; only impacts annotations, does not prevent copying images.  There's almost 
+            no reason you would want to specify this and [category_names_to_exclude]. 
         write_output (bool, optional): determines whether we actually copy images and write annotations;
             setting this to False mostly puts this function in "dry run" "mode.  The class list
             file is written regardless of the value of write_output.
+        flatten_paths (bool, optional): replace /'s in image filenames with [path_replacement_char],
+            which ensures that the output folder is a single flat folder.
     
     Returns:
         dict: information about the coco --> yolo mapping, containing at least the fields:
@@ -313,9 +322,9 @@ def coco_to_yolo(input_image_folder,
                     
                     elif source_format == 'coco_camera_traps':
                         
-                        # We allow empty bbox lists in COCO camera traps; this is typically a negative
-                        # example in a dataset that has bounding boxes, and 0 is typically the empty 
-                        # category.
+                        # We allow empty bbox lists in COCO camera traps files; this is typically a 
+                        # negative example in a dataset that has bounding boxes, and 0 is typically 
+                        # the empty category, which is typically 0.
                         if ann['category_id'] != 0:
                             if not printed_empty_annotation_warning:
                                 printed_empty_annotation_warning = True
@@ -429,13 +438,14 @@ def coco_to_yolo(input_image_folder,
     
     print('Generating class list')
     
-    class_list_filename = os.path.join(output_folder,class_file_name)
-    with open(class_list_filename, 'w') as f:
-        print('Writing class list to {}'.format(class_list_filename))
-        for i_class in range(0,len(yolo_id_to_name)):
-            # Category IDs should range from 0..N-1
-            assert i_class in yolo_id_to_name
-            f.write(yolo_id_to_name[i_class] + '\n')
+    if class_file_name is not None:
+        class_list_filename = os.path.join(output_folder,class_file_name)
+        with open(class_list_filename, 'w') as f:
+            print('Writing class list to {}'.format(class_list_filename))
+            for i_class in range(0,len(yolo_id_to_name)):
+                # Category IDs should range from 0..N-1
+                assert i_class in yolo_id_to_name
+                f.write(yolo_id_to_name[i_class] + '\n')
     
     if image_id_to_output_image_json_file is not None:
         print('Writing image ID mapping to {}'.format(image_id_to_output_image_json_file))
@@ -457,6 +467,9 @@ def coco_to_yolo(input_image_folder,
         
     source_image_to_dest_image = {}
     
+    label_files_written = []
+    n_boxes_written = 0
+    
     # TODO: parallelize this loop
     #
     # output_info = images_to_copy[0]
@@ -471,6 +484,7 @@ def coco_to_yolo(input_image_folder,
         
         source_image_to_dest_image[source_image] = dest_image
         
+        # Copy the image if necessary
         if write_output:
             
             os.makedirs(os.path.dirname(dest_image),exist_ok=True)        
@@ -482,17 +496,24 @@ def coco_to_yolo(input_image_folder,
             if (not os.path.isfile(dest_image)) or (overwrite_images):
                 shutil.copyfile(source_image,dest_image)
         
-            bboxes = output_info['bboxes']        
+        bboxes = output_info['bboxes']        
+        
+        # Write the annotation file if necessary
+        #
+        # Only write an annotation file if there are bounding boxes.  Images with 
+        # no .txt files are treated as hard negatives, at least by YOLOv5:
+        #
+        # https://github.com/ultralytics/yolov5/issues/3218
+        #
+        # I think this is also true for images with empty .txt files, but 
+        # I'm using the convention suggested on that issue, i.e. hard 
+        # negatives are expressed as images without .txt files.
+        if len(bboxes) > 0:
             
-            # Only write an annotation file if there are bounding boxes.  Images with 
-            # no .txt files are treated as hard negatives, at least by YOLOv5:
-            #
-            # https://github.com/ultralytics/yolov5/issues/3218
-            #
-            # I think this is also true for images with empty .txt files, but 
-            # I'm using the convention suggested on that issue, i.e. hard 
-            # negatives are expressed as images without .txt files.
-            if len(bboxes) > 0:
+            n_boxes_written += len(bboxes)
+            label_files_written.append(dest_txt)
+            
+            if write_output:
                 
                 with open(dest_txt,'w') as f:
                     
@@ -501,8 +522,7 @@ def coco_to_yolo(input_image_folder,
                         assert len(bbox) == 5
                         s = '{} {} {} {} {}'.format(bbox[0],bbox[1],bbox[2],bbox[3],bbox[4])
                         f.write(s + '\n')
-                        
-        # ...if we're actually writing output
+                            
         
     # ...for each image
     
@@ -510,6 +530,8 @@ def coco_to_yolo(input_image_folder,
     coco_to_yolo_info['class_list_filename'] = class_list_filename
     coco_to_yolo_info['source_image_to_dest_image'] = source_image_to_dest_image
     coco_to_yolo_info['coco_id_to_yolo_id'] = coco_id_to_yolo_id
+    coco_to_yolo_info['label_files_written'] = label_files_written
+    coco_to_yolo_info['n_boxes_written'] = n_boxes_written
     
     return coco_to_yolo_info
 

megadetector/data_management/databases/combine_coco_camera_traps_files.py

@@ -24,8 +24,10 @@ import sys
 
 #%% Merge functions
 
-def combine_cct_files(input_files, output_file=None, require_uniqueness=True,
-                      filename_prefixes=None):                             
+def combine_cct_files(input_files, 
+                      output_file=None, 
+                      require_uniqueness=True,
+                      filename_prefixes=None):
     """
     Merges the list of COCO Camera Traps files [input_files] into a single
     dictionary, optionally writing the result to [output_file].
@@ -33,8 +35,10 @@ def combine_cct_files(input_files, output_file=None, require_uniqueness=True,
     Args:
         input_files (list): paths to CCT .json files
         output_file (str, optional): path to write merged .json file
-        require_uniqueness (bool): whether to require that the images in
+        require_uniqueness (bool, optional): whether to require that the images in
             each input_dict be unique
+        filename_prefixes (dict, optional): dict mapping input filenames to strings
+            that should be prepended to image filenames from that source            
     
     Returns:
         dict: the merged COCO-formatted .json dict

megadetector/data_management/databases/integrity_check_json_db.py

@@ -327,7 +327,7 @@ def integrity_check_json_db(jsonFile, options=None):
                 
         for i_image,result in enumerate(results):
             if result is not None:
-                validation_errors.append(images[i_image]['file_name'],result)
+                validation_errors.append((images[i_image]['file_name'],result))
                             
     # ...for each image
     
@@ -393,7 +393,7 @@ def integrity_check_json_db(jsonFile, options=None):
             elif image['_count'] > 1:
                 nMultiAnnotated += 1
                 
-        print('Found {} unannotated images, {} images with multiple annotations'.format(
+        print('\nFound {} unannotated images, {} images with multiple annotations'.format(
                 nUnannotated,nMultiAnnotated))
         
         if (len(base_dir) > 0) and options.bFindUnusedImages:

megadetector/data_management/lila/generate_lila_per_image_labels.py

@@ -349,7 +349,7 @@ with open(output_file,'w',encoding='utf-8',newline='') as f:
 
 # ...with open()
 
-print('Processed {} datasets'.format(len(metadata_table)))
+print('\nProcessed {} datasets'.format(len(metadata_table)))
 
 
 #%% Read the .csv back
@@ -393,7 +393,7 @@ def check_row(row):
     dataset_name_to_locations[ds_name].add(row['location_id'])
     
 # Faster, but more annoying to debug
-if False:
+if True:
     
     df.progress_apply(check_row, axis=1)
 

megadetector/data_management/lila/test_lila_metadata_urls.py

@@ -31,9 +31,10 @@ os.makedirs(metadata_dir,exist_ok=True)
 md_results_dir = os.path.join(lila_local_base,'md_results')
 os.makedirs(md_results_dir,exist_ok=True)
 
-md_results_keys = ['mdv4_results_raw','mdv5a_results_raw','mdv5b_results_raw','md_results_with_rde']
+md_results_keys = ['mdv4_results_raw','mdv5a_results_raw','mdv5b_results_raw',
+                   'md1000-redwood_results_raw','md_results_with_rde']
 
-preferred_cloud = 'gcp' # 'azure', 'aws'
+preferred_cloud = None # 'gcp' # 'azure', 'aws'
 
 force_download = True
 
@@ -52,7 +53,7 @@ print('Loaded metadata URLs for {} datasets'.format(len(metadata_table)))
 
 #%% Download and extract metadata and MD results for each dataset
 
-# Takes ~60 seconds if everything needs to beo downloaded and unzipped
+# Takes ~60 seconds if everything needs to be downloaded and unzipped
 
 for ds_name in metadata_table.keys():    
 
@@ -88,6 +89,8 @@ url_to_source = {}
 # so we pick a semi-arbitrary image that isn't the first.  How about the 2000th?
 image_index = 2000
 
+# TODO: parallelize this loop
+#
 # ds_name = list(metadata_table.keys())[0]
 for ds_name in metadata_table.keys():
     
@@ -101,13 +104,21 @@ for ds_name in metadata_table.keys():
     with open(json_filename, 'r') as f:
         data = json.load(f)
 
-    image_base_url = metadata_table[ds_name]['image_base_url_' + preferred_cloud]
-    assert not image_base_url.endswith('/')
-    # Download a test image
-    test_image_relative_path = data['images'][image_index]['file_name']
-    test_image_url = image_base_url + '/' + test_image_relative_path
-    
-    url_to_source[test_image_url] = ds_name + ' metadata'
+    if preferred_cloud is not None:
+        clouds = [preferred_cloud]
+    else:
+        clouds = ['gcp','aws','azure']
+        
+    for cloud in clouds:
+        
+        image_base_url = metadata_table[ds_name]['image_base_url_' + cloud]
+        assert not image_base_url.endswith('/')
+        
+        # Download a test image
+        test_image_relative_path = data['images'][image_index]['file_name']
+        test_image_url = image_base_url + '/' + test_image_relative_path
+        
+        url_to_source[test_image_url] = ds_name + ' metadata ({})'.format(cloud)
     
     # Grab an image from the MegaDetector results
     

megadetector/data_management/remap_coco_categories.py

@@ -12,6 +12,7 @@ import os
 import json
 
 from copy import deepcopy
+from megadetector.utils.ct_utils import invert_dictionary
 
 
 #%% Main function
@@ -19,17 +20,27 @@ from copy import deepcopy
 def remap_coco_categories(input_data,
                           output_category_name_to_id,
                           input_category_name_to_output_category_name,
-                          output_file=None):
+                          output_file=None,
+                          allow_unused_categories=False):
     """
     Given a COCO-formatted dataset, remap the categories to a new categories mapping, optionally
     writing the results to a new file.
     
-    output_category_name_to_id is a dict mapping strings to ints.
+    Args:
+        input_data (str or dict): a COCO-formatted dict or a filename.  If it's a dict, it will 
+            be copied, not modified in place.
+        output_category_name_to_id (dict) a dict mapping strings to ints.  Categories not in 
+            this dict will be ignored or will result in errors, depending on allow_unused_categories.
+        input_category_name_to_output_category_name: a dict mapping strings to strings.  
+            Annotations using categories not in this dict will be omitted or will result in 
+            errors, depending on allow_unused_categories.
+        output_file (str, optional): output file to which we should write remapped COCO data
+        allow_unused_categories (bool, optional): should we ignore categories not present in the
+            input/output mappings?  If this is False and we encounter an unmapped category, we'll
+            error.
     
-    input_category_name_to_output_category_name is a dict mapping strings to strings.
-    
-    [input_data] can be a COCO-formatted dict or a filename.  If it's a dict, it will be copied,
-    not modified in place.
+    Returns:
+        dict: COCO-formatted dict
     """
     
     if isinstance(input_data,str):
@@ -48,23 +59,59 @@ def remap_coco_categories(input_data,
     input_category_name_to_input_category_id = {}
     for c in input_data['categories']:
         input_category_name_to_input_category_id[c['name']] = c['id']
-    
+    input_category_id_to_input_category_name = \
+        invert_dictionary(input_category_name_to_input_category_id)
+        
     # Map input IDs --> output IDs
     input_category_id_to_output_category_id = {}
-    for input_name in input_category_name_to_output_category_name.keys():
+    input_category_names = list(input_category_name_to_output_category_name.keys())
+    
+    # input_name = input_category_names[0]
+    for input_name in input_category_names:
+        
         output_name = input_category_name_to_output_category_name[input_name]
         assert output_name in output_category_name_to_id, \
             'No output ID for {} --> {}'.format(input_name,output_name)
         input_id = input_category_name_to_input_category_id[input_name]
         output_id = output_category_name_to_id[output_name]
         input_category_id_to_output_category_id[input_id] = output_id
+    
+    # ...for each category we want to keep
         
+    printed_unused_category_warnings = set()
+    
+    valid_annotations = []
+    
     # Map annotations
     for ann in output_data['annotations']:
-        assert ann['category_id'] in input_category_id_to_output_category_id, \
-            'Unrecognized category ID {}'.format(ann['category_id'])
-        ann['category_id'] = input_category_id_to_output_category_id[ann['category_id']]
         
+        input_category_id = ann['category_id']
+        if input_category_id not in input_category_id_to_output_category_id:
+            if allow_unused_categories:
+                if input_category_id not in printed_unused_category_warnings:
+                    printed_unused_category_warnings.add(input_category_id)            
+                    input_category_name = \
+                        input_category_id_to_input_category_name[input_category_id]
+                    s = 'Skipping unmapped category ID {} ({})'.format(
+                        input_category_id,input_category_name)
+                    print(s)
+                continue
+            else:
+                s = 'Unmapped category ID {}'.format(input_category_id)
+                raise ValueError(s)        
+        output_category_id = input_category_id_to_output_category_id[input_category_id]
+        ann['category_id'] = output_category_id
+        valid_annotations.append(ann)        
+        
+    # ...for each annotation
+    
+    # The only reason annotations should get excluded is the case where we allow
+    # unused categories
+    if not allow_unused_categories:
+        assert len(valid_annotations) == len(output_data['annotations'])
+    
+    output_data['annotations'] = valid_annotations
+    
     # Update the category list
     output_categories = []
     for output_name in output_category_name_to_id:
@@ -78,6 +125,8 @@ def remap_coco_categories(input_data,
             
     return input_data
 
+# ...def remap_coco_categories(...)
+
 
 #%% Command-line driver
 

megadetector/data_management/yolo_to_coco.py

@@ -34,7 +34,7 @@ def _filename_to_image_id(fn):
     return fn.replace(' ','_').replace('\\','/')
 
 
-def _process_image(fn_abs,input_folder,category_id_to_name):
+def _process_image(fn_abs,input_folder,category_id_to_name,label_folder):
     """
     Internal support function for processing one image's labels.
     """
@@ -42,8 +42,8 @@ def _process_image(fn_abs,input_folder,category_id_to_name):
     # Create the image object for this image
     #
     # Always use forward slashes in image filenames and IDs
-    fn_relative = os.path.relpath(fn_abs,input_folder).replace('\\','/')
-    image_id = _filename_to_image_id(fn_relative)
+    image_fn_relative = os.path.relpath(fn_abs,input_folder).replace('\\','/')
+    image_id = _filename_to_image_id(image_fn_relative)
     
     # This is done in a separate loop now
     #
@@ -53,7 +53,7 @@ def _process_image(fn_abs,input_folder,category_id_to_name):
     # image_ids.add(image_id)
     
     im = {}
-    im['file_name'] = fn_relative
+    im['file_name'] = image_fn_relative
     im['id'] = image_id
     
     annotations_this_image = []
@@ -65,14 +65,20 @@ def _process_image(fn_abs,input_folder,category_id_to_name):
         im['height'] = im_height
         im['error'] = None
     except Exception as e:
-        print('Warning: error reading {}:\n{}'.format(fn_relative,str(e)))
+        print('Warning: error reading {}:\n{}'.format(image_fn_relative,str(e)))
         im['width'] = -1
         im['height'] = -1
         im['error'] = str(e)
         return (im,annotations_this_image)
         
     # Is there an annotation file for this image?
-    annotation_file = os.path.splitext(fn_abs)[0] + '.txt'
+    if label_folder is not None:
+        assert input_folder in fn_abs
+        label_file_abs_base = fn_abs.replace(input_folder,label_folder)
+    else:
+        label_file_abs_base = fn_abs
+    
+    annotation_file = os.path.splitext(label_file_abs_base)[0] + '.txt'
     if not os.path.isfile(annotation_file):
         annotation_file = os.path.splitext(fn_abs)[0] + '.TXT'
     
@@ -270,9 +276,14 @@ def validate_label_file(label_file,category_id_to_name=None,verbose=False):
 # ...def validate_label_file(...)
 
     
-def validate_yolo_dataset(input_folder, class_name_file, n_workers=1, pool_type='thread', verbose=False):
+def validate_yolo_dataset(input_folder, 
+                          class_name_file, 
+                          n_workers=1, 
+                          pool_type='thread', 
+                          verbose=False):
     """
-    Verifies all the labels in a YOLO dataset folder.  
+    Verifies all the labels in a YOLO dataset folder.  Does not yet support the case where the 
+    labels and images are in different folders (yolo_to_coco() supports this).
     
     Looks for:
         
@@ -396,14 +407,17 @@ def yolo_to_coco(input_folder,
                  recursive=True,
                  exclude_string=None,
                  include_string=None,
-                 overwrite_handling='overwrite'):
+                 overwrite_handling='overwrite',
+                 label_folder=None):
     """
     Converts a YOLO-formatted dataset to a COCO-formatted dataset.
     
     All images will be assigned an "error" value, usually None.    
     
     Args:
-        input_folder (str): the YOLO dataset folder to validate
+        input_folder (str): the YOLO dataset folder to convert.  If the image and label 
+            folders are different, this is the image folder, and [label_folder] is the
+            label folder.
         class_name_file (str or list): a list of classes, a flat text file, or a yolo 
             dataset.yml/.yaml file.  If it's a dataset.yml file, that file should point to 
             input_folder as the base folder, though this is not explicitly checked.
@@ -432,6 +446,7 @@ def yolo_to_coco(input_folder,
         include_string (str, optional): include only images whose filename contains a string
         overwrite_handling (bool, optional): behavior if output_file exists ('load', 'overwrite', or 
             'error')
+        label_folder (str, optional): label folder, if different from the image folder
     
     Returns:
         dict: COCO-formatted data, the same as what's written to [output_file]
@@ -439,6 +454,8 @@ def yolo_to_coco(input_folder,
     
     ## Validate input
     
+    input_folder = input_folder.replace('\\','/')
+    
     assert os.path.isdir(input_folder)
     assert os.path.isfile(class_name_file)
     
@@ -487,6 +504,7 @@ def yolo_to_coco(input_folder,
     print('Enumerating images...')
     
     image_files_abs = find_images(input_folder,recursive=recursive,convert_slashes=True)
+    assert not any(['\\' in fn for fn in image_files_abs])
 
     n_files_original = len(image_files_abs)
     
@@ -516,8 +534,14 @@ def yolo_to_coco(input_folder,
     
     if not allow_images_without_label_files:
         print('Verifying that label files exist')
+        # image_file_abs = image_files_abs[0]
         for image_file_abs in tqdm(image_files_abs):
-            label_file_abs = os.path.splitext(image_file_abs)[0] + '.txt'
+            if label_folder is not None:
+                assert input_folder in image_file_abs
+                label_file_abs_base = image_file_abs.replace(input_folder,label_folder)
+            else:
+                label_file_abs_base = image_file_abs
+            label_file_abs = os.path.splitext(label_file_abs_base)[0] + '.txt'
             assert os.path.isfile(label_file_abs), \
                 'No annotation file for {}'.format(image_file_abs)
     
@@ -528,7 +552,7 @@ def yolo_to_coco(input_folder,
     
     for fn_abs in tqdm(image_files_abs):
         
-        fn_relative = os.path.relpath(fn_abs,input_folder)
+        fn_relative = os.path.relpath(fn_abs,input_folder).replace('\\','/')
         image_id = _filename_to_image_id(fn_relative)
         assert image_id not in image_ids, \
             'Oops, you have hit a very esoteric case where you have the same filename ' + \
@@ -543,8 +567,12 @@ def yolo_to_coco(input_folder,
     if n_workers <= 1:
         
         image_results = []        
+        # fn_abs = image_files_abs[0]
         for fn_abs in tqdm(image_files_abs):                
-            image_results.append(_process_image(fn_abs,input_folder,category_id_to_name))
+            image_results.append(_process_image(fn_abs,
+                                                input_folder,
+                                                category_id_to_name,
+                                                label_folder))
             
     else:
         
@@ -557,8 +585,10 @@ def yolo_to_coco(input_folder,
         
         print('Starting a {} pool of {} workers'.format(pool_type,n_workers))
         
-        p = partial(_process_image,input_folder=input_folder,
-                    category_id_to_name=category_id_to_name)
+        p = partial(_process_image,
+                    input_folder=input_folder,
+                    category_id_to_name=category_id_to_name,
+                    label_folder=label_folder)
         image_results = list(tqdm(pool.imap(p, image_files_abs),
                                   total=len(image_files_abs)))