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

megadetector/postprocessing/classification_postprocessing.py

@@ -13,6 +13,7 @@ Functions for postprocessing species classification results, particularly:
 
 #%% Constants and imports
 
+import os
 import json
 import copy
 
@@ -20,10 +21,18 @@ from collections import defaultdict
 from tqdm import tqdm
 
 from megadetector.utils.ct_utils import is_list_sorted
+from megadetector.utils.ct_utils import sort_dictionary_by_value
+from megadetector.utils.ct_utils import sort_dictionary_by_key
+from megadetector.utils.ct_utils import invert_dictionary
+
 from megadetector.utils.wi_utils import clean_taxonomy_string
 from megadetector.utils.wi_utils import taxonomy_level_index
 from megadetector.utils.wi_utils import taxonomy_level_string_to_index
-from megadetector.utils.ct_utils import sort_dictionary_by_value
+
+from megadetector.utils.wi_utils import non_taxonomic_prediction_strings
+from megadetector.utils.wi_utils import human_prediction_string
+from megadetector.utils.wi_utils import animal_prediction_string
+from megadetector.utils.wi_utils import blank_prediction_string
 
 
 #%% Options classes
@@ -140,22 +149,34 @@ def _sort_images_by_time(images):
     return sorted(images, key = lambda im: im['datetime'])        
 
 
-def _count_detections_by_category(detections,options):
+def count_detections_by_classification_category(detections,options=None):
     """
-    Count the number of instances of each category in the detections list
+    Count the number of instances of each classification category in the detections list
     [detections] that have an above-threshold detection.  Sort results in descending 
     order by count.  Returns a dict mapping category ID --> count.  If no detections
     are above threshold, returns an empty dict.
     
-    Assumes that if the 'classifications' field is present for a detection, it has
-    length 1, i.e. that non-top classifications have already been removed.
+    Only processes the top classification for each detection.
+
+    Args:
+        detections: detections list
+        options (ClassificationSmoothingOptions, optional): see ClassificationSmoothingOptions
+
+    Returns:
+        dict mapping above-threshold category IDs to counts
     """
     
+    if detections is None or len(detections) == 0:
+        return {}
+    
+    if options is None:
+        options = ClassificationSmoothingOptions()
+
     category_to_count = defaultdict(int)
     
     for det in detections:
         if ('classifications' in det) and (det['conf'] >= options.detection_confidence_threshold):
-            assert len(det['classifications']) == 1
+            # assert len(det['classifications']) == 1
             c = det['classifications'][0]
             if c[1] >= options.classification_confidence_threshold:
                 category_to_count[c[0]] += 1            
@@ -167,9 +188,16 @@ def _count_detections_by_category(detections,options):
     return category_to_count
 
 
-def _get_description_string(category_to_count,classification_descriptions):
+def get_classification_description_string(category_to_count,classification_descriptions):
     """
     Return a string summarizing the image content according to [category_to_count].
+
+    Args:
+        category_to_count (dict): a dict mapping category IDs to counts
+        classification_descriptions (dict): a dict mapping category IDs to description strings
+
+    Returns:
+        string: a description of this image's content, e.g. "rabbit (4), human (1)"
     """
     
     category_strings = []
@@ -202,7 +230,7 @@ def _print_counts_with_names(category_to_count,classification_descriptions):
     
 def _prepare_results_for_smoothing(input_file,options):
     """
-    Load results from [input_file] if necessary, prepare category descrptions 
+    Load results from [input_file] if necessary, prepare category descriptions 
     for smoothing.  Adds pre-smoothing descriptions to every image if the options
     say we're supposed to do that.
     """
@@ -280,10 +308,10 @@ def _prepare_results_for_smoothing(input_file,options):
                 continue
             
             detections = im['detections']        
-            category_to_count = _count_detections_by_category(detections, options)
+            category_to_count = count_detections_by_classification_category(detections, options)
                     
             im['pre_smoothing_description'] = \
-                _get_description_string(category_to_count, classification_descriptions)
+                get_classification_description_string(category_to_count, classification_descriptions)
     
     
     return {
@@ -316,9 +344,9 @@ def _smooth_classifications_for_list_of_detections(detections,
     
     ## Count the number of instances of each category in this image
     
-    category_to_count = _count_detections_by_category(detections, options)
+    category_to_count = count_detections_by_classification_category(detections, options)
     # _print_counts_with_names(category_to_count,classification_descriptions)
-    # _get_description_string(category_to_count, classification_descriptions)
+    # get_classification_description_string(category_to_count, classification_descriptions)
         
     if len(category_to_count) <= 1:
         return None
@@ -351,7 +379,7 @@ def _smooth_classifications_for_list_of_detections(detections,
             
     if verbose_debug_enabled:
         _print_counts_with_names(category_to_count,classification_descriptions)
-        import pdb; pdb.set_trace()
+        from IPython import embed; embed()
     
     
     ## Possibly change "other" classifications to the most common category
@@ -377,6 +405,11 @@ def _smooth_classifications_for_list_of_detections(detections,
             if (c[1] >= options.classification_confidence_threshold) and \
                (c[0] in other_category_ids):
                     
+                if verbose_debug_enabled:
+                    print('Replacing {} with {}'.format(
+                        classification_descriptions[c[0]],
+                        classification_descriptions[c[1]]))
+                    
                 n_other_classifications_changed_this_image += 1
                 c[0] = most_common_category
                                     
@@ -385,11 +418,14 @@ def _smooth_classifications_for_list_of_detections(detections,
         # ...for each detection
                 
     # ...if we should overwrite all "other" classifications
+
+    if verbose_debug_enabled:
+        print('Made {} other changes'.format(n_other_classifications_changed_this_image))
     
     
     ## Re-count
     
-    category_to_count = _count_detections_by_category(detections, options)
+    category_to_count = count_detections_by_classification_category(detections, options)
     # _print_counts_with_names(category_to_count,classification_descriptions)    
     keys = list(category_to_count.keys())
     max_count = category_to_count[keys[0]]    
@@ -399,13 +435,18 @@ def _smooth_classifications_for_list_of_detections(detections,
     
     ## Possibly change some non-dominant classifications to the dominant category
     
+    process_taxonomic_rules = \
+        (classification_descriptions_clean is not None) and \
+        (len(classification_descriptions_clean) > 0) and \
+        (len(category_to_count) > 1)
+            
     n_detections_flipped_this_image = 0
     
     # Don't do this if the most common category is an "other" category, or 
     # if we don't have enough of the most common category
     if (most_common_category not in other_category_ids) and \
        (max_count >= options.min_detections_to_overwrite_secondary):
-        
+                
         # i_det = 0; det = detections[i_det]
         for i_det,det in enumerate(detections):
                         
@@ -423,6 +464,32 @@ def _smooth_classifications_for_list_of_detections(detections,
             # Don't bother with below-threshold classifications
             if c[1] < options.classification_confidence_threshold:
                 continue
+                        
+            # If we're doing taxonomic processing, at this stage, don't turn children
+            # into parents; we'll likely turn parents into children in the next stage.
+            
+            if process_taxonomic_rules:
+
+                most_common_category_description = \
+                    classification_descriptions_clean[most_common_category]
+
+                category_id_this_classification = c[0]
+                assert category_id_this_classification in category_to_count
+                
+                category_description_this_classification = \
+                    classification_descriptions_clean[category_id_this_classification]
+                
+                # An empty description corresponds to the "animal" category.  We don't handle 
+                # "animal" here as a parent category, that would be handled in the "other smoothing" 
+                # step above.
+                if len(category_description_this_classification) == 0:
+                    continue
+                
+                most_common_category_is_parent_of_this_category = \
+                    most_common_category_description in category_description_this_classification
+                
+                if most_common_category_is_parent_of_this_category:
+                    continue
             
             # If we have fewer of this category than the most common category,
             # but not *too* many, flip it to the most common category.
@@ -436,10 +503,14 @@ def _smooth_classifications_for_list_of_detections(detections,
 
     # ...if the dominant category is legit    
     
+    if verbose_debug_enabled:
+        print('Made {} non-dominant --> dominant changes'.format(
+            n_detections_flipped_this_image))
+
     
     ## Re-count
     
-    category_to_count = _count_detections_by_category(detections, options)
+    category_to_count = count_detections_by_classification_category(detections, options)
     # _print_counts_with_names(category_to_count,classification_descriptions)    
     keys = list(category_to_count.keys())
     max_count = category_to_count[keys[0]]    
@@ -449,8 +520,6 @@ def _smooth_classifications_for_list_of_detections(detections,
     
     ## Possibly collapse higher-level taxonomic predictions down to lower levels
     
-    # ...when the most common class is a child of a less common class.
-    
     n_taxonomic_changes_this_image = 0
     
     process_taxonomic_rules = \
@@ -552,7 +621,7 @@ def _smooth_classifications_for_list_of_detections(detections,
     
     ## Re-count
     
-    category_to_count = _count_detections_by_category(detections, options)
+    category_to_count = count_detections_by_classification_category(detections, options)
     # _print_counts_with_names(category_to_count,classification_descriptions)    
     keys = list(category_to_count.keys())
     max_count = category_to_count[keys[0]]    
@@ -895,7 +964,7 @@ def smooth_classification_results_sequence_level(input_file,
         image_filenames_this_sequence = sequence_to_image_filenames[sequence_id]
         
         # if 'file' in image_filenames_this_sequence:
-        #    import pdb; pdb.set_trace()
+        #    from IPython import embed; embed()
             
         detections_this_sequence = []
         for image_filename in image_filenames_this_sequence:
@@ -978,3 +1047,431 @@ def smooth_classification_results_sequence_level(input_file,
     return d
 
 # ...smooth_classification_results_sequence_level(...)
+
+
+def restrict_to_taxa_list(taxa_list,
+                          speciesnet_taxonomy_file,
+                          input_file,
+                          output_file,
+                          allow_walk_down=False,
+                          add_pre_filtering_description=True):
+    """
+    Given a prediction file in MD .json format, likely without having had
+    a geofence applied, apply a custom taxa list.
+    
+    Args:
+        taxa_list (str or list): list of latin names, or a text file containing
+            a list of latin names.  Optionally may contain a second (comma-delimited)
+            column containing common names, used only for debugging.  Latin names
+            must exist in the SpeciesNet taxonomy.
+        speciesnet_taxonomy_file (str): taxonomy filename, in the same format used for 
+            model release (with 7-token taxonomy entries)            
+        input_file (str): .json file to read, in MD format.  This can be None, in which
+            case this function just validates [taxa_list].
+        output_file (str): .json file to write, in MD format
+        allow_walk_down (bool, optional): should we walk down the taxonomy tree
+            when making mappings if a parent has only a single allowable child?
+            For example, if only a single felid species is allowed, should other
+            felid predictions be mapped to that species, as opposed to being mapped
+            to the family?
+        add_pre_restriction_description (bool, optional): should we add a new metadata
+            field that summarizes each image's classifications prior to taxonomic 
+            restriction?
+    """
+
+    ##%% Read target taxa list
+    
+    if isinstance(taxa_list,str):
+        assert os.path.isfile(taxa_list), \
+            'Could not find taxa list file {}'.format(taxa_list)
+        with open(taxa_list,'r') as f:
+            taxa_list = f.readlines()
+    
+    taxa_list = [s.strip().lower() for s in taxa_list]
+    taxa_list = [s for s in taxa_list if len(s) > 0]
+    
+    target_latin_to_common = {}
+    for s in taxa_list:
+        if s.strip().startswith('#'):
+            continue
+        tokens = s.split(',')
+        assert len(tokens) <= 2
+        binomial_name = tokens[0]
+        assert len(binomial_name.split(' ')) in (1,2,3), \
+            'Illegal binomial name in species list: {}'.format(binomial_name)
+        if len(tokens) > 0:
+            common_name = tokens[1].strip().lower()
+        else:
+            common_name = None
+        assert binomial_name not in target_latin_to_common
+        target_latin_to_common[binomial_name] = common_name
+    
+
+    ##%% Read taxonomy file
+    
+    with open(speciesnet_taxonomy_file,'r') as f:
+        speciesnet_taxonomy_list = f.readlines()
+    speciesnet_taxonomy_list = [s.strip() for s in \
+                                speciesnet_taxonomy_list if len(s.strip()) > 0]
+    
+    # Maps the latin name of every taxon to the corresponding full taxon string
+    #
+    # For species, the key is a binomial name
+    speciesnet_latin_name_to_taxon_string = {}
+    speciesnet_common_name_to_taxon_string = {}
+    
+    def _insert_taxonomy_string(s):
+        
+        tokens = s.split(';')
+        assert len(tokens) == 7
+        
+        guid = tokens[0] # noqa
+        class_name = tokens[1]
+        order = tokens[2]
+        family = tokens[3]
+        genus = tokens[4]
+        species = tokens[5]        
+        common_name = tokens[6]
+        
+        if len(class_name) == 0:
+            assert common_name in ('animal','vehicle','blank')
+            return
+        
+        if len(species) > 0:
+            assert all([len(s) > 0 for s in [genus,family,order]])
+            binomial_name = genus + ' ' + species
+            if binomial_name not in speciesnet_latin_name_to_taxon_string:
+                speciesnet_latin_name_to_taxon_string[binomial_name] = s
+        elif len(genus) > 0:
+            assert all([len(s) > 0 for s in [family,order]])
+            if genus not in speciesnet_latin_name_to_taxon_string:
+                speciesnet_latin_name_to_taxon_string[genus] = s
+        elif len(family) > 0:
+            assert len(order) > 0
+            if family not in speciesnet_latin_name_to_taxon_string:
+                speciesnet_latin_name_to_taxon_string[family] = s
+        elif len(order) > 0:
+            if order not in speciesnet_latin_name_to_taxon_string:
+                speciesnet_latin_name_to_taxon_string[order] = s
+        else:
+            if class_name not in speciesnet_latin_name_to_taxon_string:
+                speciesnet_latin_name_to_taxon_string[class_name] = s
+        
+        if len(common_name) > 0:
+            if common_name not in speciesnet_common_name_to_taxon_string:
+                speciesnet_common_name_to_taxon_string[common_name] = s
+    
+    for s in speciesnet_taxonomy_list:
+        
+        _insert_taxonomy_string(s)
+    
+    
+    ##%% Make sure all parent taxa are represented in the taxonomy
+    
+    # In theory any taxon that appears as the parent of another taxon should
+    # also be in the taxonomy, but this isn't always true, so we fix it here.
+    
+    new_taxon_string_to_missing_tokens = defaultdict(list)
+    
+    # latin_name = next(iter(speciesnet_latin_name_to_taxon_string.keys()))
+    for latin_name in speciesnet_latin_name_to_taxon_string.keys():
+        
+        if 'no cv result' in latin_name:
+            continue
+        
+        taxon_string = speciesnet_latin_name_to_taxon_string[latin_name]
+        tokens = taxon_string.split(';')
+        
+        # Don't process GUID, species, or common name
+        # i_token = 6
+        for i_token in range(1,len(tokens)-2):
+            
+            test_token = tokens[i_token]            
+            if len(test_token) == 0:
+                continue
+            
+            # Do we need to make up a taxon for this token?
+            if test_token not in speciesnet_latin_name_to_taxon_string:
+                
+                new_tokens = [''] * 7
+                new_tokens[0] = 'fake_guid'
+                for i_copy_token in range(1,i_token+1):
+                    new_tokens[i_copy_token] = tokens[i_copy_token]
+                new_tokens[-1] = test_token + ' species'
+                assert new_tokens[-2] == ''
+                new_taxon_string = ';'.join(new_tokens)
+                # assert new_taxon_string not in new_taxon_strings
+                new_taxon_string_to_missing_tokens[new_taxon_string].append(test_token)
+                
+        # ...for each token
+        
+    # ...for each taxon
+        
+    print('Found {} taxa that need to be inserted to make the taxonomy valid:\n'.format(
+        len(new_taxon_string_to_missing_tokens)))
+    
+    new_taxon_string_to_missing_tokens = \
+        sort_dictionary_by_key(new_taxon_string_to_missing_tokens)
+    for taxon_string in new_taxon_string_to_missing_tokens:
+        missing_taxa = ','.join(new_taxon_string_to_missing_tokens[taxon_string])
+        print('{} ({})'.format(taxon_string,missing_taxa))
+        
+    for new_taxon_string in new_taxon_string_to_missing_tokens:
+        _insert_taxonomy_string(new_taxon_string)
+        
+        
+    ##%% Make sure all species on the allow-list are in the taxonomy
+    
+    n_failed_mappings = 0
+    
+    for target_taxon_latin_name in target_latin_to_common.keys():
+        if target_taxon_latin_name not in speciesnet_latin_name_to_taxon_string:
+            common_name = target_latin_to_common[target_taxon_latin_name]
+            s = '{} ({}) not in speciesnet taxonomy'.format(
+                target_taxon_latin_name,common_name)
+            if common_name in speciesnet_common_name_to_taxon_string:
+                s += ' (common name maps to {})'.format(
+                    speciesnet_common_name_to_taxon_string[common_name])
+            print(s)
+            n_failed_mappings += 1
+    
+    if n_failed_mappings > 0:
+        raise ValueError('Cannot continue with geofence generation')
+    
+    
+    ##%% For the allow-list, map each parent taxon to a set of allowable child taxa
+    
+    # Maps parent names to all allowed child names, or None if this is the 
+    # lowest-level allowable taxon on this path
+    allowed_parent_taxon_to_child_taxa = defaultdict(set)
+    
+    # latin_name = next(iter(target_latin_to_common.keys()))
+    for latin_name in target_latin_to_common:
+        
+        taxon_string = speciesnet_latin_name_to_taxon_string[latin_name]
+        tokens = taxon_string.split(';')
+        assert len(tokens) == 7
+        
+        # Remove GUID and common mame
+        #
+        # This is now always class/order/family/genus/species
+        tokens = tokens[1:-1]
+        
+        child_taxon = None
+        
+        # If this is a species
+        if len(tokens[-1]) > 0:
+            binomial_name = tokens[-2] + ' ' + tokens[-1]
+            assert binomial_name == latin_name
+            allowed_parent_taxon_to_child_taxa[binomial_name].add(None)
+            child_taxon = binomial_name
+            
+        # The first candidate parent is the genus        
+        parent_token_index = len(tokens) - 2
+
+        while(parent_token_index >= 0):
+            
+            parent_taxon = tokens[parent_token_index]
+            allowed_parent_taxon_to_child_taxa[parent_taxon].add(child_taxon)
+            child_taxon = parent_taxon
+            parent_token_index -= 1                
+    
+    # ...for each allowed latin name
+    
+    allowed_parent_taxon_to_child_taxa = \
+        sort_dictionary_by_key(allowed_parent_taxon_to_child_taxa)
+    
+    
+    ##%% If we were just validating the custom taxa file, we're done
+
+    if input_file is None:
+        print('Finished validating custom taxonomy list')
+        return
+    
+
+    ##%% Map all predictions that exist in this dataset...
+    
+    # ...to the prediction we should generate.
+    
+    with open(input_file,'r') as f:
+        input_data = json.load(f)
+    
+    input_category_id_to_common_name = input_data['classification_categories'] #noqa
+    input_category_id_to_taxonomy_string = \
+        input_data['classification_category_descriptions']
+    
+    input_category_id_to_output_taxon_string = {}
+    
+    # input_category_id = next(iter(input_category_id_to_taxonomy_string.keys()))
+    for input_category_id in input_category_id_to_taxonomy_string.keys():
+        
+        input_taxon_string = input_category_id_to_taxonomy_string[input_category_id]
+        input_taxon_tokens = input_taxon_string.split(';')
+        assert len(input_taxon_tokens) == 7
+    
+        # Don't mess with blank/no-cv-result/animal/human
+        if (input_taxon_string in non_taxonomic_prediction_strings) or \
+           (input_taxon_string == human_prediction_string):
+            input_category_id_to_output_taxon_string[input_category_id] = \
+                input_taxon_string
+            continue
+    
+        # Remove GUID and common mame
+        
+        # This is now always class/order/family/genus/species
+        input_taxon_tokens = input_taxon_tokens[1:-1]
+        
+        test_index = len(input_taxon_tokens) - 1
+        target_taxon = None
+        
+        # Start at the species level, and see whether each taxon is allowed
+        while((test_index >= 0) and (target_taxon is None)):
+            
+            # Species are represented as binomial names
+            if (test_index == (len(input_taxon_tokens) - 1)) and \
+                (len(input_taxon_tokens[-1]) > 0):
+                test_taxon_name = \
+                    input_taxon_tokens[-2] + ' ' + input_taxon_tokens[-1]
+            else:
+                test_taxon_name = input_taxon_tokens[test_index]
+            
+            # If we haven't yet found the level at which this taxon is non-empty,
+            # keep going up
+            if len(test_taxon_name) == 0:            
+                test_index -= 1
+                continue
+            
+            assert test_taxon_name in speciesnet_latin_name_to_taxon_string
+            
+            # Is this taxon allowed according to the custom species list?
+            if test_taxon_name in allowed_parent_taxon_to_child_taxa:
+                
+                allowed_child_taxa = allowed_parent_taxon_to_child_taxa[test_taxon_name]
+                assert allowed_child_taxa is not None
+                
+                # If this is the lowest-level allowable token or there is not a 
+                # unique child, don't walk any further, even if walking down
+                # is enabled.
+                if (None in allowed_child_taxa):
+                    assert len(allowed_child_taxa) == 1
+                
+                if (None in allowed_child_taxa) or (len(allowed_child_taxa) > 1):
+                    target_taxon = test_taxon_name
+                elif not allow_walk_down:
+                    target_taxon = test_taxon_name
+                else:
+                    # If there's a unique child, walk back *down* the allowable
+                    # taxa until we run out of unique children
+                    while ((next(iter(allowed_child_taxa)) is not None) and \
+                          (len(allowed_child_taxa) == 1)):
+                        candidate_taxon = next(iter(allowed_child_taxa))
+                        assert candidate_taxon in allowed_parent_taxon_to_child_taxa
+                        assert candidate_taxon in speciesnet_latin_name_to_taxon_string
+                        allowed_child_taxa = \
+                            allowed_parent_taxon_to_child_taxa[candidate_taxon]
+                    target_taxon = candidate_taxon
+                    
+            # ...if this is an allowed taxon
+                    
+            test_index -= 1
+    
+        # ...for each token
+        
+        if target_taxon is None:
+            output_taxon_string = animal_prediction_string                        
+        else:
+            output_taxon_string = speciesnet_latin_name_to_taxon_string[target_taxon]
+        input_category_id_to_output_taxon_string[input_category_id] = output_taxon_string        
+    
+    # ...for each category
+        
+    
+    ##%% Build the new tables
+    
+    input_category_id_to_output_category_id = {}
+    output_taxon_string_to_category_id = {}
+    output_category_id_to_common_name = {}
+    
+    for input_category_id in input_category_id_to_output_taxon_string:
+        
+        original_common_name = \
+            input_category_id_to_common_name[input_category_id]
+        original_taxon_string = \
+            input_category_id_to_taxonomy_string[input_category_id]
+        output_taxon_string = \
+            input_category_id_to_output_taxon_string[input_category_id]
+    
+        output_common_name = output_taxon_string.split(';')[-1]
+        
+        # Do we need to create a new output category?
+        if output_taxon_string not in output_taxon_string_to_category_id:
+            output_category_id = str(len(output_taxon_string_to_category_id))
+            output_taxon_string_to_category_id[output_taxon_string] = \
+                output_category_id
+            output_category_id_to_common_name[output_category_id] = \
+                output_common_name            
+        else:
+            output_category_id = \
+                output_taxon_string_to_category_id[output_taxon_string]
+        
+        input_category_id_to_output_category_id[input_category_id] = \
+            output_category_id
+            
+        if False:
+            print('Mapping {} ({}) to:\n{} ({})\n'.format(
+                original_common_name,original_taxon_string,
+                output_common_name,output_taxon_string))
+        if False:    
+            print('Mapping {} to {}'.format(
+                original_common_name,output_common_name,))
+    
+    # ...for each category
+    
+    
+    ##%% Remap all category labels
+    
+    assert len(set(output_taxon_string_to_category_id.keys())) == \
+           len(set(output_taxon_string_to_category_id.values()))
+           
+    output_category_id_to_taxon_string = \
+        invert_dictionary(output_taxon_string_to_category_id)
+        
+    with open(input_file,'r') as f:
+        output_data = json.load(f)
+
+    classification_descriptions = None
+    if 'classification_category_descriptions' in output_data:
+        classification_descriptions = output_data['classification_category_descriptions']
+
+    for im in tqdm(output_data['images']):
+
+        if 'detections' not in im or im['detections'] is None:
+            continue
+            
+        # Possibly prepare a pre-filtering description
+        pre_filtering_description = None
+        if classification_descriptions is not None and add_pre_filtering_description:
+            category_to_count = count_detections_by_classification_category(im['detections'])
+            pre_filtering_description = \
+                get_classification_description_string(category_to_count,classification_descriptions)
+            im['pre_filtering_description'] = pre_filtering_description
+
+        for det in im['detections']:
+            if 'classifications' in det:
+                for classification in det['classifications']:
+                    classification[0] = \
+                        input_category_id_to_output_category_id[classification[0]]
+
+    # ...for each image                                    
+    
+    output_data['classification_categories'] = output_category_id_to_common_name
+    output_data['classification_category_descriptions'] = \
+        output_category_id_to_taxon_string
+        
+        
+    ##%% Write output
+    
+    with open(output_file,'w') as f:
+        json.dump(output_data,f,indent=1)
+    
+# ...def restrict_to_taxa_list(...)

megadetector/postprocessing/create_crop_folder.py

@@ -130,7 +130,7 @@ def crop_results_to_image_results(image_results_file_with_crop_ids,
             containing crop IDs, likely generated via create_crop_folder.  All 
             non-standard fields in this file will be passed along to [output_file].
         crop_results_file (str): results file for the crop folder
-        output_file (str): ouptut .json file, containing crop-level classifications
+        output_file (str): output .json file, containing crop-level classifications
             mapped back to the image level.
         delete_crop_information (bool, optional): whether to delete the "crop_id" and
             "crop_filename_relative" fields from each detection, if present.