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
+*.mp3 filter=lfs diff=lfs merge=lfs -text

.gitignore

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

README.md

@@ -1,13 +1,16 @@
 ---
-title: Music Genre
-emoji: 🔥
+title: Music Genre Classifier
+emoji: 🎶
 colorFrom: pink
 colorTo: pink
 sdk: gradio
-sdk_version: 4.13.0
+sdk_version: 4.36.0
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Maintenance
+```bash
+GIT_LFS_SKIP_SMUDGE=1 git clone [email protected]:spaces/ccmusic-database/music-genre
+```

app.py

@@ -0,0 +1,220 @@
+import os
+import sys
+import torch
+import random
+import shutil
+import librosa
+import warnings
+import subprocess
+import numpy as np
+import gradio as gr
+import librosa.display
+import matplotlib.pyplot as plt
+import torchvision.transforms as transforms
+from utils import get_modelist, find_mp3_files, download
+from collections import Counter
+from model import EvalNet
+from PIL import Image
+
+
+TRANSLATE = {
+    "Symphony": "交响乐 Symphony",
+    "Opera": "戏曲 Opera",
+    "Solo": "独奏 Solo",
+    "Chamber": "室内乐 Chamber",
+    "Pop_vocal_ballad": "芭乐 Pop vocal ballad",
+    "Adult_contemporary": "成人时代 Adult contemporary",
+    "Teen_pop": "青少年流行 Teen pop",
+    "Contemporary_dance_pop": "当代流行舞曲 Contemporary dance pop",
+    "Dance_pop": "流行舞曲 Dance pop",
+    "Classic_indie_pop": "经典独立流行 Classic indie pop",
+    "Chamber_cabaret_and_art_pop": "室内卡巴莱与艺术流行乐 Chamber cabaret & art pop",
+    "Soul_or_r_and_b": "灵魂乐或节奏布鲁斯 Soul / R&B",
+    "Adult_alternative_rock": "成人另类摇滚 Adult alternative rock",
+    "Uplifting_anthemic_rock": "迷幻民族摇滚 Uplifting anthemic rock",
+    "Soft_rock": "慢摇滚 Soft rock",
+    "Acoustic_pop": "原声流行 Acoustic pop",
+}
+
+CLASSES = list(TRANSLATE.keys())
+
+
+def most_common_element(input_list):
+    counter = Counter(input_list)
+    mce, _ = counter.most_common(1)[0]
+    return mce
+
+
+def mp3_to_mel(audio_path: str, width=11.4):
+    os.makedirs("./flagged", exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path)
+        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"./flagged/mel_{round(dur, 2)}_{i}.jpg",
+                bbox_inches="tight",
+                pad_inches=0.0,
+            )
+            plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def mp3_to_cqt(audio_path: str, width=11.4):
+    os.makedirs("./flagged", exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path)
+        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"./flagged/cqt_{round(dur, 2)}_{i}.jpg",
+                bbox_inches="tight",
+                pad_inches=0.0,
+            )
+            plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def mp3_to_chroma(audio_path: str, width=11.4):
+    os.makedirs("./flagged", exist_ok=True)
+    try:
+        y, sr = librosa.load(audio_path)
+        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"./flagged/chroma_{round(dur, 2)}_{i}.jpg",
+                bbox_inches="tight",
+                pad_inches=0.0,
+            )
+            plt.close()
+
+    except Exception as e:
+        print(f"Error converting {audio_path} : {e}")
+
+
+def embed_img(img_path, 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)
+
+
+def inference(mp3_path, log_name: str, folder_path="./flagged"):
+    if os.path.exists(folder_path):
+        shutil.rmtree(folder_path)
+
+    if not mp3_path:
+        return None, "请输入音频 Please input an audio!"
+
+    network = EvalNet(log_name)
+    spec = log_name.split("_")[-1]
+    eval("mp3_to_%s" % spec)(mp3_path)
+    outputs = []
+    all_files = os.listdir(folder_path)
+    for file_name in all_files:
+        if file_name.lower().endswith(".jpg"):
+            file_path = os.path.join(folder_path, file_name)
+            input = embed_img(file_path)
+            output: torch.Tensor = network.model(input)
+            pred_id = torch.max(output.data, 1)[1]
+            outputs.append(int(pred_id))
+
+    max_count_item = most_common_element(outputs)
+    shutil.rmtree(folder_path)
+    return os.path.basename(mp3_path), TRANSLATE[CLASSES[max_count_item]]
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore")
+    ffmpeg = "ffmpeg-release-amd64-static"
+    if sys.platform.startswith("linux"):
+        if not os.path.exists(f"./{ffmpeg}.tar.xz"):
+            download(
+                f"https://www.modelscope.cn/studio/ccmusic-database/music_genre/resolve/master/{ffmpeg}.tar.xz"
+            )
+
+        folder_path = f"{os.getcwd()}/{ffmpeg}"
+        if not os.path.exists(folder_path):
+            subprocess.call(f"tar -xvf {ffmpeg}.tar.xz", shell=True)
+
+        os.environ["PATH"] = f"{folder_path}:{os.environ.get('PATH', '')}"
+
+    models = get_modelist()
+    examples = []
+    example_mp3s = find_mp3_files()
+    model_num = len(models)
+    for mp3 in example_mp3s:
+        examples.append([mp3, models[random.randint(0, model_num - 1)]])
+
+    with gr.Blocks() as demo:
+        gr.Interface(
+            fn=inference,
+            inputs=[
+                gr.Audio(label="上传MP3音频 Upload MP3", type="filepath"),
+                gr.Dropdown(
+                    choices=models, label="选择模型 Select a model", value=models[6]
+                ),
+            ],
+            outputs=[
+                gr.Textbox(label="音频文件名 Audio filename", show_copy_button=True),
+                gr.Textbox(label="流派识别 Genre recognition", show_copy_button=True),
+            ],
+            examples=examples,
+            cache_examples=False,
+            allow_flagging="never",
+            title="建议录音时长保持在 15s 以内, 过长会影响识别效率<br>It is recommended to keep the duration of recording within 15s, too long will affect the recognition efficiency.",
+        )
+
+        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,146 @@
+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=16):
+        saved_model_path = f"{MODEL_DIR}/{log_name}/save.pt"
+        m_ver = "_".join(log_name.split("_")[:-1])
+        self.m_type, self.input_size = self._model_info(m_ver)
+
+        if not hasattr(models, m_ver):
+            print("Unsupported model.")
+            exit()
+
+        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, backbone_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):
+        backbone_list = MsDataset.load(
+            "monetjoe/cv_backbones",
+            split="v1",
+            trust_remote_code=True,
+        )
+        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, debug_mode=False):
+        for name, module in self.model.named_modules():
+            if (
+                str(name).__contains__("classifier")
+                or str(name).__eq__("fc")
+                or str(name).__contains__("head")
+            ):
+                if isinstance(module, torch.nn.Linear):
+                    self.output_size = module.in_features
+                    if debug_mode:
+                        print(
+                            f"{name}(Linear): {self.output_size} -> {module.out_features}"
+                        )
+                    return True
+
+                if isinstance(module, torch.nn.Conv2d):
+                    self.output_size = module.in_channels
+                    if debug_mode:
+                        print(
+                            f"{name}(Conv2d): {self.output_size} -> {module.out_channels}"
+                        )
+                    return False
+
+        return False
+
+    def _set_classifier(self, cls_num, linear_output):
+        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
+
+        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):
+        if torch.cuda.is_available():
+            x = x.cuda()
+            self.model = self.model.cuda()
+
+        if self.m_type == "googlenet" and self.training:
+            return self.model(x)[0]
+        else:
+            return self.model(x)

requirements.txt

@@ -0,0 +1,6 @@
+librosa
+torch
+matplotlib
+torchvision
+pillow
+modelscope==1.15

utils.py

@@ -0,0 +1,67 @@
+import os
+import torch
+import requests
+from modelscope import snapshot_download
+
+MODEL_DIR = snapshot_download(
+    "ccmusic-database/music_genre",
+    cache_dir="./__pycache__",
+)
+
+
+def toCUDA(x):
+    if hasattr(x, "cuda"):
+        if torch.cuda.is_available():
+            return x.cuda()
+
+    return x
+
+
+def find_mp3_files(folder_path=f"{MODEL_DIR}/examples"):
+    wav_files = []
+    for root, _, files in os.walk(folder_path):
+        for file in files:
+            if file.endswith(".mp3"):
+                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 download(url: str):
+    filename = url.split("/")[-1]
+    response = requests.get(url, stream=True)
+    if response.status_code == 200:
+        with open(filename, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        print(f"文件已下载到 {os.getcwd()}/{filename}")
+    else:
+        print(f"下载失败，状态码：{response.status_code}")