Get the best image out of a exact/near duplicate set

[schm0]

Hi!
I'm trying to get the best image out of a near duplicate image set.
I came up with this:
near_duplicates_images = list(chain(*[ set[1:] for set in imagelab.info['near_duplicates']['sets'] ]))
This should keep one image from each image set and create one big list of images that should be discarded.
But how to sort the images by blurriness so only the best image can be kept and the worst images can be discarded?
Thanks!

[jwmueller]

Hi @schm0 , does this FAQ help you?

https://docs.cleanlab.ai/master/tutorials/faq.html#How-to-handle-near-duplicate-data-identified-by-cleanlab?

If not, we'll try to update the answer via the FAQ to help you and others with the same question simultaneously. But first want to understand where the FAQ answer is falling short for your use-case.

[schm0]

Thank you but is there no way to do this without datalab?
That doesn't seem to work with cleanvision/Imagelab because the key names are different?
The example code uses duplicate_rows = data.query("is_near_duplicate_issue").copy()
But the actual key is is_near_duplicates_issue in Imagelab
It also errors out at:

def construct_group_key(row):
    """Convert near_duplicate_sets into a frozenset and include the row's own index."""
    return frozenset(row['near_duplicate_sets']).union({row.name})

near_duplicate_sets is not defined.

[schm0]

I'm not that much into python but I think this will do it?
The goal is to create a list of images that should be trashed/moved.
e.g. removing the best quality images from the list.

# Remove one image from each exact duplicate set
# e.g. One image will be kept, all others get trashed
exact_duplicates_images = list(chain(*[ set[1:] for set in imagelab.info['exact_duplicates']['sets'] ]))

# Group near duplicates into sets
near_duplicates_image_sets = imagelab.info['near_duplicates']['sets']

# Get blurry score of each near duplicate image
near_duplicates_image_scores = (imagelab.issues[imagelab.issues["is_near_duplicates_issue"] == True]
                                    .sort_values(by='blurry_score')
                                    .reset_index()[['index', 'blurry_score']]
                                    .values.tolist())

near_duplicates_images = []

# Create a new set list by comparing
# near_duplicates_image_sets and near_duplicates_image_scores
# and removing the image with the highest blurr score (less blurry, highest quality?)
# from each set
for set in near_duplicates_image_sets:
    max_score_entry = max((entry for entry in near_duplicates_image_scores if entry[0] in set), key=lambda x: x[1])
    updated_set_list = [img for img in set if img != max_score_entry[0]]
    near_duplicates_images.append(updated_set_list)

# Flatten the set list 
# e.g. convert list of lists into one big list
# so it is easily iterable
near_duplicates_images = list(chain.from_iterable(near_duplicates_images))

[sanjanag]

This looks good if you want to keep the least blurry image from a near duplicate set.