Add paired py file for notebook from first analysis

notebooks/lilabc_CT.py

@@ -0,0 +1,571 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.16.0
+#   kernelspec:
+#     display_name: std
+#     language: python
+#     name: python3
+# ---
+
+# %%
+import pandas as pd
+import seaborn as sns
+
+sns.set_style("whitegrid")
+
+# %%
+df = pd.read_csv("../data/lila_image_urls_and_labels.csv")
+df.head()
+
+# %%
+df.columns
+
+# %%
+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.
+
+# %%
+df.sample(10)
+
+# %%
+df.info(show_counts = True)
+
+# %%
+df.nunique()
+
+# %% [markdown]
+# We have 667 unique species indicated (matches lila-taxonomy-mapping_release.csv after dropping humans, seems to have two more distinct genera though).
+
+# %%
+#check for humans
+df.loc[df.species == "homo sapien"]
+
+# %% [markdown]
+# Let's start by removing entries with `original_label`: `empty`.
+
+# %%
+df_cleaned = df.loc[df.original_label != "empty"]
+
+# %% [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. 
+#
+# 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)
+
+# %%
+df_genusSpecies.nunique()
+
+# %% [markdown]
+# This leaves us with 476 unique genera and 667 unique species among the remaining 6,978,606 entries in the 18 datasets.
+#
+# 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.
+
+# %%
+df_genusSpecies.duplicated(subset = ['url'], keep = False).value_counts()
+
+# %% [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()
+
+# %%
+df_genusSpecies.duplicated(subset = ['url', 'image_id'], keep = 'first').value_counts()
+
+# %% [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)
+
+# %%
+duplicated_urls = df_genusSpecies.loc[df_genusSpecies.url_dupe]
+duplicated_urls.head(10)
+
+# %% [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?
+
+# %%
+df_genusSpecies.head(1).values
+
+# %% [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). 
+#
+# First, let's remove the images that have multiple animals, as indicated by the `url_dupe` column.
+
+# %%
+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).
+
+# %%
+dedupe_genusSpecies.info(show_counts = True)
+
+# %%
+cols = list(dedupe_genusSpecies.columns[:11])
+cols.append('genus')
+cols.append('species')
+dedupe_genusSpecies[cols].nunique()
+
+# %% [markdown]
+# All datasets are still represented, all URLs and `image_id`s are unique, and we still have 667 distinct species. 
+#
+# 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?
+
+# %%
+dedupe_species[cols].info(show_counts = True)
+
+# %%
+dedupe_species[cols].nunique()
+
+# %% [markdown]
+# We lost 17 locations, 24 genera, and 86 common names, but all datasets are still represented.
+
+# %%
+#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.
+
+# %%
+dedupe_species.to_csv("../data/lila_image_urls_and_labels_species.csv", index = True)
+
+# %% [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)?
+
+# %%
+dedupe_species['common_species_match'] = list(dedupe_species.common_name == dedupe_species.species)
+
+# %%
+dedupe_species['common_sciName_match'] = list(dedupe_species.common_name == dedupe_species.scientific_name)
+
+# %%
+dedupe_species.common_species_match.value_counts()
+
+# %%
+dedupe_species.common_sciName_match.value_counts()
+
+# %% [markdown]
+# Common name is not filled with scientific name or species values for any of these images.
+#
+# 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
+
+# %%
+#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.")
+
+# %% [markdown]
+# ## One Image per Species per Sequence
+#
+# 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.
+
+# %%
+dedupe_species['multi-image'] = dedupe_species.duplicated(subset = ['dataset_name', 'sequence_id', 'species', 'location_id'], keep = 'first')
+
+# %%
+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()
+
+# %% [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.")
+
+# %%
+#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.")
+
+# %% [markdown]
+# Let's look at the family distribution for these.
+
+# %%
+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')
+
+# %% [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.
+#
+# #### Caltech Camera Traps
+
+# %% [markdown]
+# Look up a couple sample file values in the model results JSON (with and without detection).
+
+# %%
+df.loc[df['url'].str.contains("cct_images/5862934b-23d2-11e8-a6a3-ec086b02610b")] 
+
+# %%
+df.loc[df['url'].str.contains("cct_images/5862934c-23d2-11e8-a6a3-ec086b02610b.jpg")] 
+
+# %%
+df.loc[df['url'].str.contains("cct_images/5874d5d3-23d2-11e8-a6a3-ec086b02610b.jpg")] 
+
+# %%
+import json
+
+# %%
+dedupe_species.dataset_name.value_counts()
+
+# %% [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.
+
+# %%
+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"}
+
+
+# %%
+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
+
+
+# %% [markdown]
+# ### Earlier check on `[]`
+
+# %%
+with open("../MegaDetector_results/caltech-camera-traps_mdv5a.0.0_results.json") as file:
+    data = json.load(file)
+
+# %%
+data
+
+# %%
+cct_mdv5a = pd.json_normalize(data["images"], max_level = 1)
+
+# %%
+cct_mdv5a.head(10)
+
+# %% [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.
+
+# %%
+len(cct_mdv5a)
+
+# %%
+type(cct_mdv5a.detections[5])
+
+# %%
+cct_mdv5a.loc[cct_mdv5a['detections'].astype(str) == '[]']
+
+# %%
+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
+
+# %% [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.
+
+# %%
+with open("../MegaDetector_results/wcs-camera-traps_animals_mdv5a.0.0_results.json") as file:
+    data = json.load(file)
+
+# %%
+data
+
+# %% [markdown]
+# Looks like formatting is consistent
+
+# %%
+wcs_mdv5a = pd.json_normalize(data["images"], max_level = 1)
+
+# %%
+wcs_mdv5a.head()
+
+# %%
+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
+
+# %% [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.
+
+# %%
+with open("../MegaDetector_results/wcs-camera-traps_animals_mdv5b.0.0_results.json") as file:
+    data = json.load(file)
+
+# %%
+wcs_mdv5b = pd.json_normalize(data["images"], max_level = 1)
+wcs_mdv5b.head()
+
+# %%
+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
+
+# %% [markdown]
+# #### NACTI
+
+# %%
+with open("../MegaDetector_results/nacti_mdv5b.0.0_results.json") as file:
+    data = json.load(file)
+
+# %%
+nacti_mdv5b = pd.json_normalize(data["images"], max_level = 1)
+nacti_mdv5b.head()
+
+# %%
+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)
+
+dedupe_nacti_empties
+
+
+# %% [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.
+
+# %%
+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
+
+
+# %%
+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"}
+
+
+# %%
+empties = {}
+for key in list(mdv5b_files.keys()):
+    empties[key] = check_md_results(key, mdv5b_files[key])
+
+# %%
+empties
+
+# %% [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/).
+
+# %%
+#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")
+
+# %%
+mdv4_empties = {}
+for file in mdv4_files:
+    mdv4_empties[file] = check_md_results("Snapshot Serengeti", file)
+
+# %%
+#only ran first 4
+for file in mdv4_files[4:]:
+    mdv4_empties[file] = check_md_results("Snapshot Serengeti", file)
+
+# %% [markdown]
+#
+
+# %%
+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])
+
+# %%
+len(serengeti_df_mdv4)
+
+# %%