sync

.gitattributes

@@ -1,35 +1,35 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*.tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db* filter=lfs diff=lfs merge=lfs -text
+*.ark* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+*.pt
+__pycache__/*
+tmp/*
+flagged/*
+test.py
+rename.sh

README.md

@@ -1,6 +1,6 @@
 ---
 title: Erhu Playing Tech
-emoji: 📊
+emoji: 🪕
 colorFrom: indigo
 colorTo: gray
 sdk: gradio

app.py

@@ -0,0 +1,174 @@
+import os
+import torch
+import random
+import shutil
+import librosa
+import warnings
+import numpy as np
+import gradio as gr
+import librosa.display
+import matplotlib.pyplot as plt
+from utils import get_modelist, find_wav_files, embed_img, TEMP_DIR
+from model import EvalNet
+
+
+TRANSLATE = {
+    "vibrato": "揉弦 Rou xian",
+    "trill": "颤音 Chan yin",
+    "tremolo": "颤弓 Chan gong",
+    "staccato": "顿弓 Dun gong",
+    "ricochet": "抛弓 Pao gong",
+    "pizzicato": "拨弦 Bo xian",
+    "percussive": "击弓 Ji gong",
+    "legato_slide_glissando": "连滑音 Lian hua yin",
+    "harmonic": "泛音 Fan yin",
+    "diangong": "垫弓 Dian gong",
+    "detache": "分弓 Fen gong",
+}
+CLASSES = list(TRANSLATE.keys())
+SAMPLE_RATE = 44100
+
+
+def circular_padding(y: np.ndarray, sr: int, dur=3):
+    if len(y) >= sr * dur:
+        return y[: sr * dur]
+
+    size = sr * dur // len(y) + int((sr * dur) % len(y) > 0)
+    arrays = []
+    for _ in range(size):
+        arrays.append(y)
+
+    y = np.hstack(arrays)
+    return y[: sr * dur]
+
+
+def wav2mel(audio_path: str):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        y = circular_padding(y, sr)
+        mel_spec = librosa.feature.melspectrogram(y=y, sr=sr)
+        log_mel_spec = librosa.power_to_db(mel_spec, ref=np.max)
+        librosa.display.specshow(log_mel_spec)
+        plt.axis("off")
+        plt.savefig(
+            f"{TEMP_DIR}/output.jpg",
+            bbox_inches="tight",
+            pad_inches=0.0,
+        )
+        plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def wav2cqt(audio_path: str):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        y = circular_padding(y, sr)
+        cqt_spec = librosa.cqt(y=y, sr=sr)
+        log_cqt_spec = librosa.power_to_db(np.abs(cqt_spec) ** 2, ref=np.max)
+        librosa.display.specshow(log_cqt_spec)
+        plt.axis("off")
+        plt.savefig(
+            f"{TEMP_DIR}/output.jpg",
+            bbox_inches="tight",
+            pad_inches=0.0,
+        )
+        plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def wav2chroma(audio_path: str):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        y = circular_padding(y, sr)
+        chroma_spec = librosa.feature.chroma_stft(y=y, sr=sr)
+        log_chroma_spec = librosa.power_to_db(np.abs(chroma_spec) ** 2, ref=np.max)
+        librosa.display.specshow(log_chroma_spec)
+        plt.axis("off")
+        plt.savefig(
+            f"{TEMP_DIR}/output.jpg",
+            bbox_inches="tight",
+            pad_inches=0.0,
+        )
+        plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def infer(wav_path: str, log_name: str, folder_path=TEMP_DIR):
+    if os.path.exists(folder_path):
+        shutil.rmtree(folder_path)
+
+    if not wav_path:
+        return None, "请输入音频 Please input an audio!"
+
+    try:
+        model = EvalNet(log_name, len(TRANSLATE)).model
+    except Exception as e:
+        return None, f"{e}"
+
+    spec = log_name.split("_")[-3]
+    eval("wav2%s" % spec)(wav_path)
+    input = embed_img(f"{folder_path}/output.jpg")
+    output: torch.Tensor = model(input)
+    pred_id = torch.max(output.data, 1)[1]
+    return (
+        os.path.basename(wav_path),
+        f"{TRANSLATE[CLASSES[pred_id]]} ({CLASSES[pred_id].capitalize()})",
+    )
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore")
+    models = get_modelist()
+    examples = []
+    example_wavs = find_wav_files()
+    model_num = len(models)
+    for wav in example_wavs:
+        examples.append([wav, models[random.randint(0, model_num - 1)]])
+
+    with gr.Blocks() as demo:
+        gr.Interface(
+            fn=infer,
+            inputs=[
+                gr.Audio(label="上传录音 Upload a recording", type="filepath"),
+                gr.Dropdown(
+                    choices=models, label="选择模型 Select a model", value=models[0]
+                ),
+            ],
+            outputs=[
+                gr.Textbox(label="音频文件名 Audio filename", show_copy_button=True),
+                gr.Textbox(
+                    label="演奏技法识别 Playing tech recognition", show_copy_button=True
+                ),
+            ],
+            examples=examples,
+            cache_examples=False,
+            allow_flagging="never",
+            title="建议录音时长保持在 3s 左右<br>It is recommended to keep the recording length around 3s.",
+        )
+
+        gr.Markdown(
+            """
+# 引用 Cite
+```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}
+}
+```"""
+        )
+
+    demo.launch()

model.py

@@ -0,0 +1,142 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+from modelscope.msdatasets import MsDataset
+from utils import MODEL_DIR
+
+
+class EvalNet:
+    model: nn.Module = None
+    m_type = "squeezenet"
+    input_size = 224
+    output_size = 512
+
+    def __init__(self, log_name: str, cls_num: int):
+        saved_model_path = f"{MODEL_DIR}/{log_name}/save.pt"
+        m_ver = "_".join(log_name.split("_")[:-3])
+        self.m_type, self.input_size = self._model_info(m_ver)
+
+        if not hasattr(models, m_ver):
+            raise Exception("Unsupported model.")
+
+        self.model = eval("models.%s()" % m_ver)
+        linear_output = self._set_outsize()
+        self._set_classifier(cls_num, linear_output)
+        checkpoint = torch.load(saved_model_path, map_location="cpu")
+        if torch.cuda.is_available():
+            checkpoint = torch.load(saved_model_path)
+
+        self.model.load_state_dict(checkpoint, False)
+        self.model.eval()
+
+    def _get_backbone(self, ver: str, backbone_list: list):
+        for bb in backbone_list:
+            if ver == bb["ver"]:
+                return bb
+
+        print("Backbone name not found, using default option - alexnet.")
+        return backbone_list[0]
+
+    def _model_info(self, m_ver: str):
+        backbone_list = MsDataset.load("monetjoe/cv_backbones", split="v1")
+        backbone = self._get_backbone(m_ver, backbone_list)
+        m_type = str(backbone["type"])
+        input_size = int(backbone["input_size"])
+        return m_type, input_size
+
+    def _classifier(self, cls_num: int, output_size: int, linear_output: bool):
+        q = (1.0 * output_size / cls_num) ** 0.25
+        l1 = int(q * cls_num)
+        l2 = int(q * l1)
+        l3 = int(q * l2)
+        if linear_output:
+            return torch.nn.Sequential(
+                nn.Dropout(),
+                nn.Linear(output_size, l3),
+                nn.ReLU(inplace=True),
+                nn.Dropout(),
+                nn.Linear(l3, l2),
+                nn.ReLU(inplace=True),
+                nn.Dropout(),
+                nn.Linear(l2, l1),
+                nn.ReLU(inplace=True),
+                nn.Linear(l1, cls_num),
+            )
+
+        else:
+            return torch.nn.Sequential(
+                nn.Dropout(),
+                nn.Conv2d(output_size, l3, kernel_size=(1, 1), stride=(1, 1)),
+                nn.ReLU(inplace=True),
+                nn.AdaptiveAvgPool2d(output_size=(1, 1)),
+                nn.Flatten(),
+                nn.Linear(l3, l2),
+                nn.ReLU(inplace=True),
+                nn.Dropout(),
+                nn.Linear(l2, l1),
+                nn.ReLU(inplace=True),
+                nn.Linear(l1, cls_num),
+            )
+
+    def _set_outsize(self):
+        for name, module in self.model.named_modules():
+            if (
+                str(name).__contains__("classifier")
+                or str(name).__eq__("fc")
+                or str(name).__contains__("head")
+                or hasattr(module, "classifier")
+            ):
+                if isinstance(module, torch.nn.Linear):
+                    self.output_size = module.in_features
+                    return True
+
+                if isinstance(module, torch.nn.Conv2d):
+                    self.output_size = module.in_channels
+                    return False
+
+        return False
+
+    def _set_classifier(self, cls_num: int, linear_output: bool):
+        if self.m_type == "convnext":
+            del self.model.classifier[2]
+            self.model.classifier = nn.Sequential(
+                *list(self.model.classifier)
+                + list(self._classifier(cls_num, self.output_size, linear_output))
+            )
+            return
+
+        elif self.m_type == "maxvit":
+            del self.model.classifier[5]
+            self.model.classifier = nn.Sequential(
+                *list(self.model.classifier)
+                + list(self._classifier(cls_num, self.output_size, linear_output))
+            )
+            return
+
+        if hasattr(self.model, "classifier"):
+            self.model.classifier = self._classifier(
+                cls_num, self.output_size, linear_output
+            )
+            return
+
+        elif hasattr(self.model, "fc"):
+            self.model.fc = self._classifier(cls_num, self.output_size, linear_output)
+            return
+
+        elif hasattr(self.model, "head"):
+            self.model.head = self._classifier(cls_num, self.output_size, linear_output)
+            return
+
+        self.model.heads.head = self._classifier(
+            cls_num, self.output_size, linear_output
+        )
+
+    def forward(self, x: torch.Tensor):
+        if torch.cuda.is_available():
+            x = x.cuda()
+            self.model = self.model.cuda()
+
+        if self.m_type == "googlenet":
+            return self.model(x)[0]
+        else:
+            return self.model(x)

requirements.txt

@@ -0,0 +1,5 @@
+librosa
+torch
+matplotlib
+torchvision
+pillow

utils.py

@@ -0,0 +1,67 @@
+import os
+import torch
+import torchvision.transforms as transforms
+from modelscope import snapshot_download
+from PIL import Image
+
+MODEL_DIR = snapshot_download(
+    f"ccmusic-database/erhu_playing_tech",
+    cache_dir=f"{os.getcwd()}/__pycache__",
+)
+TEMP_DIR = f"{os.getcwd()}/flagged"
+
+
+def toCUDA(x):
+    if hasattr(x, "cuda"):
+        if torch.cuda.is_available():
+            return x.cuda()
+
+    return x
+
+
+def find_wav_files(folder_path=f"{MODEL_DIR}/examples"):
+    wav_files = []
+    for root, _, files in os.walk(folder_path):
+        for file in files:
+            if file.endswith(".wav"):
+                file_path = os.path.join(root, file)
+                wav_files.append(file_path)
+
+    return wav_files
+
+
+def get_modelist(model_dir=MODEL_DIR):
+    try:
+        entries = os.listdir(model_dir)
+    except OSError as e:
+        print(f"无法访问 {model_dir}: {e}")
+        return
+
+    # 遍历所有条目
+    output = []
+    for entry in entries:
+        # 获取完整路径
+        full_path = os.path.join(model_dir, entry)
+        # 跳过'.git'文件夹
+        if entry == ".git" or entry == "examples":
+            print(f"跳过 .git 或 examples 文件夹: {full_path}")
+            continue
+
+        # 检查条目是文件还是目录
+        if os.path.isdir(full_path):
+            # 打印目录路径
+            output.append(os.path.basename(full_path))
+
+    return output
+
+
+def embed_img(img_path: str, input_size=224):
+    transform = transforms.Compose(
+        [
+            transforms.Resize([input_size, input_size]),
+            transforms.ToTensor(),
+            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+        ]
+    )
+    img = Image.open(img_path).convert("RGB")
+    return transform(img).unsqueeze(0)