analysis and generation of metadata in commit 15fccf29

notebooks/lilabc_CT.py

@@ -20,7 +20,7 @@ import seaborn as sns
 sns.set_style("whitegrid")
 
 # %%
-df = pd.read_csv("../data/lila_image_urls_and_labels.csv")
+df = pd.read_csv("../data/lila_image_urls_and_labels.csv", low_memory = False)
 df.head()
 
 # %%
@@ -31,541 +31,345 @@ df.annotation_level.value_counts()
 
 # %% [markdown]
 # Annotation level indicates iimage vs sequence (or unknown), not analogous to `taxonomy_level` from lila-taxonomy-mapping_release.csv. It seems `original_label` may be the analogous column.
+#
+# We'll likely want to pull out the image-level before doing any sequence checks and such since those should be "clean" images. Though we will want to label them with how many distinct species are in the image first.
+#
+# We now have 66 less sequence-level annotations and 2,517,374 more image-level! That's quite the update! The unknown count has not changed.
+#
+# ### Check Dataset Counts
+#
+# 1. Make sure we have all datasets expected.
+# 2. Check which/how many datasets are labeled to the image level (and check for match to [Andrey's spreadsheet](https://docs.google.com/spreadsheets/d/1sC90DolAvswDUJ1lNSf0sk_norR24LwzX2O4g9OxMZE/edit?usp=drive_link)).
 
 # %%
-df.sample(10)
-
-# %%
-df.info(show_counts = True)
+df.dataset_name.value_counts()
 
 # %%
-df.nunique()
+df.groupby(["dataset_name"]).annotation_level.value_counts()
 
 # %% [markdown]
-# We have 667 unique species indicated (matches lila-taxonomy-mapping_release.csv after dropping humans, seems to have two more distinct genera though).
+# It seems all the unknown annotation level images are in NACTI (North American Camera Trap Images). At first glance I don't see annotation level information on HF or on [their LILA page](https://lila.science/datasets/nacti)--will require more looking.
+#
+# Desert Lion Conservation Camera Traps & Trail Camera Images of New Zealand Animals are _not_ included in the [Hugging Face dataset](https://huggingface.co/datasets/society-ethics/lila_camera_traps).
+#
+# There are definitely more in [Andrey's spreadsheet](https://docs.google.com/spreadsheets/d/1sC90DolAvswDUJ1lNSf0sk_norR24LwzX2O4g9OxMZE/edit?usp=drive_link) that aren't included here. We'll have him go through those too.
 
 # %%
-#check for humans
-df.loc[df.species == "homo sapien"]
+df.sample(10)
 
 # %% [markdown]
-# Let's start by removing entries with `original_label`: `empty`.
+# Observe that we also now get multiple URL options; `url_aws` will likely be best/fastest for use with [`distributed-downloader`](https://github.com/Imageomics/distributed-downloader) to get the images.
 
 # %%
-df_cleaned = df.loc[df.original_label != "empty"]
+df.info(show_counts = True)
 
 # %% [markdown]
-# We started with 16,833,848 entries, and are left with 8,448,597 after removing all labeled as `empty`, so about half the images. 
+# The overall dataset has grown by about 3 million images, we'll see how much of this is non-empty. I'm encouraged by the number of non-null `scientific_name` values seeming to also grow by about 3 million; most of these also seem to have genus now.
 #
-# Note that there are still about 2 million that don't have the species label, 1.5 million that are missing genus designation.
-
-# %%
-df_cleaned[['genus', 'species']].info(show_counts = True)
-
-# %%
-df_cleaned[['genus', 'species']].nunique()
-
-# %%
-df_cleaned.loc[df_cleaned['genus'].isna(), 'species'].value_counts()
-
-# %% [markdown]
-# All entries missing `genus` are also missing `species`, so we'll drop all entries with null `genus`.
-
-# %%
-df_genusSpecies = df_cleaned.dropna(subset = "genus")
-
-# %%
-df_genusSpecies.info(show_counts = True)
+# We'll definitely want to check on the scientifc name choices where genus and species aren't available, similarly for other ranks, as it is guarunteed as much as kingdom (which is hopefully aligned with all non-empty images).
+#
+# No licensing info, we'll get that from HF or the datasets themselves (Andrey can check this; most seem to be [Community Data License Agreement (permissive variant)](https://cdla.io/permissive-1-0/)).
 
 # %%
-df_genusSpecies.nunique()
+df.nunique()
 
 # %% [markdown]
-# This leaves us with 476 unique genera and 667 unique species among the remaining 6,978,606 entries in the 18 datasets.
+# We have 739 unique species indicated, though the 908 unique `scientific_name` values is likely more indicative of the diversity.
 #
-# There are about 77,000 non-unique URLs. Does this mean there are duplicated entries for images or are they sequences? This is the same number of unique `image_id`, so unclear.
+# Interesting also to note that there are duplicate URLs here; these would be the indicators of multiple species in an image as they correspond to the number of unique image IDs. We'll check this out once we remove the images labeled as "empty".
 
 # %%
-df_genusSpecies.duplicated(subset = ['url'], keep = False).value_counts()
+#check for humans
+df.loc[df.species == "homo sapien"]
 
 # %% [markdown]
-# This tracks with the rough estimate, as we see a total of 152,889 entries that are duplicates of each other, with a total of 76,787 that have been duplicated (see below).
-
-# %%
-df_genusSpecies.duplicated(subset = ['url'], keep = 'first').value_counts()
+# Let's start by removing entries with `original_label`: `empty`.
 
 # %%
-df_genusSpecies.duplicated(subset = ['url', 'image_id'], keep = 'first').value_counts()
+df_cleaned = df.loc[df.original_label != "empty"].copy()
 
 # %% [markdown]
-# These match the duplicated `image_id`s as well. Perhaps this is more than one animal in the frame? In which case it is important to mark all the potential duplicates as duplicates, not just the instances after the image's first occurence.
-
-# %%
-df_genusSpecies['url_dupe'] = df_genusSpecies.duplicated(subset = ['url'], keep = False)
-
-# %%
-df_genusSpecies.sample(10)
+# ## Save the Reduced Data (no more "empty" labels)
 
 # %%
-duplicated_urls = df_genusSpecies.loc[df_genusSpecies.url_dupe]
-duplicated_urls.head(10)
+df_cleaned.to_csv("../data/lila_image_urls_and_labels.csv", index = False)
 
 # %% [markdown]
-# From this small sample, it looks like they are distinguished by their frame number (`frame_num`) and the animal itself--there is more than one animal (of a different species) in frame so it duplicates the image information because there is an entry for each species of animal in the image.
-
-# %% [markdown]
-# We have 1,046,985 distinct sequence IDs for the 6,901,819 unique image IDs, suggesting an average of 6 images per sequence?
+# Let's check where we are with annotations now that we've removed all the images labeled as empty.
 
 # %%
-df_genusSpecies.head(1).values
+df.groupby(["dataset_name"]).annotation_level.value_counts()
 
 # %% [markdown]
-# The end of the URL `cct_images/...jpg` matches the `file` indicator in the model results from LILA BC for MegaDetector. We will use agreement about the animal's precense from both [v5a and v5b models](https://lila.science/megadetector-results-for-camera-trap-datasets/) (v4 for Snapshot Serengeti) to determine appropriate images from a sequence to keep (only one per sequence to avoid testing on the same animal (instance) multiple times). 
+# We started with 19,351,156 entries, and are left with 10,965,902 after removing all labeled as `empty`, so more than half the images now; it's an increase of about 2.5M from the last version. 
 #
-# First, let's remove the images that have multiple animals, as indicated by the `url_dupe` column.
+# Note that there are still about 3.4 million that don't have the species label, 1.5 million that are missing genus designation. 10,192,703 of them have scientific and common name, though! That's nearly all of them.
 
 # %%
-dedupe_genusSpecies = df_genusSpecies.loc[~df_genusSpecies.url_dupe]
-dedupe_genusSpecies.head()
-
-# %% [markdown]
-# Let's quickly check our stats on this subset (eg, `speices`/`genus` values).
+df_cleaned.info(show_counts = True)
 
 # %%
-dedupe_genusSpecies.info(show_counts = True)
+df_cleaned.nunique()
 
 # %%
-cols = list(dedupe_genusSpecies.columns[:11])
-cols.append('genus')
-cols.append('species')
-dedupe_genusSpecies[cols].nunique()
+print(df_cleaned.phylum.value_counts())
+print()
+print(df_cleaned["class"].value_counts())
 
 # %% [markdown]
-# All datasets are still represented, all URLs and `image_id`s are unique, and we still have 667 distinct species. 
+# We have 10,965,902 total - 10,864,013 unique URLs, suggesting at most 101,889 images have more than one species in them. That's only 1% of our images here and even smaller at the scale we're looking for the next ToL dataset. It is interesting to note though and we should explore this more.
 #
-# We should probably drop the null `species` values since we have such a large number of images and prefer to keep it more specific.
-
-# %%
-dedupe_species = dedupe_genusSpecies.loc[dedupe_genusSpecies.species.notna()]
-dedupe_species.head()
-
-# %% [markdown]
-# Have any of our other stats changed significantly?
+# I'm curious about the single "variety", since I thought that was more of a plant label and these are all animals.
+#
+# All images are in Animalia, as expected; we have 2 phyla represented and 8 classes:
+#  - Predominantly Chordata, and within that phylum, Mammalia is the vast majority, though aves is about 10%.
+#  - Note that not every image with a phylum label has a class label.
+#  - Insecta, malacostraca, arachnida, and diplopoda are all in the class Arthropoda.
+#
+# ### Label Multi-Species Images
+# We'll go by both the URL and image ID, which do seem to correspond to the same images (for uniqueness).
 
 # %%
-dedupe_species[cols].info(show_counts = True)
+df_cleaned["multi_species"] = df_cleaned.duplicated(subset = ["url_aws", "image_id"], keep = False)
 
-# %%
-dedupe_species[cols].nunique()
+df_cleaned.loc[df_cleaned["multi_species"]].nunique()
 
 # %% [markdown]
-# We lost 17 locations, 24 genera, and 86 common names, but all datasets are still represented.
+# We've got just under 100K images that have multiple species. We can figure out how many each of them have, and then move on to looking at images per sequence and other labeling info.
 
 # %%
-#some sample images
-dedupe_species['url'].head().values
-
-# %% [markdown]
-# ## Save a Species Label CSV
-#
-# Dataset with all images that have labels down to the species level. We will get some stats on this to determine how to truncate to just one instance of each animal per sequence.
+multi_sp_imgs = list(df_cleaned.loc[df_cleaned["multi_species"], "image_id"].unique())
 
 # %%
-dedupe_species.to_csv("../data/lila_image_urls_and_labels_species.csv", index = True)
+for img in multi_sp_imgs:
+    df_cleaned.loc[df_cleaned["image_id"] == img, "num_species"] = df_cleaned.loc[df_cleaned["image_id"] == img].shape[0]
+    
+df_cleaned.head()
 
 # %% [markdown]
-# ### Species Stats
-#
-# Let's get some statistics on this data to help narrow it down:
-# - Do we have instances of common name matching scientific name? There are more unique instances of `common_name` than `species` or `scientific_name`.
-# - What is the minimum number of instances of a particular species? We'll balance the datset to have the smallest number available (assuming 20+ images).
-# - For later evaluation, what's the distribution of time of day (will be more meaningful for the finalized species dataset)?
+# #### Save this to CSV now we got those counts
 
 # %%
-dedupe_species['common_species_match'] = list(dedupe_species.common_name == dedupe_species.species)
+df_cleaned.to_csv("../data/lila_image_urls_and_labels.csv", index = False)
 
 # %%
-dedupe_species['common_sciName_match'] = list(dedupe_species.common_name == dedupe_species.scientific_name)
+df_cleaned.loc[df_cleaned["multi_species"]].head()
 
-# %%
-dedupe_species.common_species_match.value_counts()
+# %% [markdown]
+# How many different species do we generally have when we have multiple species in an image?
 
 # %%
-dedupe_species.common_sciName_match.value_counts()
+df_cleaned.num_species.value_counts()
 
 # %% [markdown]
-# Common name is not filled with scientific name or species values for any of these images.
+# We have 97,567 images with 2 different species (most multi-species instances), 2,023 with 3 different species, and 92 with 4.
 #
-# Now, let's check the number of each species. Then maybe check scientific name and common name since we have more of these.
-
-# %%
-num_species_dict = {}
-for species in dedupe_species.species.unique():
-    num_species = len(dedupe_species.loc[dedupe_species.species == species])
-    num_species_dict[species] = num_species
-num_species_dict
+# We will want to dedicate some more time to exploring some of these taxonomic counts, but we'll first look at the number of unique taxa (by Linnean 7-rank (`unique_7_tuple`) and then by all taxonomic labels (`unique_taxa`) available). We'll compare these to the number of unique scientific and common names, then perhaps add a count of number of creatures based on one of those labels. At that point we may save another copy of this CSV and start a new analysis notebook.
 
 # %%
-#Add this info to the dataset
-for species, num in num_species_dict.items():
-    dedupe_species.loc[dedupe_species.species == species, 'num_species'] = num
-
-# %%
-more_samples = {}
-for species, num in num_species_dict.items():
-    if num >= 40:
-        more_samples[species] = num
-
-more_samples
-
-# %%
-print("We have ", len(more_samples), " species for which there are at least 40 images.")
-
-# %%
-mid_samples = {}
-for species, num in num_species_dict.items():
-    if num >= 20:
-        mid_samples[species] = num
-
-print("We have ", len(mid_samples), " species for which there are at least 20 images.")
+df_cleaned.annotation_level.value_counts()
 
 # %% [markdown]
-# ## One Image per Species per Sequence
+# We've got ~3M labeled to the image and another 3M unknonwn labeling (all from NACTI, which Andrey will check on), leaving ~5M labeled only to at the sequence level. This _should_ give Jianyang something to work with to start exploring near-duplicate de-duplication. 
 #
-# Now let's generate the final dataset we'll use for testing. When there are sequences of images, there's the clear potential to capture multiple images of the same animal, so we'll check for duplicates of `sequence_id` and `species` pairings within datasets and keep the first instance of each species within a sequence. We expect to have between 948,156 and 1,000,000 labeled images as a result.
+# Let's update the non-multi species images to show 1 in the `num_species` column, then move on to checking the taxonomy strings.
 
 # %%
-dedupe_species['multi-image'] = dedupe_species.duplicated(subset = ['dataset_name', 'sequence_id', 'species', 'location_id'], keep = 'first')
+df_cleaned.loc[df_cleaned["num_species"].isna(), "num_species"] = 1.0
 
-# %%
-dedupe_species.head()
-
-# %%
-dedupe_species['multi-image'].value_counts()
-
-# %%
-species_single_seq = dedupe_species.loc[~dedupe_species['multi-image']]
-species_single_seq.sample(7)
-
-# %%
-species_single_seq.to_csv("../data/lila_image_urls_and_labels_SingleSpecies.csv", index = False)
-
-# %%
-species_single_seq[cols].nunique()
+df_cleaned.num_species.value_counts()
 
 # %% [markdown]
-# Same number of unique common and scientific names.
-
-# %% [markdown]
-# #### Check Number of Images per Species
-
-# %%
-num_singleSpecies_dict = {}
-for species in species_single_seq.species.unique():
-    num_species = len(species_single_seq.loc[species_single_seq.species == species])
-    num_singleSpecies_dict[species] = num_species
-num_singleSpecies_dict
-
-# %%
-more_singleSamples = {}
-for species, num in num_singleSpecies_dict.items():
-    if num >= 40:
-        more_singleSamples[species] = num
-
-print("We have ", len(more_singleSamples), " species for which there are at least 40 images.")
-print()
-
-mid_singleSamples = {}
-for species, num in num_singleSpecies_dict.items():
-    if num >= 20:
-        mid_singleSamples[species] = num
-
-print("We have ", len(mid_singleSamples), " species for which there are at least 20 images.")
+# ### Taxonomic String Exploration
 
 # %%
-#Add the counts to the dataset for filtering
-for species, num in num_singleSpecies_dict.items():
-    species_single_seq.loc[species_single_seq.species == species, 'num_singleSpecies'] = num
-
-# %%
-total_more_images = 0
-for species, num in more_singleSamples.items():
-    total_more_images += num
-
-total_mid_images = 0
-for species, num in mid_singleSamples.items():
-    total_mid_images += num
-
-# %%
-print("With a 20 image per species cutoff, we have ", total_mid_images, "total images.")
-print("With a 40 image per species cutoff, we have ", total_more_images, "total images.")
+lin_taxa = ['kingdom', 'phylum', 'class', 'order', 'family', 'genus', 'species']
+all_taxa = ['kingdom',
+            'phylum',
+            'subphylum',
+            'superclass',
+            'class',
+            'subclass',
+            'infraclass',
+            'superorder',
+            'order',
+            'suborder',
+            'infraorder',
+            'superfamily',
+            'family',
+            'subfamily',
+            'tribe',
+            'genus',
+            'species',
+            'subspecies',
+            'variety']
 
 # %% [markdown]
-# Let's look at the family distribution for these.
+# #### How many have all 7 Linnean ranks?
 
 # %%
-import seaborn as sns
-
-sns.set_style("whitegrid")
-sns.set(rc = {'figure.figsize': (10,10)})
-
-# %%
-sns.histplot(species_single_seq.loc[species_single_seq.num_singleSpecies >= 40], y = 'family')
-
-# %%
-sns.histplot(species_single_seq.loc[species_single_seq.num_singleSpecies >= 20], y = 'family')
+df_all_taxa = df_cleaned.dropna(subset = lin_taxa)
+df_all_taxa[all_taxa].info(show_counts = True)
 
 # %% [markdown]
-# ### Check for images marked as having animal that are actually empty 
-# This can occur when images are labeled as a sequence, and it is suggested that it is not an unusual occurance. We will use the [MegaDetector results](https://lila.science/megadetector-results-for-camera-trap-datasets/) provided by LILA BC to run a check for these. Ultimately, we won't use repeated instances of the same animal in the same sequence so the process of removing extra instances may also alleviate this issue. Additionally, it's worth noting that MegaDector is trained to err on the side of detection (i.e., it's more likely to see an animal that's not there), so not likely to change our assessment.
+# That's pretty good coverage: 7,521,712 out of 10,965,902. It looks like many of them also have the other taxonomic ranks too. Now how many different 7-tuples are there?
 #
-# #### Caltech Camera Traps
-
-# %% [markdown]
-# Look up a couple sample file values in the model results JSON (with and without detection).
+# #### How many unique 7-tuples?
 
 # %%
-df.loc[df['url'].str.contains("cct_images/5862934b-23d2-11e8-a6a3-ec086b02610b")] 
+#number of unique 7-tuples in full dataset
+df_cleaned['lin_duplicate'] = df_cleaned.duplicated(subset = lin_taxa, keep = 'first')
+df_unique_lin_taxa = df_cleaned.loc[~df_cleaned['lin_duplicate']].copy()
+df_unique_lin_taxa.info(show_counts = True)
 
-# %%
-df.loc[df['url'].str.contains("cct_images/5862934c-23d2-11e8-a6a3-ec086b02610b.jpg")] 
+# %% [markdown]
+# Interesting, we have 891 unique 7-tuple taxonomic strings, but 1 scientific and common name seem to be missing.
+# What's the uniqueness count here?
 
 # %%
-df.loc[df['url'].str.contains("cct_images/5874d5d3-23d2-11e8-a6a3-ec086b02610b.jpg")] 
+df_unique_lin_taxa.nunique()
 
-# %%
-import json
+# %% [markdown]
+# They're across all datasets. We have 890 unique scientific names and 886 unique common names (from 885 original labels).
 
 # %%
-dedupe_species.dataset_name.value_counts()
+df_unique_lin_taxa.loc[(df_unique_lin_taxa["scientific_name"].isna()) | (df_unique_lin_taxa["common_name"].isna())]
 
 # %% [markdown]
-# Most of our images are comingi from NACTI and Snapshot Serengeti, so those may be the more important to focus on, but good to check through. Those two will also take longer. Let's start with the smaller ones to get some preliminary checks. As noted above, it's not likely to change our results.
+# It's a car...We need to remove cars...
 
 # %%
-mdv5b_files = {"Caltech Camera Traps": "caltech-camera-traps_mdv5a.0.0_results.json",
-               "Channel Islands Camera Traps": "channel-islands-camera-traps_mdv5b.0.0_results.json",
-               "ENA24": "ena24_mdv5b.0.0_results.json",
-               "Idaho Camera Traps": "idaho-camera-traps_mdv5b.0.0_results.json",
-               "Island Conservation Camera Traps": "island-conservation-camera-traps_mdv5b.0.0_results.json",
-               "Missouri Camera Traps": "missouri-camera-traps_mdv5b.0.0_results.json",
-               "Orinoquia Camera Traps": "orinoquia-camera-traps_public_mdv5b.0.0_results.json",
-               "Snapshot Camdeboo": "snapshot-safari_CDB_mdv5b.0.0_results.json",
-               "Snapshot Enonkishu": "snapshot-safari_ENO_mdv5b.0.0_results.json",
-               "Snapshot Karoo": "snapshot-safari_KAR_mdv5b.0.0_results.json",
-               "Snapshot Kgalagadi": "snapshot-safari_KGA_mdv5b.0.0_results.json",
-               "Snapshot Kruger": "snapshot-safari_KRU_mdv5b.0.0_results.json",
-               "Snapshot Mountain Zebra": "snapshot-safari_MTZ_mdv5b.0.0_results.json",
-               "SWG Camera Traps": "swg-camera-traps_public_mdv5b.0.0_results.json",
-               "WCS Camera Traps": "wcs-camera-traps_animals_mdv5b.0.0_results.json",
-               "Wellington Camera Traps": "wellington-camera-traps_images_mdv5b.0.0_results.json"}
-
+df_cleaned.loc[df_cleaned["original_label"] == "car"].shape
 
 # %%
-def filter_md_results(dataset_name, filename):
-    with open("../MegaDetector_results/" + filename) as file:
-        data = json.load(file)
-    df_mdv5b = pd.json_normalize(data["images"], max_level = 1)
-    print(df_mdv5b.head())
-    dedupe_url = list(dedupe_species.loc[dedupe_species["dataset_name"] == dataset_name, 'url'])
-    dedupe_url_empties = []
-    for file in list(df_mdv5b.loc[(df_mdv5b['max_detection_conf'] <= 80 & df_mdv5b['detections'].astype(str) != '[]'), 'file']):
-        if file in dedupe_url:
-            dedupe_url_empties.append(file)
-    print(dataset_name, ": ", dedupe_url_empties)
-    return dedupe_url_empties
-
+df_cleaned.loc[df_cleaned["original_label"] == "car", "dataset_name"].value_counts()
 
 # %% [markdown]
-# ### Earlier check on `[]`
+# #### How many unique full taxa (sub ranks included)?
 
 # %%
-with open("../MegaDetector_results/caltech-camera-traps_mdv5a.0.0_results.json") as file:
-    data = json.load(file)
+#number of unique 7-tuples in full dataset
+df_cleaned['full_duplicate'] = df_cleaned.duplicated(subset = all_taxa, keep = 'first')
+df_unique_all_taxa = df_cleaned.loc[~df_cleaned['full_duplicate']].copy()
+df_unique_all_taxa.info(show_counts = True)
 
-# %%
-data
-
-# %%
-cct_mdv5a = pd.json_normalize(data["images"], max_level = 1)
+# %% [markdown]
+# When we consider the sub-ranks as well we wind up with 909 unique taxa (still with one scientific and common name missing--the car!).
 
 # %%
-cct_mdv5a.head(10)
+df_unique_all_taxa.nunique()
 
 # %% [markdown]
-# `file` matches the end of the `url` value in our DataFame. We want to filter out any empty detections that are still in `dedupe_species`. We could also consider lower confidences, but maybe start there.
+# We have now captured all 908 unique scientific names, but only 901 of the 999 unique common names.
 
 # %%
-len(cct_mdv5a)
+df_unique_all_taxa.loc[(df_unique_all_taxa["scientific_name"].isna()) | (df_unique_all_taxa["common_name"].isna())]
 
-# %%
-type(cct_mdv5a.detections[5])
-
-# %%
-cct_mdv5a.loc[cct_mdv5a['detections'].astype(str) == '[]']
+# %% [markdown]
+# #### Let's remove those cars
 
 # %%
-dedupe_url_cct = list(dedupe_species.loc[dedupe_species['dataset_name'] == "Caltech Camera Traps", 'url'])
-dedupe_cct_empties = []
-for file in list(cct_mdv5a.loc[cct_mdv5a['detections'].astype(str) == '[]', 'file']):
-    if file in dedupe_url_cct:
-        dedupe_cct_empties.append(file)
-
-dedupe_cct_empties
-
-# %% [markdown]
-# CCT Seem fine
+df_cleaned = df_cleaned[df_cleaned["original_label"] != "car"].copy()
+df_cleaned[["original_label", "scientific_name", "common_name", "kingdom"]].info(show_counts = True)
 
 # %% [markdown]
-# #### WCS Camera Traps
-# Since these have a note that empties may be labeled as species within the sequence, let's check this as well.
+# Now we have 10,961,185 instead of 10,965,902 images; they all have `original_label`, but only 10,192,703 of them have `scientific_name`, `common_name`, and `kingdom`. What are the `original_label`s for those ~800K images?
 
 # %%
-with open("../MegaDetector_results/wcs-camera-traps_animals_mdv5a.0.0_results.json") as file:
-    data = json.load(file)
+no_taxa = df_cleaned.loc[(df_cleaned["scientific_name"].isna()) & (df_cleaned["common_name"].isna()) & (df_cleaned["kingdom"].isna())].copy()
 
-# %%
-data
+print(no_taxa[["dataset_name", "original_label"]].nunique())
+no_taxa[["dataset_name", "original_label"]].info(show_counts = True)
 
 # %% [markdown]
-# Looks like formatting is consistent
+# What are these 24 other labels and how are the 768,482 images with them distributed across these 12 datasets?
 
 # %%
-wcs_mdv5a = pd.json_normalize(data["images"], max_level = 1)
+no_taxa["original_label"].value_counts()
 
 # %%
-wcs_mdv5a.head()
+no_taxa["dataset_name"].value_counts()
 
 # %%
-list(dedupe_species.loc[dedupe_species['dataset_name'] == "WCS Camera Traps", 'url'])
-
-# %%
-dedupe_url_wcs = list(dedupe_species.loc[dedupe_species['dataset_name'] == "WCS Camera Traps", 'url'])
-dedupe_wcs_empties = []
-for file in list(wcs_mdv5a.loc[wcs_mdv5a['detections'].astype(str) == '[]', 'file']):
-    if file in dedupe_url_wcs:
-        dedupe_wcs_empties.append(file)
-
-dedupe_wcs_empties
+no_taxa.groupby(["dataset_name"])["original_label"].value_counts()
 
 # %% [markdown]
-# MegaDetector v5b is supposed to have less false positives than v5a, so let's check that and see if we're still in the clear.
+# Interesting. It seems like all of these should also be removed. Vegetation obstruction could of course be labeled in Plantae, but we're not going to be labeling 7K images for this project. 
+#
+# Let's remove them, then we should have 10,192,703 images.
 
 # %%
-with open("../MegaDetector_results/wcs-camera-traps_animals_mdv5b.0.0_results.json") as file:
-    data = json.load(file)
+non_taxa_labels = list(no_taxa["original_label"].unique())
 
 # %%
-wcs_mdv5b = pd.json_normalize(data["images"], max_level = 1)
-wcs_mdv5b.head()
+df_clean = df_cleaned.loc[~df_cleaned["original_label"].isin(non_taxa_labels)].copy()
+df_clean.info(show_counts = True)
 
 # %%
-dedupe_wcs_empties = []
-for file in list(wcs_mdv5b.loc[wcs_mdv5b['detections'].astype(str) == '[]', 'file']):
-    if file in dedupe_url_wcs:
-        dedupe_wcs_empties.append(file)
-
-dedupe_wcs_empties
+df_clean.nunique()
 
 # %% [markdown]
-# #### NACTI
+# Let's check out our top ten labels, scientific names, and common names. Then we'll save this cleaned metadata file.
 
 # %%
-with open("../MegaDetector_results/nacti_mdv5b.0.0_results.json") as file:
-    data = json.load(file)
+df_clean["original_label"].value_counts()[:10]
 
 # %%
-nacti_mdv5b = pd.json_normalize(data["images"], max_level = 1)
-nacti_mdv5b.head()
+df_clean["scientific_name"].value_counts()[:10]
 
 # %%
-dedupe_url_nacti = list(dedupe_species.loc[dedupe_species['dataset_name'] == "NACTI", 'url'])
-dedupe_nacti_empties = []
-for file in list(nacti_mdv5b.loc[nacti_mdv5b['detections'].astype(str) == '[]', 'file']):
-    if file in dedupe_url_nacti:
-        dedupe_nacti_empties.append(file)
+df_clean["common_name"].value_counts()[:10]
 
-dedupe_nacti_empties
+# %% [markdown]
+# There are also 257,159 humans in here! Glad the number agrees across labels. We'll probably need to remove the humans, though I may save a copy with them still on the HF repo (it is just our dev repo). Which datasets have them? I thought humans were filtered out previously (though I could be mistaken as they seem to be in 15 of the 20 datasets).
 
+# %%
+df_clean.loc[df_clean["original_label"] == "human", "dataset_name"].value_counts()
 
 # %% [markdown]
-# #### Check Remaining Datasets
-#
-# Let's automate the process to speed this up with a function to take the dataset and filename and return any marked empty by the model.
+# What do human labels look like (as in do they have the full taxa structure)?
 
 # %%
-def check_md_results(dataset_name, filename):
-    with open("../MegaDetector_results/" + filename) as file:
-        data = json.load(file)
-    df_mdv5b = pd.json_normalize(data["images"], max_level = 1)
-    print(df_mdv5b.head())
-    dedupe_url = list(dedupe_species.loc[dedupe_species["dataset_name"] == dataset_name, 'url'])
-    dedupe_url_empties = []
-    for file in list(df_mdv5b.loc[df_mdv5b['detections'].astype(str) == '[]', 'file']):
-        if file in dedupe_url:
-            dedupe_url_empties.append(file)
-    print(dataset_name, ": ", dedupe_url_empties)
-    return dedupe_url_empties
+df_clean.loc[df_clean["original_label"] == "human"].sample(5)
 
+# %% [markdown]
+# It does seem to have full taxa...interesting.
 
 # %%
-mdv5b_files = {"Channel Islands Camera Traps": "channel-islands-camera-traps_mdv5b.0.0_results.json",
-               "ENA24": "ena24_mdv5b.0.0_results.json",
-               "Idaho Camera Traps": "idaho-camera-traps_mdv5b.0.0_results.json",
-               "Island Conservation Camera Traps": "island-conservation-camera-traps_mdv5b.0.0_results.json",
-               "Missouri Camera Traps": "missouri-camera-traps_mdv5b.0.0_results.json",
-               "Orinoquia Camera Traps": "orinoquia-camera-traps_public_mdv5b.0.0_results.json",
-               "Snapshot Camdeboo": "snapshot-safari_CDB_mdv5b.0.0_results.json",
-               "Snapshot Enonkishu": "snapshot-safari_ENO_mdv5b.0.0_results.json",
-               "Snapshot Karoo": "snapshot-safari_KAR_mdv5b.0.0_results.json",
-               "Snapshot Kgalagadi": "snapshot-safari_KGA_mdv5b.0.0_results.json",
-               "Snapshot Kruger": "snapshot-safari_KRU_mdv5b.0.0_results.json",
-               "Snapshot Mountain Zebra": "snapshot-safari_MTZ_mdv5b.0.0_results.json",
-               "SWG Camera Traps": "swg-camera-traps_public_mdv5b.0.0_results.json",
-               "Wellington Camera Traps": "wellington-camera-traps_images_mdv5b.0.0_results.json"}
-
+df_clean.to_csv("../data/lila_image_urls_and_labels_wHumans.csv", index = False)
 
 # %%
-empties = {}
-for key in list(mdv5b_files.keys()):
-    empties[key] = check_md_results(key, mdv5b_files[key])
+df_clean.loc[df_clean["original_label"] != "human"].to_csv("../data/lila_image_urls_and_labels.csv", index = False)
 
 # %%
-empties
+taxa = [col for col in list(df_clean.columns) if col in all_taxa or col =="original_label"]
 
-# %% [markdown]
-# #### Snapshot Serengeti
-#
-# Snapshot Serengeti was evaluated with MegaDetector v4 due to questions raised by [this issue](https://github.com/ultralytics/yolov5/issues/9294) as noted on [LILA BC's site](https://lila.science/megadetector-results-for-camera-trap-datasets/).
+df_taxa = df_clean[taxa].copy()
+df_taxa.loc[df_taxa["original_label"] == "human"].sample(7)
 
 # %%
-#Snapshot Serengeti was evaluated with MegaDetector v4
-mdv4_files = ["snapshot-serengeti-mdv4.1.0_results.json/snapshot-serengeti_S" + str(i) + "_mdv4.1.0_results.json" for i in range(1,11)]
-mdv4_files.append("snapshot-serengeti-mdv4.1.0_results.json/snapshot-serengeti_SER_S11_mdv4.1.0_results.json")
+df_clean.loc[df_clean["original_label"] != "human"].info(show_counts = True)
 
 # %%
-mdv4_empties = {}
-for file in mdv4_files:
-    mdv4_empties[file] = check_md_results("Snapshot Serengeti", file)
+df_clean.loc[df_clean["original_label"] != "human"].nunique()
+
+# %% [markdown]
+# We have 1,198,696 distinct sequence IDs for the 9,849,119 unique image IDs, suggesting an average of 8 images per sequence?
 
 # %%
-#only ran first 4
-for file in mdv4_files[4:]:
-    mdv4_empties[file] = check_md_results("Snapshot Serengeti", file)
+df_clean.loc[df_clean["original_label"] != "human", "annotation_level"].value_counts()
 
 # %% [markdown]
-#
+# #### Check Number of Images per Scientific Name?
 
 # %%
-with open("../MegaDetector_results/snapshot-serengeti-mdv4.1.0_results.json/snapshot-serengeti_S1_mdv4.1.0_results.json") as file:
-    data = json.load(file)
 
-serengeti_df_mdv4 = pd.json_normalize(data["images"], max_level = 1)
+# %%
 
 # %%
-len(serengeti_df_mdv4.loc[serengeti_df_mdv4.max_detection_conf >= .8])
+sns.histplot(df_clean.loc[df_clean["original_label"] != "human"], y = 'class')
 
 # %%
-len(serengeti_df_mdv4)
+sns.histplot(df_clean.loc[df_clean["original_label"] != "human"], y = 'order')
 
 # %%