Update WABAD.py

WABAD.py

@@ -1,72 +1,216 @@
-import datasets
-import pandas as pd
-import os
-import ast
-
-
-class WABADBuilderConfig(datasets.BuilderConfig):
-    def __init__(self, location_dir, **kwargs):
-        super().__init__(**kwargs)
-        self.location_dir = location_dir
-
-class WABADDataset(datasets.GeneratorBasedBuilder):
-    BUILDER_CONFIGS = [
-        WABADBuilderConfig(name="BAM", location_dir="BAM", description="BAM location"),
-        WABADBuilderConfig(name="ARD", location_dir="ARD", description="ARD location"),
-        # add more locations here
-    ]
-
-    def _info(self):
-        return datasets.DatasetInfo(
-            features=datasets.Features({
-                "audio": datasets.Audio(), 
-                "labels": datasets.Sequence(datasets.Value("int32")),
-                "site_ID": datasets.Value("string"),
-                # any other metadata
-            })
-        )
-
-    def _split_generators(self, dl_manager):
-        config_dir = self.config.location_dir
-        
-        # Use the correct dataset URL format and download specific files
-        train_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/{config_dir}_metadata_train.parquet"
-        test_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/{config_dir}_metadata_test.parquet"
-        
-        # Download the parquet files
-        train_file = dl_manager.download(train_url)
-        test_file = dl_manager.download(test_url)
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "parquet_file": train_file,
-                    "config_dir": config_dir
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "parquet_file": test_file,
-                    "config_dir": config_dir
-                },
-            )
-        ]
-
-    def _generate_examples(self, parquet_file, config_dir):
-        df = pd.read_parquet(parquet_file)
-        for idx, row in df.iterrows():
-            # Download audio file on demand
-            audio_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/audio/{os.path.basename(row['filepath'])}"
-
-            labels = row["labels"]
-            if isinstance(labels, str):
-                labels = ast.literal_eval(labels) 
-            
-            yield idx, { 
-                "audio": {"path": audio_url, "bytes": None},  # Let datasets handle the download
-                "labels": labels,
-                "site_ID": row.get("site_ID", self.config.name),
-                # other metadata
-            }
+import datasets
+import pandas as pd
+import os
+import ast
+import zipfile
+from pathlib import Path
+
+
+def _extract_zip_to_folder(zip_path, output_dir):
+    """Extract zip file to output directory, similar to BirdSet's tar extraction"""
+    # 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 zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        for member in zip_ref.infolist():
+            if not member.is_dir():
+                # Extract file to output directory
+                member.filename = os.path.basename(member.filename)
+                zip_ref.extract(member, path=output_dir)
+    
+    return output_dir
+
+
+def _extract_and_delete_zip(dl_dir: dict, cache_dir: str = None) -> dict:
+    """Extract downloaded zip files and delete archives immediately, similar to BirdSet"""
+    audio_paths = {name: [] for name, data in dl_dir.items() if name.startswith('audio_')}
+    
+    for name, data in dl_dir.items():
+        if not name.startswith('audio_'):
+            continue
+            
+        # Extract zip file
+        directory, filename = os.path.split(data)
+        output_dir = os.path.join(cache_dir or directory, "extracted", filename.split(".")[0])
+        audio_path = _extract_zip_to_folder(data, output_dir)
+        
+        # Clean up
+        os.remove(data)
+        # Remove lock files if they exist (datasets >3.0.0)
+        if os.path.exists(f"{data}.lock"):
+            os.remove(f"{data}.lock")
+        if os.path.exists(f"{data}.json"):
+            os.remove(f"{data}.json")
+            
+        # Store the base name without 'audio_' prefix
+        base_name = name.replace('audio_', '')
+        audio_paths[base_name] = audio_path
+    
+    return audio_paths
+
+
+class WABADBuilderConfig(datasets.BuilderConfig):
+    def __init__(self, location_dir, **kwargs):
+        super().__init__(**kwargs)
+        self.location_dir = location_dir
+
+
+class WABADDataset(datasets.GeneratorBasedBuilder):
+    """WABAD: World Acoustic Bird Audio Dataset"""
+    
+    # Batch size to prevent memory issues
+    DEFAULT_WRITER_BATCH_SIZE = 500
+    
+    BUILDER_CONFIGS = [
+        WABADBuilderConfig(name="BUR", location_dir="BUR", description="BUR location"),
+        # Add more locations here as needed
+    ]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description="WABAD: World Acoustic Bird Audio Dataset",
+            features=datasets.Features({
+                "audio": datasets.Audio(sampling_rate=48_000, mono=True, decode=False),
+                "filename": datasets.Value("string"),
+                "filepath": datasets.Value("string"),
+                "labels": datasets.Sequence(datasets.Value("int32")),
+                "species": datasets.Sequence(datasets.Value("string")),
+                "site_ID": datasets.Value("string"),
+                "study_area": datasets.Value("string"),
+                "recording_location": datasets.Value("string"),
+                "biome": datasets.Value("string"),
+                "latitude": datasets.Value("string"),
+                "longitude": datasets.Value("string"),
+                "recorder": datasets.Value("string"),
+                "omnidirectional": datasets.Value("string"),
+                "sampling_rate": datasets.Value("string"),
+                "recording_date": datasets.Value("string"),
+                "min_annotated": datasets.Value("int32"),
+                "contact": datasets.Value("string"),
+                "reference": datasets.Value("string"),
+            })
+        )
+
+    def _split_generators(self, dl_manager):
+        config_dir = self.config.location_dir
+        base_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}"
+        
+        # Download metadata and audio files
+        dl_dir = dl_manager.download({
+            "meta_train": f"{base_url}/{config_dir}_metadata_train.parquet",
+            "meta_test": f"{base_url}/{config_dir}_metadata_test.parquet",
+            "audio_train": f"{base_url}/audio.zip",  # Assuming same zip for both splits
+            "audio_test": f"{base_url}/audio.zip",
+        })
+        
+        # Extract zip files and clean up
+        audio_paths = _extract_and_delete_zip(dl_dir, dl_manager.download_config.cache_dir) if not dl_manager.is_streaming else {}
+        
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "audio_archive_iterator": dl_manager.iter_archive(dl_dir["audio_train"]) if dl_manager.is_streaming else None,
+                    "audio_extracted_path": audio_paths.get("train") if not dl_manager.is_streaming else None,
+                    "meta_path": dl_dir["meta_train"],
+                    "split": "train"
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "audio_archive_iterator": dl_manager.iter_archive(dl_dir["audio_test"]) if dl_manager.is_streaming else None,
+                    "audio_extracted_path": audio_paths.get("test") if not dl_manager.is_streaming else None,
+                    "meta_path": dl_dir["meta_test"],
+                    "split": "test"
+                },
+            )
+        ]
+
+    def _generate_examples(self, audio_archive_iterator, audio_extracted_path, meta_path, split):
+        # Load metadata
+        metadata = pd.read_parquet(meta_path)
+        if metadata.index.name != "filename":
+            # Set filename as index for easier lookup
+            if "filename" in metadata.columns:
+                metadata.index = metadata["filename"]
+            else:
+                # Fallback: extract filename from filepath
+                metadata.index = metadata["filepath"].apply(lambda x: os.path.basename(x))
+
+        idx = 0
+        
+        # Handle streaming case
+        if audio_archive_iterator:
+            for audio_path_in_archive, audio_file in audio_archive_iterator:
+                file_name = os.path.basename(audio_path_in_archive)
+                
+                # Find matching metadata rows
+                if file_name in metadata.index:
+                    rows = metadata.loc[[file_name]] if isinstance(metadata.loc[file_name], pd.Series) else metadata.loc[metadata.index == file_name]
+                    audio_bytes = audio_file.read()
+                    
+                    for _, row in (rows.to_frame().T if isinstance(rows, pd.Series) else rows).iterrows():
+                        yield idx, self._metadata_from_row(row, audio_bytes=audio_bytes)
+                        idx += 1
+        
+        # Handle non-streaming case
+        elif audio_extracted_path:
+            audio_files = os.listdir(audio_extracted_path)
+            
+            for audio_file in audio_files:
+                if audio_file in metadata.index:
+                    row_data = metadata.loc[audio_file]
+                    
+                    # Handle case where there might be multiple rows for same filename
+                    if isinstance(row_data, pd.DataFrame):
+                        for _, row in row_data.iterrows():
+                            audio_path = os.path.join(audio_extracted_path, audio_file)
+                            yield idx, self._metadata_from_row(row, audio_path=audio_path)
+                            idx += 1
+                    else:
+                        audio_path = os.path.join(audio_extracted_path, audio_file)
+                        yield idx, self._metadata_from_row(row_data, audio_path=audio_path)
+                        idx += 1
+
+    def _metadata_from_row(self, row, audio_path=None, audio_bytes=None):
+        """Convert metadata row to example format"""
+        # Parse labels if they're stored as strings
+        labels = row.get("labels", [])
+        if isinstance(labels, str):
+            try:
+                labels = ast.literal_eval(labels)
+            except (ValueError, SyntaxError):
+                labels = []
+        
+        # Parse species if it's stored as string
+        species = row.get("species", [])
+        if isinstance(species, str):
+            try:
+                species = ast.literal_eval(species)
+            except (ValueError, SyntaxError):
+                species = [species] if species else []
+        
+        return {
+            "audio": {"path": audio_path, "bytes": audio_bytes} if audio_bytes else audio_path,
+            "filename": row.get("filename", ""),
+            "filepath": row.get("filepath", ""),
+            "labels": labels,
+            "species": species,
+            "site_ID": row.get("site_ID", self.config.name),
+            "study_area": row.get("study_area", ""),
+            "recording_location": row.get("recording_location", ""),
+            "biome": row.get("biome", ""),
+            "latitude": str(row.get("latitude", "")),
+            "longitude": str(row.get("longitude", "")),
+            "recorder": row.get("recorder", ""),
+            "omnidirectional": row.get("omnidirectional", ""),
+            "sampling_rate": row.get("sampling_rate", ""),
+            "recording_date": str(row.get("recording_date", "")),
+            "min_annotated": int(row.get("min_annotated", 0)) if pd.notna(row.get("min_annotated")) else 0,
+            "contact": row.get("contact", ""),
+            "reference": row.get("reference", ""),
+        }