Update audioset.py

audioset.py

@@ -5,14 +5,25 @@
 
 import os
 import json
+import gzip
+import shutil
+import pathlib
+import logging
 import textwrap
 import datasets
 import itertools
 import typing as tp
 import pandas as pd
+import urllib.request
 from pathlib import Path
+from copy import deepcopy
+from tqdm.auto import tqdm
+from rich.logging import RichHandler
 from huggingface_hub import hf_hub_download
 
+logger = logging.getLogger(__name__)
+logger.addHandler(RichHandler())
+logger.setLevel(logging.INFO)
 
 SAMPLE_RATE = 32_000
 
@@ -27,6 +38,15 @@ ID2LABEL = json.load(
 LABEL2ID = {v:k for k, v in ID2LABEL.items()}
 CLASSES = list(set(LABEL2ID.keys()))
 
+# Cache location
+VERSION = "0.0.1"
+DEFAULT_XDG_CACHE_HOME = "~/.cache"
+XDG_CACHE_HOME = os.getenv("XDG_CACHE_HOME", DEFAULT_XDG_CACHE_HOME)
+DEFAULT_HF_CACHE_HOME = os.path.join(XDG_CACHE_HOME, "huggingface")
+HF_CACHE_HOME = os.path.expanduser(os.getenv("HF_HOME", DEFAULT_HF_CACHE_HOME))
+DEFAULT_HF_DATASETS_CACHE = os.path.join(HF_CACHE_HOME, "datasets")
+HF_DATASETS_CACHE = Path(os.getenv("HF_DATASETS_CACHE", DEFAULT_HF_DATASETS_CACHE))
+
 
 class AudioSetConfig(datasets.BuilderConfig):
     """BuilderConfig for AudioSet."""
@@ -51,6 +71,18 @@ class AudioSet(datasets.GeneratorBasedBuilder):
             name="balanced", 
             description="",
         ), 
+        AudioSetConfig(
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "audio": datasets.Audio(sampling_rate=SAMPLE_RATE),
+                    "sound": datasets.Sequence(datasets.Value("string")), 
+                    "label": datasets.Sequence(datasets.features.ClassLabel(names=CLASSES)), 
+                }
+            ),
+            name="unbalanced-part00", 
+            description="",
+        ), 
     ]
 
     DEFAULT_CONFIG_NAME = "balanced"
@@ -77,14 +109,34 @@ class AudioSet(datasets.GeneratorBasedBuilder):
     def _split_generators(self, dl_manager):
         """Returns SplitGenerators."""
         if self.config.name == 'balanced':
-            archive_path = dl_manager.extract(_BALANCED_TRAIN_FILENAME)
-        elif self.config.name == 'unbalanced':
-            archive_path = dl_manager.extract(_UNBALANCED_TRAIN_FILENAME)
+            train_archive_path = dl_manager.extract(_BALANCED_TRAIN_FILENAME)
+            
+        elif self.config.name == 'unbalanced-part00':
+            for zip_type in ['zip', 'z01', 'z02']:
+                _UNBALANCED_TRAIN_FILENAME = f'unbalanced_train_segments_part00_partial.{zip_type}'
+                zip_file_url = f'https://huggingface.co/datasets/confit/audioset/resolve/main/unbalanced/{_UNBALANCED_TRAIN_FILENAME}'
+                _save_path = os.path.join(
+                    HF_DATASETS_CACHE, 'confit___audioset/unbalanced', VERSION, _UNBALANCED_TRAIN_FILENAME
+                )
+                download_file(zip_file_url, _save_path)
+                logger.info(f"`{_UNBALANCED_TRAIN_FILENAME}` is downloaded to {_save_path}")
+
+            main_zip_filename = 'unbalanced_train_segments_part00_partial.zip'
+            concat_zip_filename = 'unbalanced_train_segments_part00_full.zip'
+            _input_file = os.path.join(HF_DATASETS_CACHE, 'confit___audioset/unbalanced', VERSION, main_zip_filename)
+            _output_file = os.path.join(HF_DATASETS_CACHE, 'confit___audioset/unbalanced', VERSION, concat_zip_filename)
+            
+            if not os.path.exists(_output_file):
+                logger.info(f"Reassemble {_output_file} file")
+                os.system(f"zip -q -F {_input_file} --out {_output_file}")
+            train_archive_path = dl_manager.extract(_output_file)
+            logger.info(f"`{concat_zip_filename}` is downloaded to {train_archive_path}")
+        
         test_archive_path = dl_manager.extract(_EVAL_FILENAME)
         
         return [
             datasets.SplitGenerator(
-                name=datasets.Split.TRAIN, gen_kwargs={"archive_path": archive_path, "split": "train"}
+                name=datasets.Split.TRAIN, gen_kwargs={"archive_path": train_archive_path, "split": "train"}
             ), 
             datasets.SplitGenerator(
                 name=datasets.Split.TEST, gen_kwargs={"archive_path": test_archive_path, "split": "test"}
@@ -159,4 +211,98 @@ def fast_scandir(path: str, exts: tp.List[str], recursive: bool = False):
             subfolders.extend(sf)
             files.extend(f)  # type: ignore
 
-    return subfolders, files
+    return subfolders, files
+
+
+def download_file(
+    source,
+    dest,
+    unpack=False,
+    dest_unpack=None,
+    replace_existing=False,
+    write_permissions=False,
+):
+    """Downloads the file from the given source and saves it in the given
+    destination path.
+     Arguments
+    ---------
+    source : path or url
+        Path of the source file. If the source is an URL, it downloads it from
+        the web.
+    dest : path
+        Destination path.
+    unpack : bool
+        If True, it unpacks the data in the dest folder.
+    dest_unpack: path
+        Path where to store the unpacked dataset
+    replace_existing : bool
+        If True, replaces the existing files.
+    write_permissions: bool
+        When set to True, all the files in the dest_unpack directory will be granted write permissions.
+        This option is active only when unpack=True.
+    """
+    class DownloadProgressBar(tqdm):
+        """DownloadProgressBar class."""
+
+        def update_to(self, b=1, bsize=1, tsize=None):
+            """Needed to support multigpu training."""
+            if tsize is not None:
+                self.total = tsize
+            self.update(b * bsize - self.n)
+
+    # Create the destination directory if it doesn't exist
+    dest_dir = pathlib.Path(dest).resolve().parent
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    if "http" not in source:
+        shutil.copyfile(source, dest)
+
+    elif not os.path.isfile(dest) or (
+        os.path.isfile(dest) and replace_existing
+    ):
+        print(f"Downloading {source} to {dest}")
+        with DownloadProgressBar(
+            unit="B",
+            unit_scale=True,
+            miniters=1,
+            desc=source.split("/")[-1],
+        ) as t:
+            urllib.request.urlretrieve(
+                source, filename=dest, reporthook=t.update_to
+            )
+    else:
+        print(f"{dest} exists. Skipping download")
+
+    # Unpack if necessary
+    if unpack:
+        if dest_unpack is None:
+            dest_unpack = os.path.dirname(dest)
+        print(f"Extracting {dest} to {dest_unpack}")
+        # shutil unpack_archive does not work with tar.gz files
+        if (
+            source.endswith(".tar.gz")
+            or source.endswith(".tgz")
+            or source.endswith(".gz")
+        ):
+            out = dest.replace(".gz", "")
+            with gzip.open(dest, "rb") as f_in:
+                with open(out, "wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+        else:
+            shutil.unpack_archive(dest, dest_unpack)
+        if write_permissions:
+            set_writing_permissions(dest_unpack)
+
+
+def set_writing_permissions(folder_path):
+    """
+    This function sets user writing permissions to all the files in the given folder.
+    Arguments
+    ---------
+    folder_path : folder
+        Folder whose files will be granted write permissions.
+    """
+    for root, dirs, files in os.walk(folder_path):
+        for file_name in files:
+            file_path = os.path.join(root, file_name)
+            # Set writing permissions (mode 0o666) to the file
+            os.chmod(file_path, 0o666)