Create irmas.py

irmas.py

@@ -0,0 +1,157 @@
+# coding=utf-8
+
+"""IRMAS dataset."""
+
+import os
+import re
+import textwrap
+import datasets
+import itertools
+import typing as tp
+from pathlib import Path
+
+SAMPLE_RATE = 44_100
+
+_IRMAS_TRAIN_SET_URL = 'https://zenodo.org/record/1290750/files/IRMAS-TrainingData.zip'
+_IRMAS_TEST_SET_PART1_URL = 'https://zenodo.org/record/1290750/files/IRMAS-TestingData-Part1.zip'
+_IRMAS_TEST_SET_PART2_URL = 'https://zenodo.org/record/1290750/files/IRMAS-TestingData-Part2.zip'
+_IRMAS_TEST_SET_PART3_URL = 'https://zenodo.org/record/1290750/files/IRMAS-TestingData-Part3.zip'
+
+
+INSTRUMENTS = [
+    'cel', 'cla', 'flu', 'gac', 'gel', 'org', 'pia', 'sax', 'tru', 'vio', 'voi'
+]
+
+
+class IRMASConfig(datasets.BuilderConfig):
+    """BuilderConfig for IRMAS."""
+    
+    def __init__(self, features, **kwargs):
+        super(IRMASConfig, self).__init__(version=datasets.Version("0.0.1", ""), **kwargs)
+        self.features = features
+
+
+class IRMAS(datasets.GeneratorBasedBuilder):
+
+    BUILDER_CONFIGS = [
+        IRMASConfig(
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "audio": datasets.Audio(sampling_rate=SAMPLE_RATE),
+                    "instrument": datasets.Sequence(datasets.Value("string")),
+                    "label": datasets.Sequence(datasets.ClassLabel(names=INSTRUMENTS)),
+                }
+            ),
+            name="irmas", 
+            description=textwrap.dedent(
+                """\
+                IRMAS is intended to be used for training and testing methods for the automatic recognition of predominant instruments in musical audio. 
+                The instruments considered are: cello, clarinet, flute, acoustic guitar, electric guitar, organ, piano, saxophone, trumpet, violin, and human singing voice.
+                """
+            ),
+        ), 
+    ]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description="",
+            features=self.config.features,
+            supervised_keys=None,
+            homepage="https://zenodo.org/records/1290750",
+            citation="""
+                @inproceedings{bosch2012comparison,
+                  title={A Comparison of Sound Segregation Techniques for Predominant Instrument Recognition in Musical Audio Signals.},
+                  author={Bosch, Juan J and Janer, Jordi and Fuhrmann, Ferdinand and Herrera, Perfecto},
+                  booktitle={ISMIR},
+                  pages={559--564},
+                  year={2012}
+                }
+            """,
+            task_templates=None,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        train_archive_path = dl_manager.download_and_extract(_IRMAS_TRAIN_SET_URL)
+        test_archive_part1_path = dl_manager.download_and_extract(_IRMAS_TEST_SET_PART1_URL)
+        test_archive_part2_path = dl_manager.download_and_extract(_IRMAS_TEST_SET_PART2_URL)
+        test_archive_part3_path = dl_manager.download_and_extract(_IRMAS_TEST_SET_PART3_URL)
+
+        extensions = ['.wav']
+        _, _train_walker = fast_scandir(train_archive_path, extensions, recursive=True)
+        _test_walker = []
+        for part in [test_archive_part1_path, test_archive_part2_path, test_archive_part3_path]:
+            _, _walker = fast_scandir(part, extensions, recursive=True)
+            _test_walker.extend(_walker)
+        
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN, gen_kwargs={"audio_filepaths": _train_walker, "split": "train"}
+            ), 
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST, gen_kwargs={"audio_filepaths": _test_walker, "split": "test"}
+            ), 
+        ]
+
+    def _generate_examples(self, audio_filepaths, split=None):
+
+        def extract_bracketed_items(filename):
+            # Regex pattern to find text inside square brackets
+            pattern = r'\[([^\]]+)\]'
+            # Find all occurrences of the pattern
+            items = re.findall(pattern, filename)
+            return items
+    
+        if split == 'train':
+            for guid, audio_path in enumerate(audio_filepaths):
+                labels = extract_bracketed_items(audio_path)
+                labels = [label for label in labels if label in INSTRUMENTS]
+                yield guid, {
+                    "id": str(guid),
+                    "file": audio_path, 
+                    "audio": audio_path, 
+                    "instrument": labels, 
+                    "label": labels 
+                }
+                
+        elif split == 'test':
+            for guid, audio_path in enumerate(audio_filepaths):
+                labels = []
+                with open(audio_path.replace('.wav', '.txt'), 'r') as f:
+                    for line in f:
+                        labels.append(line.strip())
+                yield guid, {
+                    "id": str(guid),
+                    "file": audio_path, 
+                    "audio": audio_path, 
+                    "instrument": labels, 
+                    "label": labels 
+                }
+
+
+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