upl base code

.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: GZ IsoTech
-emoji: 🏆
+emoji: 🪕🎵
 colorFrom: red
 colorTo: indigo
 sdk: gradio

app.py

@@ -0,0 +1,219 @@
+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_files, embed_img, TEMP_DIR
+from collections import Counter
+from model import EvalNet
+
+
+TRANSLATE = {
+    "vibrato": "颤音",
+    "upward_portamento": "上滑音",
+    "downward_portamento": "下滑音",
+    "returning_portamento": "回滑音",
+    "glissando": "刮奏, 花指",
+    "tremolo": "摇指",
+    "harmonics": "泛音",
+    "plucks": "勾, 打, 抹, 托, ...",
+}
+CLASSES = list(TRANSLATE.keys())
+SAMPLE_RATE = 44100
+
+
+def circular_padding(spec: np.ndarray, end: int):
+    size = len(spec)
+    if end <= size:
+        return spec
+
+    num_padding = end - size
+    num_repeat = num_padding // size + int(num_padding % size != 0)
+    padding = np.tile(spec, num_repeat)
+    return np.concatenate((spec, padding))[:end]
+
+
+def wav2mel(audio_path: str, width=3):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        total_frames = len(y)
+        if total_frames % (width * sr) != 0:
+            count = total_frames // (width * sr) + 1
+            y = circular_padding(y, count * width * sr)
+
+        mel_spec = librosa.feature.melspectrogram(y=y, sr=sr)
+        log_mel_spec = librosa.power_to_db(mel_spec, ref=np.max)
+        dur = librosa.get_duration(y=y, sr=sr)
+        total_frames = log_mel_spec.shape[1]
+        step = int(width * total_frames / dur)
+        count = int(total_frames / step)
+        begin = int(0.5 * (total_frames - count * step))
+        end = begin + step * count
+        for i in range(begin, end, step):
+            librosa.display.specshow(log_mel_spec[:, i : i + step])
+            plt.axis("off")
+            plt.savefig(
+                f"{TEMP_DIR}/{i}.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, width=3):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        total_frames = len(y)
+        if total_frames % (width * sr) != 0:
+            count = total_frames // (width * sr) + 1
+            y = circular_padding(y, count * width * sr)
+
+        cqt_spec = librosa.cqt(y=y, sr=sr)
+        log_cqt_spec = librosa.power_to_db(np.abs(cqt_spec) ** 2, ref=np.max)
+        dur = librosa.get_duration(y=y, sr=sr)
+        total_frames = log_cqt_spec.shape[1]
+        step = int(width * total_frames / dur)
+        count = int(total_frames / step)
+        begin = int(0.5 * (total_frames - count * step))
+        end = begin + step * count
+        for i in range(begin, end, step):
+            librosa.display.specshow(log_cqt_spec[:, i : i + step])
+            plt.axis("off")
+            plt.savefig(
+                f"{TEMP_DIR}/{i}.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, width=3):
+    os.makedirs(TEMP_DIR, exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
+        total_frames = len(y)
+        if total_frames % (width * sr) != 0:
+            count = total_frames // (width * sr) + 1
+            y = circular_padding(y, count * width * 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)
+        dur = librosa.get_duration(y=y, sr=sr)
+        total_frames = log_chroma_spec.shape[1]
+        step = int(width * total_frames / dur)
+        count = int(total_frames / step)
+        begin = int(0.5 * (total_frames - count * step))
+        end = begin + step * count
+        for i in range(begin, end, step):
+            librosa.display.specshow(log_chroma_spec[:, i : i + step])
+            plt.axis("off")
+            plt.savefig(
+                f"{TEMP_DIR}/{i}.jpg",
+                bbox_inches="tight",
+                pad_inches=0.0,
+            )
+            plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def most_frequent_value(lst: list):
+    counter = Counter(lst)
+    max_count = max(counter.values())
+    for element, count in counter.items():
+        if count == max_count:
+            return element
+
+    return None
+
+
+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)
+    jpgs = find_files(folder_path, ".jpg")
+    preds = []
+    for jpg in jpgs:
+        input = embed_img(jpg)
+        output: torch.Tensor = model(input)
+        preds.append(torch.max(output.data, 1)[1])
+
+    pred_id = most_frequent_value(preds)
+    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_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="古筝演奏技法识别 Guzheng playing tech recognition",
+                    show_copy_button=True,
+                ),
+            ],
+            examples=examples,
+            cache_examples=False,
+            flagging_mode="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 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,145 @@
+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,6 @@
+modelscope
+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/GZ_IsoTech",
+    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_files(folder_path=f"{MODEL_DIR}/examples", ext=".wav"):
+    wav_files = []
+    for root, _, files in os.walk(folder_path):
+        for file in files:
+            if file.endswith(ext):
+                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)