Update BirdSet.py

BirdSet.py

@@ -11,26 +11,27 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# TODO: Address all TODOs and remove all explanatory comments
 """BirdSet: The General Avian Monitoring Evaluation Benchmark"""
 
 import os
 import datasets
 import pandas as pd
-import numpy as np
+from tqdm.auto import tqdm
+import tarfile
+
+from . import classes
 
 from .classes import BIRD_NAMES_NIPS4BPLUS, BIRD_NAMES_AMAZON_BASIN, BIRD_NAMES_HAWAII, \
     BIRD_NAMES_HIGH_SIERRAS, BIRD_NAMES_SIERRA_NEVADA, BIRD_NAMES_POWDERMILL_NATURE, BIRD_NAMES_SAPSUCKER, \
     BIRD_NAMES_COLUMBIA_COSTA_RICA, BIRD_NAMES_XENOCANTO, BIRD_NAMES_XENOCANTO_M
 
-from . import classes
-
-from .descriptions import _BIRD_DB_CITATION, _NIPS4BPLUS_CITATION, _NIPS4BPLUS_DESCRIPTION, \
+from .descriptions import _NIPS4BPLUS_CITATION, _NIPS4BPLUS_DESCRIPTION, \
     _HIGH_SIERRAS_DESCRIPTION, _HIGH_SIERRAS_CITATION, _SIERRA_NEVADA_DESCRIPTION, _SIERRA_NEVADA_CITATION, \
     _POWDERMILL_NATURE_DESCRIPTION, _POWDERMILL_NATURE_CITATION, _AMAZON_BASIN_DESCRIPTION, _AMAZON_BASIN_CITATION, \
     _SAPSUCKER_WOODS_DESCRIPTION, _SAPSUCKER_WOODS_CITATION, _COLUMBIA_COSTA_RICA_CITATION, \
     _COLUMBIA_COSTA_RICA_DESCRIPTION, _HAWAIIAN_ISLANDS_CITATION, _HAWAIIAN_ISLANDS_DESCRIPTION
 
+
 #############################################
 _BIRDSET_CITATION = """\
     @article{birdset,
@@ -50,6 +51,44 @@ _BIRDSET_DESCRIPTION = """\
 base_url = "https://huggingface.co/datasets/DBD-research-group/BirdSet/resolve/data"
 
 
+def _extract_all_to_same_folder(tar_path, output_dir):
+    """custom extraction for tar.gz files, that extracts all files to output_dir without subfolders"""
+    # check if data already exists
+    if not os.path.isfile(output_dir) and os.path.isdir(output_dir) and os.listdir(output_dir):
+        return output_dir
+    os.makedirs(output_dir, exist_ok=True)
+
+    with tarfile.open(tar_path, "r:gz") as tar:
+        for member in tar.getmembers():
+            if member.isfile():
+                member.name = os.path.basename(member.name)
+                tar.extract(member, path=output_dir)
+
+    return output_dir
+
+
+def _extract_and_delete(dl_dir: dict) -> dict:
+    """extracts downloaded files and deletes the archive file immediately, with progress bar.
+    only the processed archive and its content are saved at the same time."""
+    audio_paths = {name: [] for name, data in dl_dir.items() if isinstance(data, list)}
+    for name, data in dl_dir.items():
+        if not isinstance(data, list):
+            continue
+
+        # extract and immediately delete archives
+        for path in tqdm(data, f"Extracting {name} split"):
+            head, tail = os.path.split(path)
+            output_dir = os.path.join(head, "extracted", tail)
+            #audio_path = dl_manager.extract(path) # if all archive files are without subfolders this works just fine
+            audio_path = _extract_all_to_same_folder(path, output_dir)
+            os.remove(path)
+            os.remove(f"{path}.lock")
+            os.remove(f"{path}.json")
+            audio_paths[name].append(audio_path)
+
+    return audio_paths
+
+
 class BirdSetConfig(datasets.BuilderConfig):
     def __init__(
             self,
@@ -375,6 +414,7 @@ class BirdSet(datasets.GeneratorBasedBuilder):
 
     def _split_generators(self, dl_manager):
         ds_name = self.config.name
+        # settings for how much archives (tar.gz) files are uploaded for a specific dataset
         train_files = {"PER": 11,
                        "NES": 13,
                        "UHH": 5,
@@ -395,7 +435,7 @@ class BirdSet(datasets.GeneratorBasedBuilder):
                       "SSW": 36,
                       "SNE": 5}
 
-        test5s_files = {"PER": 1,
+        test_5s_files = {"PER": 1,
                       "NES": 1,
                       "UHH": 1,
                       "HSN": 1,
@@ -404,160 +444,116 @@ class BirdSet(datasets.GeneratorBasedBuilder):
                       "SSW": 4,
                       "SNE": 1}
 
+        # different configs, determine what needs to be downloaded
         if self.config.name.endswith("_xc"):
             ds_name = ds_name[:-3]
             dl_dir = dl_manager.download({
                 "train": [os.path.join(self.config.data_dir, f"{ds_name}_train_shard_{n:04d}.tar.gz") for n in range(1, train_files[ds_name] + 1)],
-                "metadata": os.path.join(self.config.data_dir, f"{ds_name}_metadata_train.parquet"),
+                "meta_train": os.path.join(self.config.data_dir, f"{ds_name}_metadata_train.parquet"),
             })
 
         elif self.config.name.endswith("_scape"):
             ds_name = ds_name[:-6]
             dl_dir = dl_manager.download({
                 "test": [os.path.join(self.config.data_dir, f"{ds_name}_test_shard_{n:04d}.tar.gz") for n in range(1, test_files[ds_name] + 1)],
-                "test_5s": [os.path.join(self.config.data_dir, f"{ds_name}_test5s_shard_{n:04d}.tar.gz") for n in range(1, test5s_files[ds_name] + 1)],
-                "metadata": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test.parquet"),
-                "metadata_5s": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test_5s.parquet"),
+                "test_5s": [os.path.join(self.config.data_dir, f"{ds_name}_test5s_shard_{n:04d}.tar.gz") for n in range(1, test_5s_files[ds_name] + 1)],
+                "meta_test": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test.parquet"),
+                "meta_test_5s": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test_5s.parquet"),
             })
 
         # use POW for XCM/XCL validation
         elif self.config.name.startswith("XC"):
             dl_dir = dl_manager.download({
                 "train": [os.path.join(self.config.data_dir, f"{ds_name}_shard_{n:04d}.tar.gz") for n in range(1, train_files[ds_name] + 1)],
-                "valid": [os.path.join(self.config.data_dir[:-3] + "POW", f"POW_test5s_shard_{n:04d}.tar.gz") for n in range(1, test5s_files["POW"] + 1)],
-                "metadata": os.path.join(self.config.data_dir, f"{ds_name}_metadata.parquet"),
-                "meta_test_5s": os.path.join(self.config.data_dir[:-3] + "POW", f"POW_metadata_test_5s.parquet"),
+                "valid": [os.path.join(self.config.data_dir[:-3] + "POW", f"POW_test5s_shard_{n:04d}.tar.gz") for n in range(1, test_5s_files["POW"] + 1)],
+                "meta_train": os.path.join(self.config.data_dir, f"{ds_name}_metadata.parquet"),
+                "meta_valid": os.path.join(self.config.data_dir[:-3] + "POW", f"POW_metadata_test_5s.parquet"),
             })
 
-        elif self.config.name in train_files.keys():
+        else:
             dl_dir = dl_manager.download({
                 "train": [os.path.join(self.config.data_dir, f"{ds_name}_train_shard_{n:04d}.tar.gz") for n in range(1, train_files[ds_name] + 1)],
                 "test": [os.path.join(self.config.data_dir, f"{ds_name}_test_shard_{n:04d}.tar.gz") for n in range(1, test_files[ds_name] + 1)],
-                "test_5s": [os.path.join(self.config.data_dir, f"{ds_name}_test5s_shard_{n:04d}.tar.gz") for n in range(1, test5s_files[ds_name] + 1)],
+                "test_5s": [os.path.join(self.config.data_dir, f"{ds_name}_test5s_shard_{n:04d}.tar.gz") for n in range(1, test_5s_files[ds_name] + 1)],
                 "meta_train": os.path.join(self.config.data_dir, f"{ds_name}_metadata_train.parquet"),
                 "meta_test": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test.parquet"),
                 "meta_test_5s": os.path.join(self.config.data_dir, f"{ds_name}_metadata_test_5s.parquet"),
             })
 
-        # TODO no more extraction
-        #local_audio_archives_paths = dl_manager.extract(dl_dir) if not dl_manager.is_streaming else None
-        #local_audio_archives_paths = dl_manager.iter_archive(dl_dir)
-
-        if self.config.name.startswith("XC") or self.config.name.endswith("_xc"):
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["train"]],
-                        #"local_audio_archives_paths": local_audio_archives_paths["train"] if local_audio_archives_paths else None,
-                        "metapath": dl_dir["metadata"],
-                        "split": datasets.Split.TRAIN,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name="valid",
-                    gen_kwargs={
-                        "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["valid"]],
-                        #"local_audio_archives_paths": local_audio_archives_paths["valid"] if local_audio_archives_paths else None,
-                        "metapath": dl_dir["meta_test_5s"],
-                        "split": "valid",
-                    },
-                ),
-            ]
+        # custom extraction that deletes archives right after extraction
+        audio_paths = _extract_and_delete(dl_dir) if not dl_manager.is_streaming else None
+
+        # construct split generators
+        # assumes every key in dl_dir of NAME also has meta_NAME
+        names = [name for name in dl_dir.keys() if not name.startswith("meta_")]
+        is_streaming = dl_manager.is_streaming
+
+        return [datasets.SplitGenerator(
+            name=name,
+            gen_kwargs={
+                "audio_archive_iterators": (dl_manager.iter_archive(archive_path) for archive_path in dl_dir[name]) if is_streaming else () ,
+                "audio_extracted_paths": audio_paths[name] if not is_streaming else (),
+                "meta_path": dl_dir[f"meta_{name}"],
+                "split": name
+            }
+        ) for name in names]
+
+
+    def _generate_examples(self, audio_archive_iterators, audio_extracted_paths, meta_path, split):
+        metadata = pd.read_parquet(meta_path)
+        if metadata.index.name != "filepath":  # TODO could be removed by changing train metadata files to have filepath as index
+            metadata.index = metadata["filepath"].str.split("/").apply(lambda x: x[-1]) # TODO work around for update_1 inconsistent filepath
 
-        elif self.config.name.endswith("_scape"):
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["test"]],
-                        #"local_audio_archives_paths": local_audio_archives_paths["test"] if local_audio_archives_paths else None,
-                        "metapath": dl_dir["metadata"],
-                        "split": datasets.Split.TEST,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name="test_5s",
-                    gen_kwargs={
-                        "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["test_5s"]],
-                        #"local_audio_archives_paths": local_audio_archives_paths["test_5s"] if local_audio_archives_paths else None,
-                        "metapath": dl_dir["metadata_5s"],
-                        "split": "test_multilabel"
-                    },
-                ),
-            ]
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["train"]],
-                    #"local_audio_archives_paths": local_audio_archives_paths["train"] if local_audio_archives_paths else None,
-                    "metapath": dl_dir["meta_train"],
-                    "split": datasets.Split.TRAIN,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["test"]],
-                    #"local_audio_archives_paths": local_audio_archives_paths["test"] if local_audio_archives_paths else None,
-                    "metapath": dl_dir["meta_test"],
-                    "split": datasets.Split.TEST,
-                },
-            ),
-            datasets.SplitGenerator(
-                name="test_5s",
-                gen_kwargs={
-                    "audio_archive_iterators": [dl_manager.iter_archive(archive_path) for archive_path in dl_dir["test_5s"]],
-                    #"local_audio_archives_paths": local_audio_archives_paths["test_5s"] if local_audio_archives_paths else None,
-                    "metapath": dl_dir["meta_test_5s"],
-                    "split": "test_multilabel"
-                },
-            ),
-        ]
-
-    def _generate_examples(self, audio_archive_iterators, metapath, split):
-        metadata = pd.read_parquet(metapath)
         idx = 0
-        for i, audio_archive_iterator in enumerate(audio_archive_iterators):
+        # in case of streaming
+        for audio_archive_iterator in audio_archive_iterators:
             for audio_path_in_archive, audio_file in audio_archive_iterator:
-                id = os.path.split(audio_path_in_archive)[-1]
-                rows = metadata[metadata.index == (int(id[2:].split(".")[0]) if split == "train" else id)]
-                audio_path = audio_path_in_archive
-
+                file_name = os.path.split(audio_path_in_archive)[-1]
+                rows = metadata.loc[[file_name]]
+                audio = audio_file.read()
                 for _, row in rows.iterrows():
-                    idx += 1
-                    yield id if split == "train" else idx, {
-                        "audio": audio_file.read(),
-                        "filepath": audio_path,
-                        "start_time": row["start_time"],
-                        "end_time": row["end_time"],
-                        "low_freq": row["low_freq"],
-                        "high_freq": row["high_freq"],
-                        "ebird_code": row["ebird_code"] if split != "test_multilabel" else None,
-                        "ebird_code_multilabel": row.get("ebird_code_multilabel", None) if "no_call" not in row.get("ebird_code_multilabel", []) else [],
-                        "ebird_code_secondary": row.get("ebird_code_secondary", None),
-                        "call_type": row["call_type"],
-                        "sex": row["sex"],
-                        "lat": row["lat"],
-                        "long": row["long"],
-                        "length": row.get("length", None),
-                        "microphone": row["microphone"],
-                        "license": row.get("license", None),
-                        "source": row["source"],
-                        "local_time": row["local_time"],
-                        "detected_events": row.get("detected_events", None),
-                        "event_cluster": row.get("event_cluster", None),
-                        "peaks": row.get("peaks", None),
-                        "quality": row.get("quality", None),
-                        "recordist": row.get("recordist", None),
-                        "genus": row.get("genus", None),
-                        "species_group": row.get("species_group", None),
-                        "order": row.get("order", None),
-                        "genus_multilabel": row.get("genus_multilabel", None),
-                        "species_group_multilabel": row.get("species_group_multilabel", None),
-                        "order_multilabel": row.get("order_multilabel", None),
-                    }
-
-            os.remove(audio_archive_iterator.args[0])
+                    yield idx, self._metadata_from_row(row, split, audio_path=file_name, audio=audio)
+                idx += 1
+
+        # in case of not streaming
+        for audio_extracted_path in audio_extracted_paths:
+            audio_files = os.listdir(audio_extracted_path)
+            current_metadata = metadata.loc[audio_files]
+            for audio_file, row in current_metadata.iterrows():
+                audio_path = os.path.join(audio_extracted_path, audio_file)
+                yield idx, self._metadata_from_row(row, split, audio_path=audio_path)
+                idx += 1
+
+
+    @staticmethod
+    def _metadata_from_row(row, split: str, audio_path=None, audio=None) -> dict:
+        return {"audio": audio_path if not audio else {"path": None, "bytes": audio},
+                "filepath": audio_path,
+                "start_time": row["start_time"],
+                "end_time": row["end_time"],
+                "low_freq": row["low_freq"],
+                "high_freq": row["high_freq"],
+                "ebird_code": row["ebird_code"] if split != "test_5s" else None,
+                "ebird_code_multilabel": row.get("ebird_code_multilabel", None),
+                "ebird_code_secondary": row.get("ebird_code_secondary", None),
+                "call_type": row["call_type"],
+                "sex": row["sex"],
+                "lat": row["lat"],
+                "long": row["long"],
+                "length": row.get("length", None),
+                "microphone": row["microphone"],
+                "license": row.get("license", None),
+                "source": row["source"],
+                "local_time": row["local_time"],
+                "detected_events": row.get("detected_events", None),
+                "event_cluster": row.get("event_cluster", None),
+                "peaks": row.get("peaks", None),
+                "quality": row.get("quality", None),
+                "recordist": row.get("recordist", None),
+                "genus": row.get("genus", None) if split != "test_5s" else None,
+                "species_group": row.get("species_group", None) if split != "test_5s" else None,
+                "order": row.get("order", None) if split != "test_5s" else None,
+                "genus_multilabel": row.get("genus_multilabel", [row.get("genus")]),
+                "species_group_multilabel": row.get("species_group_multilabel", [row.get("species_group")]),
+                "order_multilabel": row.get("order_multilabel", [row.get("order")]),
+            }