upl script

.gitignore

@@ -0,0 +1 @@
+rename.sh

Guzheng_Tech99.py

@@ -0,0 +1,297 @@
+import os
+import csv
+import random
+import datasets
+import numpy as np
+from glob import glob
+
+_NAMES = {
+    "chanyin": 0,
+    "dianyin": 6,
+    "shanghua": 2,
+    "xiahua": 3,
+    "huazhi": 4,
+    "guazou": 4,
+    "lianmo": 4,
+    "liantuo": 4,
+    "yaozhi": 5,
+    "boxian": 1,
+}
+
+_NAME = [
+    "chanyin",
+    "boxian",
+    "shanghua",
+    "xiahua",
+    "huazhi/guazou/lianmo/liantuo",
+    "yaozhi",
+    "dianyin",
+]
+
+_DBNAME = os.path.basename(__file__).split(".")[0]
+
+_HOMEPAGE = f"https://www.modelscope.cn/datasets/ccmusic-database/{_DBNAME}"
+
+_DOMAIN = f"https://www.modelscope.cn/api/v1/datasets/ccmusic-database/{_DBNAME}/repo?Revision=master&FilePath=data"
+
+_URLS = {
+    "audio": f"{_DOMAIN}/audio.zip",
+    "mel": f"{_DOMAIN}/mel.zip",
+    "label": f"{_DOMAIN}/label.zip",
+}
+
+_TIME_LENGTH = 3  # seconds
+_SAMPLE_RATE = 44100
+_HOP_LENGTH = 512  # SAMPLE_RATE * ZHEN_LENGTH // 1000
+
+
+class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
+    def _info(self):
+        return datasets.DatasetInfo(
+            features=(
+                datasets.Features(
+                    {
+                        "audio": datasets.Audio(sampling_rate=44100),
+                        "mel": datasets.Image(),
+                        "label": datasets.Sequence(
+                            feature={
+                                "onset_time": datasets.Value("float32"),
+                                "offset_time": datasets.Value("float32"),
+                                "IPT": datasets.ClassLabel(num_classes=7, names=_NAME),
+                                "note": datasets.Value("int8"),
+                            }
+                        ),
+                    }
+                )
+                if self.config.name == "default"
+                else datasets.Features(
+                    {
+                        "data": datasets.features.Array3D(
+                            dtype="float32", shape=(88, 258, 1)
+                        ),
+                        "label": datasets.features.Array2D(
+                            dtype="float32", shape=(7, 258)
+                        ),
+                    }
+                )
+            ),
+            homepage=_HOMEPAGE,
+            license="CC-BY-NC-ND",
+            version="1.2.0",
+        )
+
+    def _RoW_norm(self, data):
+        common_sum = 0
+        square_sum = 0
+        tfle = 0
+        for i in range(len(data)):
+            tfle += (data[i].sum(-1).sum(0) != 0).astype("int").sum()
+            common_sum += data[i].sum(-1).sum(-1)
+            square_sum += (data[i] ** 2).sum(-1).sum(-1)
+
+        common_avg = common_sum / tfle
+        square_avg = square_sum / tfle
+        std = np.sqrt(square_avg - common_avg**2)
+        return common_avg, std
+
+    def _norm(self, avg, std, data, size):
+        avg = np.tile(avg.reshape((1, -1, 1, 1)), (size[0], 1, size[2], size[3]))
+        std = np.tile(std.reshape((1, -1, 1, 1)), (size[0], 1, size[2], size[3]))
+        data = (data - avg) / std
+        return data
+
+    def _load(self, wav_dir, csv_dir, groups, avg=None, std=None):
+        # Return all [(audio address, corresponding to csv file address), ( , ), ...] list
+        if std is None:
+            std = np.array([None])
+
+        if avg is None:
+            avg = np.array([None])
+
+        def files(wav_dir, csv_dir, group):
+            flacs = sorted(glob(os.path.join(wav_dir, group, "*.flac")))
+            if len(flacs) == 0:
+                flacs = sorted(glob(os.path.join(wav_dir, group, "*.wav")))
+
+            csvs = sorted(glob(os.path.join(csv_dir, group, "*.csv")))
+            files = list(zip(flacs, csvs))
+            if len(files) == 0:
+                raise RuntimeError(f"Group {group} is empty")
+
+            result = []
+            for audio_path, csv_path in files:
+                result.append((audio_path, csv_path))
+
+            return result
+
+        # Returns the CQT of the input audio
+        def logCQT(file):
+            import librosa
+
+            sr = _SAMPLE_RATE
+            y, sr = librosa.load(file, sr=sr)
+            # 帧长为32ms (1000ms/(16000/512) = 32ms), D2的频率是73.418
+            cqt = librosa.cqt(
+                y,
+                sr=sr,
+                hop_length=_HOP_LENGTH,
+                fmin=27.5,
+                n_bins=88,
+                bins_per_octave=12,
+            )
+            return (
+                (1.0 / 80.0) * librosa.core.amplitude_to_db(np.abs(cqt), ref=np.max)
+            ) + 1.0
+
+        def chunk_data(f):
+            s = int(_SAMPLE_RATE * _TIME_LENGTH / _HOP_LENGTH)
+            xdata = np.transpose(f)
+            x = []
+            length = int(np.ceil((int(len(xdata) / s) + 1) * s))
+            app = np.zeros((length - xdata.shape[0], xdata.shape[1]))
+            xdata = np.concatenate((xdata, app), 0)
+            for i in range(int(length / s)):
+                data = xdata[int(i * s) : int(i * s + s)]
+                x.append(np.transpose(data[:s, :]))
+
+            return np.array(x)
+
+        def load_all(audio_path, csv_path):
+            # Load audio features: The shape of cqt (88, 8520), 8520 is the number of frames on the time axis
+            cqt = logCQT(audio_path)
+            # Load the ground truth label
+            hop = _HOP_LENGTH
+            n_steps = cqt.shape[1]
+            n_IPTs = 7
+            technique = _NAMES
+            IPT_label = np.zeros([n_IPTs, n_steps], dtype=int)
+            with open(csv_path, "r") as f:  # csv file for each audio
+                reader = csv.DictReader(f, delimiter=",")
+                for label in reader:  # each note
+                    onset = float(label["onset_time"])
+                    offset = float(label["offset_time"])
+                    IPT = int(technique[label["IPT"]])
+                    left = int(round(onset * _SAMPLE_RATE / hop))
+                    frame_right = int(round(offset * _SAMPLE_RATE / hop))
+                    frame_right = min(n_steps, frame_right)
+                    IPT_label[IPT, left:frame_right] = 1
+
+            return dict(
+                audiuo_path=audio_path, csv_path=csv_path, cqt=cqt, IPT_label=IPT_label
+            )
+
+        data = []
+        # print(f"Loading {len(groups)} group{'s' if len(groups) > 1 else ''} ")
+        for group in groups:
+            for input_files in files(wav_dir, csv_dir, group):
+                data.append(load_all(*input_files))
+
+        i = 0
+        for dic in data:
+            x = dic["cqt"]
+            x = chunk_data(x)
+            y_i = dic["IPT_label"]
+            y_i = chunk_data(y_i)
+            if i == 0:
+                Xtr = x
+                Ytr_i = y_i
+                i += 1
+
+            else:
+                Xtr = np.concatenate([Xtr, x], axis=0)
+                Ytr_i = np.concatenate([Ytr_i, y_i], axis=0)
+
+        # Transform the shape of the input
+        Xtr = np.expand_dims(Xtr, axis=3)
+        # Calculate the mean and variance of the input
+        if avg.all() == None and std.all() == None:
+            avg, std = self._RoW_norm(Xtr)
+        # Normalize
+        Xtr = self._norm(avg, std, Xtr, Xtr.shape)
+        return list(Xtr), list(Ytr_i)
+
+    def _parse_csv_label(self, csv_file):
+        label = []
+        with open(csv_file, mode="r", encoding="utf-8") as file:
+            for row in csv.DictReader(file):
+                label.append(
+                    {
+                        "onset_time": float(row["onset_time"]),
+                        "offset_time": float(row["offset_time"]),
+                        "IPT": _NAME[_NAMES[row["IPT"]]],
+                        "note": int(row["note"]),
+                    }
+                )
+
+        return label
+
+    def _split_generators(self, dl_manager):
+        audio_files = dl_manager.download_and_extract(_URLS["audio"])
+        csv_files = dl_manager.download_and_extract(_URLS["label"])
+        trainset, validset, testset = [], [], []
+        if self.config.name == "default":
+            files = {}
+            mel_files = dl_manager.download_and_extract(_URLS["mel"])
+            for path in dl_manager.iter_files([audio_files]):
+                fname: str = os.path.basename(path)
+                if fname.endswith(".flac"):
+                    item_id = fname.split(".")[0]
+                    files[item_id] = {"audio": path}
+
+            for path in dl_manager.iter_files([mel_files]):
+                fname = os.path.basename(path)
+                if fname.endswith(".jpg"):
+                    item_id = fname.split(".")[0]
+                    files[item_id]["mel"] = path
+
+            for path in dl_manager.iter_files([csv_files]):
+                fname = os.path.basename(path)
+                if fname.endswith(".csv"):
+                    item_id = fname.split(".")[0]
+                    files[item_id]["label"] = self._parse_csv_label(path)
+
+            for item in files.values():
+                if "train" in item["audio"]:
+                    trainset.append(item)
+
+                elif "validation" in item["audio"]:
+                    validset.append(item)
+
+                elif "test" in item["audio"]:
+                    testset.append(item)
+
+        else:
+            audio_dir = audio_files + "\\audio"
+            csv_dir = csv_files + "\\label"
+            X_train, Y_train = self._load(audio_dir, csv_dir, ["train"])
+            X_valid, Y_valid = self._load(audio_dir, csv_dir, ["validation"])
+            X_test, Y_test = self._load(audio_dir, csv_dir, ["test"])
+
+            for i in range(len(X_train)):
+                trainset.append({"data": X_train[i], "label": Y_train[i]})
+
+            for i in range(len(X_valid)):
+                validset.append({"data": X_valid[i], "label": Y_valid[i]})
+
+            for i in range(len(X_test)):
+                testset.append({"data": X_test[i], "label": Y_test[i]})
+
+        random.shuffle(trainset)
+        random.shuffle(validset)
+        random.shuffle(testset)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN, gen_kwargs={"files": trainset}
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION, gen_kwargs={"files": validset}
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST, gen_kwargs={"files": testset}
+            ),
+        ]
+
+    def _generate_examples(self, files):
+        for i, path in enumerate(files):
+            yield i, path

README.md

@@ -1,3 +1,169 @@
 ---
-license: mit
+license: cc-by-nc-nd-4.0
+task_categories:
+- audio-classification
+language:
+- zh
+- en
+tags:
+- music
+- art
+pretty_name: Guzheng Technique 99 Dataset
+size_categories:
+- n<1K
+viewer: false
 ---
+
+# Dataset Card for Guzheng Technique 99 Dataset
+The raw dataset, sourced from [Guzheng_Tech99](https://ccmusic-database.github.io/en/database/csmtd.html#Tech99), encompasses 99 solo compositions for the guzheng, recorded by professional musicians in a studio environment, with a cumulative duration of 9,064.6 seconds. Each composition has been annotated for every note, indicating the onset, offset, pitch, and playing techniques, which include chanyin, boxian, shanghua, xiahua, huazhi\guazou\lianmo\liantuo, yaozhi, and dianyin. This meticulous annotation has resulted in a total of 63,352 annotated labels across the dataset.
+
+Based on the above raw data, we performed data processing and constructed the `default subset` of the current integrated version of the dataset, and the details of its data structure can be viewed through the [viewer](https://www.modelscope.cn/datasets/ccmusic-database/Guzheng_Tech99/dataPeview).
+
+In light of the fact that the current dataset has been referenced and evaluated in a published article, we transcribe here the details of the dataset processing during the evaluation in the said article: each audio clip is a 3-second segment sampled at 44,100Hz, which is then converted into a log Constant-Q Transform (CQT) spectrogram. A CQT accompanied by a label constitutes a single data entry, forming the first and second columns, respectively. The CQT is a 3-dimensional array with dimensions of 88×258×1, representing the frequency-time structure of the audio. The label, on the other hand, is a 2-dimensional array with dimensions of 7×258, indicating the presence of seven distinct techniques across each time frame. Ultimately, given that the raw dataset has already been divided into train, valid, and test sets, we have integrated the feature extraction method mentioned in this article's evaluation process into the API, thereby constructing the `eval subset`.
+
+## Viewer
+<https://www.modelscope.cn/datasets/ccmusic-database/Guzheng_Tech99/dataPeview>
+
+## Dataset Structure
+### Default Subset
+<style>
+  .datastructure td {
+    vertical-align: middle !important;
+    text-align: center;
+  }
+  .datastructure th {
+    text-align: center;
+  }
+</style>
+<table class="datastructure">
+    <tr>
+        <th>audio</th>
+        <th>mel</th>
+        <th>label</th>
+    </tr>
+    <tr>
+        <td>.flac, 44100Hz</td>
+        <td>.jpg, 44100Hz</td>
+        <td>{onset_time : float64, offset_time : float, IPT : 7-class, note : int8}</td>
+    </tr>
+    <tr>
+        <td>...</td>
+        <td>...</td>
+        <td>...</td>
+    </tr>
+</table>
+
+### Eval Subset
+| data(logCQT spectrogram) |      label       |
+| :----------------------: | :--------------: |
+|  float64, 88 x 258 x 1   | float64, 7 x 258 |
+|           ...            |       ...        |
+
+### Data Instances
+.zip(.flac, .csv)
+
+### Data Fields
+The dataset comprises 99 Guzheng solo compositions, recorded by professionals in a studio, totaling 9064.6 seconds. It includes seven playing techniques labeled for each note (onset, offset, pitch, vibrato, point note, upward portamento, downward portamento, plucks, glissando, and tremolo), resulting in 63,352 annotated labels. The dataset is divided into 79, 10, and 10 songs for the training, validation, and test sets, respectively.
+
+### Data Splits
+train, validation, test
+
+## Dataset Description
+- **Homepage:** <https://ccmusic-database.github.io>
+- **Repository:** <https://huggingface.co/datasets/ccmusic-database/Guzheng_Tech99>
+- **Paper:** <https://doi.org/10.5281/zenodo.5676893>
+- **Leaderboard:** <https://www.modelscope.cn/datasets/ccmusic-database/Guzheng_Tech99>
+- **Point of Contact:** <https://github.com/LiDCC/GuzhengTech99/tree/windows>
+
+### Dataset Summary
+The integrated version provides the original content and the spectrogram generated in the experimental part of the paper cited above. For the second part, the pre-process in the paper is replicated. Each audio clip is a 3-second segment sampled at 44,100Hz, which is subsequently converted into a log Constant-Q Transform (CQT) spectrogram. A CQT accompanied by a label constitutes a single data entry, forming the first and second columns, respectively. The CQT is a 3-dimensional array with the dimension of 88 × 258 × 1, representing the frequency-time structure of the audio. The label, on the other hand, is a 2-dimensional array with dimensions of 7 × 258, which indicates the presence of seven distinct techniques across each time frame. indicating the existence of the seven techniques in each time frame. In the end, given that the raw dataset has already been split into train, valid, and test sets, the integrated dataset maintains the same split method. This dataset can be used for frame-level guzheng playing technique detection.
+
+### Supported Tasks and Leaderboards
+MIR, audio classification
+
+### Languages
+Chinese, English
+
+## Usage
+### Default Subset
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("ccmusic-database/Guzheng_Tech99", name="default", split="train")
+for item in ds:
+    print(item)
+```
+
+### Eval Subset
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("ccmusic-database/Guzheng_Tech99", name="eval")
+for item in ds["train"]:
+    print(item)
+
+for item in ds["validation"]:
+    print(item)
+
+for item in ds["test"]:
+    print(item)
+```
+
+## Maintenance
+```bash
+GIT_LFS_SKIP_SMUDGE=1 git clone [email protected]:datasets/ccmusic-database/Guzheng_Tech99
+cd Guzheng_Tech99
+```
+## Dataset Creation
+### Curation Rationale
+Instrument playing technique (IPT) is a key element of musical presentation.
+
+### Source Data
+#### Initial Data Collection and Normalization
+Dichucheng Li, Monan Zhou
+
+#### Who are the source language producers?
+Students from FD-LAMT
+
+### Annotations
+#### Annotation process
+Guzheng is a polyphonic instrument. In Guzheng performance, notes with different IPTs are usually overlapped and mixed IPTs that can be decomposed into multiple independent IPTs are usually used. Most existing work on IPT detection typically uses datasets with monophonic instrumental solo pieces. This dataset fills a gap in the research field.
+
+#### Who are the annotators?
+Students from FD-LAMT
+
+### Personal and Sensitive Information
+None
+
+## Considerations for Using the Data
+### Social Impact of Dataset
+Promoting the development of the music AI industry
+
+### Discussion of Biases
+Only for Traditional Chinese Instruments
+
+### Other Known Limitations
+Insufficient sample 
+
+## Additional Information
+### Dataset Curators
+Dichucheng Li
+
+### Evaluation
+[Dichucheng Li, Mingjin Che, Wenwu Meng, Yulun Wu, Yi Yu, Fan Xia and Wei Li. "Frame-Level Multi-Label Playing Technique Detection Using Multi-Scale Network and Self-Attention Mechanism", in IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP 2023).](https://arxiv.org/pdf/2303.13272.pdf)
+
+### Citation Information
+```bibtex
+@dataset{zhaorui_liu_2021_5676893,
+  author       = {Monan Zhou, Shenyang Xu, Zhaorui Liu, Zhaowen Wang, Feng Yu, Wei Li and Baoqiang Han},
+  title        = {CCMusic: an Open and Diverse Database for Chinese and General Music Information Retrieval Research},
+  month        = {mar},
+  year         = {2024},
+  publisher    = {HuggingFace},
+  version      = {1.2},
+  url          = {https://huggingface.co/ccmusic-database}
+}
+```
+
+### Contributions
+Promoting the development of the music AI industry