Update Guzheng_Tech99.py

Guzheng_Tech99.py

@@ -1,8 +1,10 @@
 import os
 import csv
 import random
+import librosa
 import datasets
 import numpy as np
+from tqdm import tqdm
 from glob import glob
 
 _NAMES = {
@@ -64,9 +66,15 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
                 if self.config.name == "default"
                 else datasets.Features(
                     {
-                        "data": datasets.features.Array3D(
+                        "mel": datasets.features.Array3D(
+                            dtype="float32", shape=(128, 258, 1)
+                        ),
+                        "cqt": datasets.features.Array3D(
                             dtype="float32", shape=(88, 258, 1)
                         ),
+                        "chroma": datasets.features.Array3D(
+                            dtype="float32", shape=(12, 258, 1)
+                        ),
                         "label": datasets.features.Array2D(
                             dtype="float32", shape=(7, 258)
                         ),
@@ -83,7 +91,7 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
         square_sum = 0
         tfle = 0
         for i in range(len(data)):
-            tfle += (data[i].sum(-1).sum(0) != 0).astype("int").sum()
+            tfle += (data[i].sum(-1).sum(0) != 0).astype("float").sum()
             common_sum += data[i].sum(-1).sum(-1)
             square_sum += (data[i] ** 2).sum(-1).sum(-1)
 
@@ -92,20 +100,14 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
         std = np.sqrt(square_avg - common_avg**2)
         return common_avg, std
 
-    def _norm(self, avg, std, data, size):
+    def _norm(self, data):
+        size = data.shape
+        avg, std = self._RoW_norm(data)
         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])
+        return (data - avg) / std
 
+    def _load(self, wav_dir, csv_dir, groups):
         def files(wav_dir, csv_dir, group):
             flacs = sorted(glob(os.path.join(wav_dir, group, "*.flac")))
             if len(flacs) == 0:
@@ -122,12 +124,18 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
 
             return result
 
-        # Returns the CQT of the input audio
-        def logCQT(file):
-            import librosa
+        def logMel(y, sr=_SAMPLE_RATE):
+            # 帧长为32ms (1000ms/(16000/512) = 32ms), D2的频率是73.418
+            mel = librosa.feature.melspectrogram(
+                y=y,
+                sr=sr,
+                hop_length=_HOP_LENGTH,
+                fmin=27.5,
+            )
+            return librosa.power_to_db(mel, ref=np.max)
 
-            sr = _SAMPLE_RATE
-            y, sr = librosa.load(file, sr=sr)
+        # Returns the CQT of the input audio
+        def logCQT(y, sr=_SAMPLE_RATE):
             # 帧长为32ms (1000ms/(16000/512) = 32ms), D2的频率是73.418
             cqt = librosa.cqt(
                 y,
@@ -141,10 +149,21 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
                 (1.0 / 80.0) * librosa.core.amplitude_to_db(np.abs(cqt), ref=np.max)
             ) + 1.0
 
+        def logChroma(y, sr=_SAMPLE_RATE):
+            # 帧长为32ms (1000ms/(16000/512) = 32ms), D2的频率是73.418
+            chroma = librosa.feature.chroma_stft(
+                y=y,
+                sr=sr,
+                hop_length=_HOP_LENGTH,
+            )
+            return (
+                (1.0 / 80.0) * librosa.core.amplitude_to_db(np.abs(chroma), ref=np.max)
+            ) + 1.0
+
         def chunk_data(f):
-            s = int(_SAMPLE_RATE * _TIME_LENGTH / _HOP_LENGTH)
-            xdata = np.transpose(f)
             x = []
+            xdata = np.transpose(f)
+            s = _SAMPLE_RATE * _TIME_LENGTH // _HOP_LENGTH
             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)
@@ -154,16 +173,16 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
 
             return np.array(x)
 
-        def load_all(audio_path, csv_path):
+        def load_all(audio_path, csv_path, hop=_HOP_LENGTH, n_IPTs=7, technique=_NAMES):
             # Load audio features: The shape of cqt (88, 8520), 8520 is the number of frames on the time axis
-            cqt = logCQT(audio_path)
+            y, sr = librosa.load(audio_path, sr=_SAMPLE_RATE)
+            mel = logMel(y, sr)
+            cqt = logCQT(y, sr)
+            chroma = logChroma(y, sr)
             # 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
+            with open(csv_path, "r", encoding="utf-8") as f:  # csv file for each audio
                 reader = csv.DictReader(f, delimiter=",")
                 for label in reader:  # each note
                     onset = float(label["onset_time"])
@@ -175,7 +194,12 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
                     IPT_label[IPT, left:frame_right] = 1
 
             return dict(
-                audiuo_path=audio_path, csv_path=csv_path, cqt=cqt, IPT_label=IPT_label
+                audio_path=audio_path,
+                csv_path=csv_path,
+                mel=mel,
+                cqt=cqt,
+                chroma=chroma,
+                IPT_label=IPT_label,
             )
 
         data = []
@@ -184,29 +208,33 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
             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)
+        for i, dic in tqdm(enumerate(data), total=len(data), desc="Feature extracting"):
+            x_mel = chunk_data(dic["mel"])
+            x_cqt = chunk_data(dic["cqt"])
+            x_chroma = chunk_data(dic["chroma"])
             y_i = dic["IPT_label"]
             y_i = chunk_data(y_i)
             if i == 0:
-                Xtr = x
+                Xtr_mel = x_mel
+                Xtr_cqt = x_cqt
+                Xtr_chroma = x_chroma
                 Ytr_i = y_i
-                i += 1
 
             else:
-                Xtr = np.concatenate([Xtr, x], axis=0)
+                Xtr_mel = np.concatenate([Xtr_mel, x_mel], axis=0)
+                Xtr_cqt = np.concatenate([Xtr_cqt, x_cqt], axis=0)
+                Xtr_chroma = np.concatenate([Xtr_chroma, x_chroma], 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)
+        Xtr_mel = np.expand_dims(Xtr_mel, axis=3)
+        Xtr_cqt = np.expand_dims(Xtr_cqt, axis=3)
+        Xtr_chroma = np.expand_dims(Xtr_chroma, axis=3)
         # Normalize
-        Xtr = self._norm(avg, std, Xtr, Xtr.shape)
-        return list(Xtr), list(Ytr_i)
+        Xtr_mel = self._norm(Xtr_mel)
+        Xtr_cqt = self._norm(Xtr_cqt)
+        Xtr_chroma = self._norm(Xtr_chroma)
+        return [list(Xtr_mel), list(Xtr_cqt), list(Xtr_chroma)], list(Ytr_i)
 
     def _parse_csv_label(self, csv_file):
         label = []
@@ -259,19 +287,40 @@ class Guzheng_Tech99(datasets.GeneratorBasedBuilder):
                     testset.append(item)
 
         else:
-            audio_dir = audio_files + "\\audio"
-            csv_dir = csv_files + "\\label"
+            audio_dir = os.path.join(audio_files, "audio")
+            csv_dir = os.path.join(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(Y_train)):
+                trainset.append(
+                    {
+                        "mel": X_train[0][i],
+                        "cqt": X_train[1][i],
+                        "chroma": X_train[2][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(Y_valid)):
+                validset.append(
+                    {
+                        "mel": X_valid[0][i],
+                        "cqt": X_valid[1][i],
+                        "chroma": X_valid[2][i],
+                        "label": Y_valid[i],
+                    }
+                )
 
-            for i in range(len(X_test)):
-                testset.append({"data": X_test[i], "label": Y_test[i]})
+            for i in range(len(Y_test)):
+                testset.append(
+                    {
+                        "mel": X_test[0][i],
+                        "cqt": X_test[1][i],
+                        "chroma": X_test[2][i],
+                        "label": Y_test[i],
+                    }
+                )
 
         random.shuffle(trainset)
         random.shuffle(validset)