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

megadetector/data_management/read_exif.py

@@ -210,6 +210,8 @@ def read_pil_exif(im,options=None):
     if exif_info is None:
         return exif_tags
 
+    # Read all standard EXIF tags; if necessary, we'll filter later to a restricted
+    # list of tags.
     for k, v in exif_info.items():
         assert isinstance(k,str) or isinstance(k,int), \
             'Invalid EXIF key {}'.format(str(k))
@@ -221,6 +223,7 @@ def read_pil_exif(im,options=None):
 
     exif_ifd_tags = _get_exif_ifd(exif_info)
 
+    # Read tags that are only available via offset
     for k in exif_ifd_tags.keys():
         v = exif_ifd_tags[k]
         if k in exif_tags:
@@ -266,7 +269,7 @@ def read_pil_exif(im,options=None):
 
             # Convert to strings, e.g. 'GPSTimeStamp'
             gps_info = {}
-            for int_tag,v in enumerate(gps_info_raw.keys()):
+            for int_tag,v in gps_info_raw.items():
                 assert isinstance(int_tag,int)
                 if int_tag in ExifTags.GPSTAGS:
                     gps_info[ExifTags.GPSTAGS[int_tag]] = v
@@ -276,11 +279,15 @@ def read_pil_exif(im,options=None):
             exif_tags['GPSInfo'] = gps_info
 
         except Exception as e:
+
             if options.verbose:
                 print('Warning: error reading GPS info: {}'.format(str(e)))
 
     # ...if we think there might be GPS tags in this image
 
+    # Filter tags if necessary
+    exif_tags = _filter_tags(exif_tags,options)
+
     return exif_tags
 
 # ...read_pil_exif()
@@ -332,25 +339,68 @@ def _filter_tags(tags,options):
     dict.
     """
 
+    ## No-op cases
+
     if options is None:
         return tags
-    if options.tags_to_include is None and options.tags_to_exclude is None:
+
+    if (options.tags_to_include is None) and (options.tags_to_exclude is None):
         return tags
+
+    ## If we're including specific tags
+
     if options.tags_to_include is not None:
-        assert options.tags_to_exclude is None, "tags_to_include and tags_to_exclude are incompatible"
+
+        assert options.tags_to_exclude is None, \
+            "tags_to_include and tags_to_exclude are incompatible"
+
+        tags_to_include = options.tags_to_include
+
+        if isinstance(tags_to_include,str):
+
+            # Special case:return all tags
+            if tags_to_include == 'all':
+                return tags
+
+            # Otherwise convert string to list
+            tags_to_include = tags_to_include.split(',')
+
+        # Case-insensitive matching
+        tags_to_include = [s.lower().strip() for s in tags_to_include]
+
         tags_to_return = {}
+
         for tag_name in tags.keys():
-            if tag_name in options.tags_to_include:
+            if str(tag_name).strip().lower() in tags_to_include:
                 tags_to_return[tag_name] = tags[tag_name]
+
         return tags_to_return
+
+    ## If we're excluding specific tags
+
     if options.tags_to_exclude is not None:
-        assert options.tags_to_include is None, "tags_to_include and tags_to_exclude are incompatible"
+
+        assert options.tags_to_include is None, \
+            "tags_to_include and tags_to_exclude are incompatible"
+
+        tags_to_exclude = options.tags_to_exclude
+
+        # Convert string to list
+        if isinstance(tags_to_exclude,str):
+            tags_to_exclude = tags_to_exclude.split(',')
+
+        # Case-insensitive matching
+        tags_to_exclude = [s.lower().strip() for s in tags_to_exclude]
+
         tags_to_return = {}
         for tag_name in tags.keys():
-            if tag_name not in options.tags_to_exclude:
+            if str(tag_name).strip().lower() not in tags_to_exclude:
                 tags_to_return[tag_name] = tags[tag_name]
+
         return tags_to_return
 
+# ...def _filter_tags(...)
+
 
 def read_exif_tags_for_image(file_path,options=None):
     """
@@ -381,8 +431,10 @@ def read_exif_tags_for_image(file_path,options=None):
 
         except Exception as e:
             if options.verbose:
-                print('Read failure for image {}: {}'.format(
+                print('PIL EXIF read failure for image {}: {}'.format(
                     file_path,str(e)))
+                import traceback
+                traceback.print_exc()
             result['status'] = 'read_failure'
             result['error'] = str(e)
 
@@ -582,9 +634,10 @@ def _populate_exif_for_images(image_base,images,options=None):
             results = list(tqdm(pool.imap(partial(_populate_exif_data,image_base=image_base,
                                             options=options),images),total=len(images)))
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for EXIF extraction")
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print("Pool closed and joined for EXIF extraction")
 
     return results
 
@@ -691,6 +744,7 @@ def read_exif_from_folder(input_folder,
         list: list of dicts, each of which contains EXIF information for one images.  Fields include at least:
             * 'file_name': the relative path to the image
             * 'exif_tags': a dict of EXIF tags whose exact format depends on [options.processing_library].
+            * 'status' and 'error': only populated when reading EXIF information for an image fails
     """
 
     if options is None:
@@ -698,9 +752,11 @@ def read_exif_from_folder(input_folder,
 
     # Validate options
     if options.tags_to_include is not None:
-        assert options.tags_to_exclude is None, "tags_to_include and tags_to_exclude are incompatible"
+        assert options.tags_to_exclude is None, \
+            "tags_to_include and tags_to_exclude are incompatible"
     if options.tags_to_exclude is not None:
-        assert options.tags_to_include is None, "tags_to_include and tags_to_exclude are incompatible"
+        assert options.tags_to_include is None, \
+            "tags_to_include and tags_to_exclude are incompatible"
 
     if input_folder is None:
         input_folder = ''
@@ -724,7 +780,7 @@ def read_exif_from_folder(input_folder,
             print('Could not write to file {}'.format(output_file))
             raise
 
-    if options.processing_library == 'exif':
+    if options.processing_library == 'exiftool':
         assert is_executable(options.exiftool_command_name), 'exiftool not available'
 
     if filenames is None:

megadetector/data_management/remap_coco_categories.py

@@ -126,7 +126,7 @@ def remap_coco_categories(input_data,
         with open(output_file,'w') as f:
             json.dump(output_data,f,indent=1)
 
-    return input_data
+    return output_data
 
 # ...def remap_coco_categories(...)
 

megadetector/data_management/remove_exif.py

@@ -13,9 +13,10 @@ included in package-level dependency lists.  YMMV.
 #%% Imports and constants
 
 import os
-import glob
 import argparse
 
+from megadetector.utils.path_utils import recursive_file_list
+
 from multiprocessing.pool import Pool as Pool
 from tqdm import tqdm
 
@@ -77,7 +78,10 @@ def remove_exif(image_base_folder,recursive=True,n_processes=1):
 
     assert os.path.isdir(image_base_folder), \
         'Could not find folder {}'.format(image_base_folder)
-    all_files = [f for f in glob.glob(image_base_folder+ "*/**", recursive=recursive)]
+    all_files = recursive_file_list(image_base_folder,
+                                    recursive=True,
+                                    return_relative_paths=False,
+                                    convert_slashes=True)
     image_files = [s for s in all_files if \
                    (s.lower().endswith('.jpg') or s.lower().endswith('.jpeg'))]
 
@@ -98,9 +102,10 @@ def remove_exif(image_base_folder,recursive=True,n_processes=1):
             pool = Pool(n_processes)
             _ = list(tqdm(pool.imap(remove_exif_from_image,image_files),total=len(image_files)))
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for EXIF removal")
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print("Pool closed and joined for EXIF removal")
 
 # ...remove_exif(...)
 

megadetector/data_management/rename_images.py

@@ -28,8 +28,9 @@ def rename_images(input_folder,
                   read_exif_options=None,
                   n_copy_workers=8):
     """
-    For the given image struct in COCO format and associated list of annotations, reformats the
-    detections into labelme format.
+    Copies images from a possibly-nested folder structure to a flat folder structure,
+    including EXIF timestamps in each filename.  Loosely equivalent to camtrapR's
+    imageRename() function.
 
     Args:
         input_folder (str): the folder to search for images, always recursive
@@ -56,8 +57,9 @@ def rename_images(input_folder,
     if read_exif_options is None:
         read_exif_options = ReadExifOptions()
 
-    read_exif_options.tags_to_include = ['DateTime','Model','Make','ExifImageWidth','ExifImageHeight','DateTime',
-                                         'DateTimeOriginal']
+    read_exif_options.tags_to_include = ['DateTime','Model',
+                                         'Make','ExifImageWidth',
+                                         'ExifImageHeight','DateTimeOriginal']
     read_exif_options.verbose = False
 
     exif_info = read_exif_from_folder(input_folder=input_folder,
@@ -104,17 +106,21 @@ def rename_images(input_folder,
     if not dry_run:
 
         input_fn_abs_to_output_fn_abs = {}
+
         for input_fn_relative in input_fn_relative_to_output_fn_relative:
+
             output_fn_relative = input_fn_relative_to_output_fn_relative[input_fn_relative]
             input_fn_abs = os.path.join(input_folder,input_fn_relative)
             output_fn_abs = os.path.join(output_folder,output_fn_relative)
             input_fn_abs_to_output_fn_abs[input_fn_abs] = output_fn_abs
 
-            parallel_copy_files(input_file_to_output_file=input_fn_abs_to_output_fn_abs,
-                                max_workers=n_copy_workers,
-                                use_threads=True,
-                                overwrite=True,
-                                verbose=verbose)
+        parallel_copy_files(input_file_to_output_file=input_fn_abs_to_output_fn_abs,
+                            max_workers=n_copy_workers,
+                            use_threads=True,
+                            overwrite=True,
+                            verbose=verbose)
+
+    # ...if this is not a dry run
 
     return input_fn_relative_to_output_fn_relative
 
@@ -129,13 +135,14 @@ if False:
 
     #%% Configure options
 
-    input_folder = r'G:\camera_traps\camera_trap_videos\2024.05.25\cam3'
-    output_folder = r'G:\camera_traps\camera_trap_videos\2024.05.25\cam3_flat'
+    input_folder = r'G:\camera_traps\camera_trap_images\2018.05.04'
+    output_folder = r'g:\temp\rename-test-out'
     dry_run = False
     verbose = True
     read_exif_options = ReadExifOptions()
-    read_exif_options.tags_to_include = ['DateTime','Model','Make','ExifImageWidth','ExifImageHeight','DateTime',
-                               'DateTimeOriginal']
+    read_exif_options.tags_to_include = ['DateTime','Model','Make',
+                                         'ExifImageWidth','ExifImageHeight',
+                                         'DateTimeOriginal']
     read_exif_options.n_workers = 8
     read_exif_options.verbose = verbose
     n_copy_workers = 8

megadetector/data_management/resize_coco_dataset.py

@@ -65,7 +65,9 @@ def _process_single_image_for_resize(image_data,
             return None, None
 
     output_fn_abs = os.path.join(output_folder, input_fn_relative)
-    os.makedirs(os.path.dirname(output_fn_abs), exist_ok=True)
+    output_dir = os.path.dirname(output_fn_abs)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir, exist_ok=True)
 
     if verbose:
         print('Resizing {} to {}'.format(input_fn_abs,output_fn_abs))
@@ -235,6 +237,9 @@ def resize_coco_dataset(input_folder,
             processed_results.append(result)
 
     else:
+
+        pool = None
+
         try:
 
             assert pool_type in ('process', 'thread'), f'Illegal pool type {pool_type}'
@@ -257,9 +262,10 @@ def resize_coco_dataset(input_folder,
                                         desc=f"Resizing images with {pool_type} pool"))
 
         finally:
-            pool.close()
-            pool.join()
-            print(f"{pool_type.capitalize()} pool closed and joined.")
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print('Pool closed and joined for COCO dataset resizing')
 
     new_images_list = []
     new_annotations_list = []

megadetector/data_management/speciesnet_to_md.py

@@ -33,9 +33,9 @@ def main(): # noqa
 
     args = parser.parse_args()
 
-    generate_md_results_from_predictions_json(args.predictions_json_file,
-                                              args.md_results_file,
-                                              args.base_folder)
+    generate_md_results_from_predictions_json(predictions_json_file=args.predictions_json_file,
+                                              md_results_file=args.md_results_file,
+                                              base_folder=args.base_folder)
 
 if __name__ == '__main__':
     main()

megadetector/data_management/yolo_output_to_md_output.py

@@ -110,6 +110,8 @@ def read_classes_from_yolo_dataset_file(fn):
 
     return category_id_to_name
 
+# ...def def read_classes_from_yolo_dataset_file(...)
+
 
 def yolo_json_output_to_md_output(yolo_json_file,
                                   image_folder,
@@ -187,7 +189,7 @@ def yolo_json_output_to_md_output(yolo_json_file,
     for image_id in image_id_to_relative_path:
         relative_path = image_id_to_relative_path[image_id]
         assert relative_path not in image_file_relative_to_image_id, \
-            'Duplication image IDs in YOLO output conversion for image {}'.format(relative_path)
+            'Duplicate image IDs in YOLO output conversion for image {}'.format(relative_path)
         image_file_relative_to_image_id[relative_path] = image_id
 
     with open(yolo_json_file,'r') as f:

megadetector/data_management/yolo_to_coco.py

@@ -23,6 +23,7 @@ from megadetector.utils.path_utils import find_images
 from megadetector.utils.path_utils import recursive_file_list
 from megadetector.utils.path_utils import find_image_strings
 from megadetector.utils.ct_utils import invert_dictionary
+from megadetector.utils.ct_utils import write_json
 from megadetector.visualization.visualization_utils import open_image
 from megadetector.data_management.yolo_output_to_md_output import \
     read_classes_from_yolo_dataset_file
@@ -175,8 +176,8 @@ def load_yolo_class_list(class_name_file):
 
         with open(class_name_file,'r') as f:
             lines = f.readlines()
+        lines = [s.strip() for s in lines]
         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
@@ -189,7 +190,7 @@ def load_yolo_class_list(class_name_file):
                     class_name_file))
 
         category_id_to_name = {}
-        for i_category_id,category_name in enumerate(class_names):
+        for i_category_id,category_name in enumerate(lines):
             assert len(category_name) > 0
             category_id_to_name[i_category_id] = category_name
 
@@ -387,9 +388,10 @@ def validate_yolo_dataset(input_folder,
             label_results = list(tqdm(pool.imap(p, label_files),
                                     total=len(label_files)))
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for label file validation")
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print("Pool closed and joined for label file validation")
 
     assert len(label_results) == len(label_files)
 
@@ -470,7 +472,8 @@ def yolo_to_coco(input_folder,
     input_folder = input_folder.replace('\\','/')
 
     assert os.path.isdir(input_folder)
-    assert os.path.isfile(class_name_file)
+    if isinstance(class_name_file,str):
+        assert os.path.isfile(class_name_file)
 
     assert empty_image_handling in \
         ('no_annotations','empty_annotations','skip','error'), \
@@ -591,19 +594,26 @@ def yolo_to_coco(input_folder,
 
         assert pool_type in ('process','thread'), 'Illegal pool type {}'.format(pool_type)
 
-        if pool_type == 'thread':
-            pool = ThreadPool(n_workers)
-        else:
-            pool = Pool(n_workers)
+        pool = None
+        try:
+            if pool_type == 'thread':
+                pool = ThreadPool(n_workers)
+            else:
+                pool = Pool(n_workers)
 
-        print('Starting a {} pool of {} workers'.format(pool_type,n_workers))
+            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,
-                    label_folder=label_folder)
-        image_results = list(tqdm(pool.imap(p, image_files_abs),
-                                  total=len(image_files_abs)))
+            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)))
+        finally:
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print('Pool closed and joined for YOLO to COCO conversion')
 
 
     assert len(image_results) == len(image_files_abs)
@@ -674,8 +684,7 @@ def yolo_to_coco(input_folder,
 
     if output_file is not None:
         print('Writing to {}'.format(output_file))
-        with open(output_file,'w') as f:
-            json.dump(d,f,indent=1)
+        write_json(output_file,d)
 
     return d
 

megadetector/detection/change_detection.py

@@ -262,7 +262,7 @@ def detect_motion(prev_image_path,
     curr_image = cv2.imread(str(curr_image_path))
 
     if curr_image is None:
-        print(f"Could not read image: {curr_image_path}")
+        print(f'Could not read image: {curr_image_path}')
         return to_return, motion_state
 
     # Read previous image if available (used for frame diff mode)
@@ -270,7 +270,7 @@ def detect_motion(prev_image_path,
     if prev_image_path is not None:
         prev_image = cv2.imread(str(prev_image_path))
         if prev_image is None:
-            print(f"Could not read image: {prev_image_path}")
+            print(f'Could not read image: {prev_image_path}')
             return to_return, motion_state
 
 
@@ -470,10 +470,10 @@ def process_camera_folder(folder_path, options=None):
     image_files = find_images(folder_path, recursive=True, return_relative_paths=False)
 
     if len(image_files) == 0:
-        print(f'"No images found in {folder_path}"')
+        print(f'No images found in {folder_path}')
         return pd.DataFrame()
 
-    print(f"Processing {len(image_files)} images in {camera_name}")
+    print(f'Processing {len(image_files)} images in {camera_name}')
 
     # Initialize results
     results = []
@@ -527,7 +527,7 @@ def process_camera_folder(folder_path, options=None):
         diff_percentage = motion_result['diff_percentage']
 
         # Format regions as semicolon-separated list of "x,y,w,h"
-        regions_str = ';'.join([f"{x},{y},{w},{h}" for x, y, w, h in regions])
+        regions_str = ';'.join([f'{x},{y},{w},{h}' for x, y, w, h in regions])
 
         # Add result for current image
         results.append({
@@ -587,9 +587,9 @@ def process_folders(folders, options=None, output_csv=None):
                 try:
                     folder_results = future.result()
                     all_results.append(folder_results)
-                    print(f"Finished processing {folder}")
+                    print(f'Finished processing {folder}')
                 except Exception as e:
-                    print(f"Error processing {folder}: {e}")
+                    print(f'Error processing {folder}: {e}')
 
     # Combine all results
     if all_results:
@@ -598,7 +598,7 @@ def process_folders(folders, options=None, output_csv=None):
         # Save to CSV if requested
         if output_csv:
             combined_results.to_csv(output_csv, index=False)
-            print(f"Results saved to {output_csv}")
+            print(f'Results saved to {output_csv}')
 
         return combined_results
     else:
@@ -656,7 +656,7 @@ def create_change_previews(motion_results, output_folder, num_samples=10, random
         prev_image = cv2.imread(prev_image_path)
 
         if curr_image is None or prev_image is None:
-            print(f"Could not read images: {prev_image_path} or {curr_image_path}")
+            print(f'Could not read images: {prev_image_path} or {curr_image_path}')
             continue
 
         # Ensure that both images have the same dimensions
@@ -675,7 +675,7 @@ def create_change_previews(motion_results, output_folder, num_samples=10, random
         # Add details at the bottom
         camera = row['camera']
         diff_pct = row['diff_percentage']
-        info_text = f"Camera: {camera} | Change: {diff_pct:.2f}%"
+        info_text = f'Camera: {camera} | Change: {diff_pct:.2f}%'
         cv2.putText(combined, info_text, (10, combined.shape[0] - 10), font, 0.7, (0, 255, 0), 2)
 
         # Draw bounding boxes on the 'after' image if regions exist
@@ -690,12 +690,12 @@ def create_change_previews(motion_results, output_folder, num_samples=10, random
                                     (curr_image.shape[1] + x + w, y + h),
                                     (0, 0, 255), 2)
                     except ValueError:
-                        print(f"Invalid region format: {region}")
+                        print(f'Invalid region format: {region}')
 
         # Save the combined image
         camera_name = Path(curr_image_path).parent.name
         image_name = Path(curr_image_path).name
-        output_path = output_folder / f"preview_{camera_name}_{image_name}"
+        output_path = output_folder / f'preview_{camera_name}_{image_name}'
         cv2.imwrite(str(output_path), combined)
 
         preview_paths.append(str(output_path))
@@ -708,7 +708,11 @@ def create_change_previews(motion_results, output_folder, num_samples=10, random
 
 #%% Command-line driver
 
-def main(): # noqa
+def main():
+    """
+    Command-line driver
+    """
+
     parser = argparse.ArgumentParser(description='Detect motion in timelapse camera images')
     parser.add_argument('--root_dir', required=True, help='Root directory containing camera folders')
     parser.add_argument('--output_csv', default=None, help='Optional output CSV file')
@@ -801,7 +805,7 @@ def main(): # noqa
     root_dir = Path(args.root_dir)
     camera_folders = [f for f in root_dir.iterdir() if f.is_dir()]
 
-    print(f"Found {len(camera_folders)} camera folders")
+    print(f'Found {len(camera_folders)} camera folders')
 
     # Process all folders
     results = process_folders(
@@ -817,16 +821,20 @@ def main(): # noqa
             args.preview_folder,
             num_samples=args.num_previews
         )
-        print(f"Created {len(preview_paths)} preview images in {args.preview_folder}")
+        print(f'Created {len(preview_paths)} preview images in {args.preview_folder}')
 
-    print("Motion detection completed")
+    print('Motion detection completed')
 
     # Display summary
     motion_detected_count = results['motion_detected'].sum()
     total_images = len(results)
-    print(f"Motion detected in {motion_detected_count} out of {total_images} images "
-          f"({motion_detected_count/total_images*100:.2f}%)")
+    if total_images > 0:
+        print(f'Motion detected in {motion_detected_count} out of {total_images} images '
+              f'({motion_detected_count/total_images*100:.2f}%)')
+    else:
+        print('No images were processed')
 
+# ...def main(...)
 
 if __name__ == "__main__":
     main()

megadetector/detection/process_video.py

@@ -303,7 +303,7 @@ def options_to_command(options):
     if options.verbose:
         cmd += ' --verbose'
     if options.detector_options is not None and len(options.detector_options) > 0:
-        cmd += '--detector_options {}'.format(dict_to_kvp_list(options.detector_options))
+        cmd += ' --detector_options {}'.format(dict_to_kvp_list(options.detector_options))
 
     return cmd
 

megadetector/detection/pytorch_detector.py

@@ -112,9 +112,9 @@ def _get_model_type_for_model(model_file,
             print('Warning: model type from model version is {}, from file metadata is {}'.format(
                 model_type_from_model_version,model_type_from_model_file_metadata))
             if prefer_model_type_source == 'table':
-                model_type = model_type_from_model_file_metadata
-            else:
                 model_type = model_type_from_model_version
+            else:
+                model_type = model_type_from_model_file_metadata
 
     elif model_type_from_model_file_metadata is not None:
 
@@ -373,7 +373,7 @@ def _initialize_yolo_imports(model_type='yolov5',
         except Exception:
 
             print('It looks like you are trying to run a model that requires the ultralytics package, '
-                  'but the ultralytics package is not installed, but .  For licensing reasons, this '
+                  'but the ultralytics package is not installed.  For licensing reasons, this '
                   'is not installed by default with the MegaDetector Python package.  Run '
                   '"pip install ultralytics" to install it, and try again.')
             raise
@@ -1314,8 +1314,8 @@ class PTDetector:
 
         assert isinstance(pred, list)
         assert len(pred) == len(batch_metadata), \
-            print('Mismatch between prediction length {} and batch size {}'.format(
-                   len(pred),len(batch_metadata)))
+            'Mismatch between prediction length {} and batch size {}'.format(
+                   len(pred),len(batch_metadata))
 
         # Process each image's detections
         for i_image, det in enumerate(pred):