Create magnatagatune.py

magnatagatune.py

@@ -0,0 +1,322 @@
+# coding=utf-8
+
+"""MagnaTagATune dataset."""
+
+
+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
+
+logger = logging.getLogger(__name__)
+logger.addHandler(RichHandler())
+logger.setLevel(logging.INFO)
+
+SAMPLE_RATE = 32_000
+
+# 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))
+
+TOP_50_CLASSES = [
+    'ambient', 'beat', 'beats', 'cello', 'choir', 'choral', 'classic', 'classical', 'country', 'dance', 
+    'drums', 'electronic', 'fast', 'female', 'female vocal', 'female voice', 'flute',  'guitar', 'harp', 'harpsichord', 
+    'indian', 'loud', 'male', 'male vocal', 'male voice', 'man',  'metal', 'new age', 'no vocal', 'no vocals', 
+    'no voice', 'opera', 'piano', 'pop', 'quiet',  'rock', 'singing', 'sitar', 'slow', 'soft', 
+    'solo', 'strings', 'synth', 'techno', 'violin',  'vocal', 'vocals', 'voice', 'weird', 'woman'
+]
+CLASS2INDEX = {cls:idx for idx, cls in enumerate(TOP_50_CLASSES)}
+INDEX2CLASS = {idx:cls for idx, cls in enumerate(TOP_50_CLASSES)}
+
+
+class MagnaTagATuneConfig(datasets.BuilderConfig):
+    """BuilderConfig for MagnaTagATune."""
+    
+    def __init__(self, features, **kwargs):
+        super(MagnaTagATuneConfig, self).__init__(version=datasets.Version(VERSION, ""), **kwargs)
+        self.features = features
+
+
+class MagnaTagATune(datasets.GeneratorBasedBuilder):
+
+    BUILDER_CONFIGS = [
+        MagnaTagATuneConfig(
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "audio": datasets.Audio(sampling_rate=SAMPLE_RATE),
+                    "tags": datasets.Sequence(datasets.Value("string")), 
+                    "label": datasets.Sequence(datasets.features.ClassLabel(names=TOP_50_CLASSES)), 
+                }
+            ),
+            name="top50", 
+            description="",
+        ), 
+    ]
+
+    DEFAULT_CONFIG_NAME = "top50"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description="",
+            features=self.config.features,
+            supervised_keys=None,
+            homepage="",
+            citation="",
+            task_templates=None,
+        )
+
+    def _load_metadata(self):
+        # Read metadata
+        df = pd.read_csv("https://mirg.city.ac.uk/datasets/magnatagatune/annotations_final.csv", sep="\t")
+        df = df[df[TOP_50_CLASSES].sum(axis=1) > 0]
+        df = df[TOP_50_CLASSES + ["mp3_path", "clip_id"]]
+        
+        train_ids_df = pd.read_csv(
+            'https://raw.githubusercontent.com/jordipons/musicnn-training/master/data/index/mtt/train_gt_mtt.tsv', 
+            sep='\t', header=None
+        )
+        train_ids = train_ids_df[0].tolist()
+        train_df = df[df["clip_id"].isin(train_ids)]
+
+        validation_ids_df = pd.read_csv(
+            "https://raw.githubusercontent.com/jordipons/musicnn-training/master/data/index/mtt/val_gt_mtt.tsv", 
+            sep="\t", header=None
+        )
+        validation_ids = validation_ids_df[0].tolist()
+        validation_df = df[df["clip_id"].isin(validation_ids)]
+
+        test_ids_df = pd.read_csv(
+            "https://raw.githubusercontent.com/jordipons/musicnn-training/master/data/index/mtt/test_gt_mtt.tsv", 
+            sep="\t", header=None
+        )
+        test_ids = test_ids_df[0].tolist()
+        test_df = df[df["clip_id"].isin(test_ids)]
+        
+        label_names = df.columns
+        label_names = label_names.drop(["mp3_path", "clip_id"])
+
+        return train_df, validation_df, test_df, label_names
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        if self.config.name == 'top50':
+            mp3_zip_files = [
+                'https://mirg.city.ac.uk/datasets/magnatagatune/mp3.zip.001', 
+                'https://mirg.city.ac.uk/datasets/magnatagatune/mp3.zip.002', 
+                'https://mirg.city.ac.uk/datasets/magnatagatune/mp3.zip.003', 
+            ]
+            for zip_file_url in mp3_zip_files:
+                _filename = zip_file_url.split('/')[-1]
+                _save_path = os.path.join(
+                    HF_DATASETS_CACHE, 'confit___magnatagatune/top50', VERSION, _filename
+                )
+                download_file(zip_file_url, _save_path)
+                logger.info(f"`{_filename}` is downloaded to {_save_path}")
+
+            main_zip_filename = 'mp3.zip'
+            _save_dir = os.path.join(HF_DATASETS_CACHE, 'confit___magnatagatune/top50', VERSION)
+            _output_file = os.path.join(_save_dir, main_zip_filename)
+            
+            if not os.path.exists(_output_file):
+                logger.info(f"Concatenate zip files to {main_zip_filename}")
+                os.system(f"cat {os.path.join(_save_dir, 'mp3.zip.*')} > {_output_file}")
+
+            archive_path = dl_manager.extract(_output_file)
+            logger.info(f"`{main_zip_filename}` is now extracted to {archive_path}")
+        
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN, gen_kwargs={"archive_path": archive_path, "split": "train"}
+            ), 
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION, gen_kwargs={"archive_path": archive_path, "split": "validation"}
+            ), 
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": "test"}
+            ), 
+        ]
+
+    def _generate_examples(self, archive_path, split=None, metadata_df=None):
+        train_df, validation_df, test_df, label_names = self._load_metadata()
+        extensions = ['.mp3']
+        _, _walker = fast_scandir(archive_path, extensions, recursive=True)
+
+        class2index = {cls:idx for idx, cls in enumerate(label_names)}
+        index2class = {idx:cls for idx, cls in enumerate(label_names)}
+
+        if split == 'train':
+            fileid2class = {}
+            for idx, row in train_df.iterrows():
+                fileid = row['mp3_path']
+                class_ = row[label_names].tolist()
+                if len(class_) == 0:
+                    continue
+                class_ = [index2class.get(idx) for idx in class_]
+                fileid2class[fileid] = class_
+        elif split == 'validation':
+            fileid2class = {}
+            for idx, row in validation_df.iterrows():
+                fileid = row['mp3_path']
+                class_ = row[label_names].tolist()
+                if len(class_) == 0:
+                    continue
+                class_ = [index2class.get(idx) for idx in class_]
+                fileid2class[fileid] = class_
+        elif split == 'test':
+            fileid2class = {}
+            for idx, row in test_df.iterrows():
+                fileid = row['mp3_path']
+                class_ = row[label_names].tolist()
+                if len(class_) == 0:
+                    continue
+                class_ = [index2class.get(idx) for idx in class_]
+                fileid2class[fileid] = class_
+
+        for guid, audio_path in enumerate(_walker):
+            tags = fileid2class.get(Path(audio_path).stem)
+            yield guid, {
+                "id": str(guid),
+                "file": audio_path, 
+                "audio": audio_path, 
+                "tags": tags, 
+                "label": tags, 
+            }
+
+
+def fast_scandir(path: str, exts: tp.List[str], recursive: bool = False):
+    # Scan files recursively faster than glob
+    # From github.com/drscotthawley/aeiou/blob/main/aeiou/core.py
+    subfolders, files = [], []
+
+    try:  # hope to avoid 'permission denied' by this try
+        for f in os.scandir(path):
+            try:  # 'hope to avoid too many levels of symbolic links' error
+                if f.is_dir():
+                    subfolders.append(f.path)
+                elif f.is_file():
+                    if os.path.splitext(f.name)[1].lower() in exts:
+                        files.append(f.path)
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    if recursive:
+        for path in list(subfolders):
+            sf, f = fast_scandir(path, exts, recursive=recursive)
+            subfolders.extend(sf)
+            files.extend(f)  # type: ignore
+
+    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)