Upload 16 files

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

README.md

@@ -1,14 +1,14 @@
----
-title: MusicGenrePulse
-emoji: 🦀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.15.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: DL app to classify music and get genre distribution.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: MusicGenrePulse
+emoji: 🦀
+colorFrom: red
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.15.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: DL app to classify music and get genre distribution.
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,94 @@
+import gradio as gr
+import torch
+import numpy as np
+import librosa
+import time
+from MusicGenrePulse.src.utility import slice_songs  # Adjust your imports as needed
+from MusicGenrePulse.src import MusicCNN, MusicCRNN2D
+
+# Configuration
+DESIRED_SR = 22050
+HOP_LENGTH = 512
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+NUM_CLASSES = 10
+
+# Model loading (example for cnn and crnn; update paths as necessary)
+models = {"cnn": {}, "crnn": {}}
+# For instance:
+cnn_model_paths = {1: "models/cnn/1s.pth", 3: "models/cnn/3s.pth", 5: "models/cnn/5s.pth", 10: "models/cnn/10s.pth"}
+crnn_model_paths = {1: "models/crnn/1s.pth", 3: "models/crnn/3s.pth", 5: "models/crnn/5s.pth",
+                    10: "models/crnn/10s.pth"}
+
+
+def get_frames(slice_length):
+    return int(slice_length * DESIRED_SR / HOP_LENGTH)
+
+
+# Load cnn models
+for slice_len, path in cnn_model_paths.items():
+    model = MusicCNN(num_classes=NUM_CLASSES, device=DEVICE)
+    dummy_input = torch.randn(2, 1, 128, get_frames(slice_len)).to(DEVICE)
+    _ = model(dummy_input)
+    model.load_state_dict(torch.load(path, map_location=DEVICE))
+    model.to(DEVICE)
+    model.eval()
+    models["cnn"][slice_len] = model
+
+# Load crnn models
+for slice_len, path in crnn_model_paths.items():
+    model = MusicCRNN2D(num_classes=NUM_CLASSES, device=DEVICE)
+    dummy_input = torch.randn(2, 1, 128, get_frames(slice_len)).to(DEVICE)
+    _ = model(dummy_input)
+    model.load_state_dict(torch.load(path, map_location=DEVICE))
+    model.to(DEVICE)
+    model.eval()
+    models["crnn"][slice_len] = model
+
+GENRE_LABELS = ["Blues", "Classical", "Country", "Disco", "HipHop", "Jazz", "Metal", "Pop", "Reggae", "Rock"]
+
+
+def predict_genre(audio_file, slice_length, architecture):
+    slice_length = int(slice_length)
+    start_time = time.time()
+
+    y, sr = librosa.load(audio_file, sr=DESIRED_SR)
+    target_length = int(np.ceil(len(y) / sr)) * sr
+    if len(y) < target_length:
+        y = np.pad(y, (0, target_length - len(y)), mode='constant')
+
+    mel_spectrogram = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=2048, hop_length=HOP_LENGTH, n_mels=128)
+    mel_spectrogram_db = librosa.power_to_db(mel_spectrogram, ref=np.max)
+    min_val, max_val = np.min(mel_spectrogram_db), np.max(mel_spectrogram_db)
+    normalized_spectrogram = (mel_spectrogram_db - min_val) / (
+                max_val - min_val) if max_val - min_val > 0 else mel_spectrogram_db
+
+    X_slices, _, _ = slice_songs([normalized_spectrogram], [0], ["temp"], sr=sr, hop_length=HOP_LENGTH,
+                                 length_in_seconds=slice_length)
+    X_slices = torch.tensor(X_slices, dtype=torch.float32).unsqueeze(1).to(DEVICE)
+
+    model_used = models[architecture][slice_length]
+    with torch.no_grad():
+        outputs = model_used(X_slices)
+        probabilities = torch.nn.functional.softmax(outputs, dim=1).cpu().numpy()
+
+    avg_probs = np.mean(probabilities, axis=0)
+    genre_distribution = {GENRE_LABELS[i]: float(avg_probs[i]) for i in range(NUM_CLASSES)}
+    inference_time = time.time() - start_time
+    return genre_distribution, f"Inference Time: {inference_time:.2f} seconds"
+
+
+slice_length_dropdown = gr.Dropdown(choices=["1", "3", "5", "10"], value="1", label="Slice Length (seconds)")
+architecture_dropdown = gr.Dropdown(choices=["cnn", "crnn"], value="cnn", label="Model Architecture")
+
+demo = gr.Interface(
+    fn=predict_genre,
+    inputs=[gr.Audio(type="filepath", label="Upload Audio File"), slice_length_dropdown, architecture_dropdown],
+    outputs=[gr.Label(num_top_classes=10, label="Genre Distribution"), gr.Textbox(label="Inference Time")],
+    title="Music Genre Classifier",
+    description="Upload an audio file, select a slice length and model architecture to predict its genre distribution."
+)
+
+if __name__ == "__main__":
+    demo.launch()
+
+

models/cnn/10s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7280b3c52a5f2c741180160eed533237817bb9ba66bd8edf6519b0ce7776670b
+size 224021010

models/cnn/1s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2914628c6cb675e7c75e14f1686c0f20bd84c6cacad4a41db367bd476796f6be
+size 22694418

models/cnn/3s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e8135267a6db5e835e246755cde7997d00944415bd5db344fc2e036cb8f5b06
+size 68831762

models/cnn/5s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ca0c926d4393f112c3acee391ab1cc4fbfef41f015c156e8aeb68dbdf1cee09
+size 110774802

models/crnn/10s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:161bb49d3ed4bb761e9d7c6095afe5fbc144c7c95d49df5c1198d477d96191ce
+size 1626402

models/crnn/1s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbdeec8991d3b655e6785a2aa451accebd479ab3a0f3d61a4fc39429af471d6a
+size 1626402

models/crnn/3s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68bdbe9d17904bfb57720554edd4947c3c9e3df9ad4f14c505fdeb4420ce3b77
+size 1626402

models/crnn/5s.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e72bf03a664a8c1418d3b16d0634df595428aed5e4bcda75e75115548ab085df
+size 1626402

models/metrics_summary_table.csv

@@ -0,0 +1,17 @@
+,Model,Split Size,Slice Accuracy,Slice Loss,Song Accuracy,Execution Time,Epoch
+0,MusicCNN,1s,0.7991666666666667,0.8332288451790809,0.9,0h 21m 1s,106
+1,MusicCNN,3s,0.8205263157894737,0.8359026940245378,0.86,0h 24m 59s,82
+2,MusicCNN,5s,0.8372727272727273,0.8710557313398881,0.85,0h 24m 19s,84
+3,MusicCNN,10s,0.836,0.987051441192627,0.88,0h 38m 37s,133
+4,MusicCRNN2D,1s,0.8333333333333334,0.746949385046959,0.94,0h 13m 12s,48
+5,MusicCRNN2D,3s,0.8078947368421052,0.8572936429475483,0.89,0h 11m 48s,43
+6,MusicCRNN2D,5s,0.8190909090909091,0.8851883194663308,0.89,0h 13m 50s,68
+7,MusicCRNN2D,10s,0.778,0.9759823226928712,0.85,0h 18m 24s,66
+8,MusicCRNN1D,1s,0.5648333333333333,1.7309636125564576,0.7,0h 11m 57s,97
+9,MusicCRNN1D,3s,0.5510526315789473,1.7096873275857225,0.62,0h 2m 33s,65
+10,MusicCRNN1D,5s,0.5972727272727273,1.698943519592285,0.69,0h 3m 30s,123
+11,MusicCRNN1D,10s,0.532,1.783525552749634,0.59,0h 2m 3s,124
+12,MusicRNN,1s,0.6378333333333334,1.2230633710006171,0.78,0h 5m 56s,45
+13,MusicRNN,3s,0.6210526315789474,1.2467606188984293,0.71,0h 2m 14s,42
+14,MusicRNN,5s,0.6018181818181818,1.1574554492668672,0.63,0h 0m 43s,46
+15,MusicRNN,10s,0.502,1.3741582012176514,0.53,0h 0m 49s,47

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+torch
+librosa
+numpy

src/__init__.py

@@ -0,0 +1,2 @@
+
+

src/models.py

@@ -0,0 +1,153 @@
+import torch.nn as nn
+
+class MusicCNN(nn.Module):
+    def __init__(self, num_classes, dropout_rate=0.3, device="cuda"):
+        super(MusicCNN, self).__init__()
+        self.device = device
+
+        # Convolutional blocks
+        self.conv_block1 = nn.Sequential(
+            nn.Conv2d(1, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.conv_block2 = nn.Sequential(
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.conv_block3 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.fc_layers = None  # Fully connected layers will be initialized later
+        self.num_classes = num_classes
+        self.dropout_rate = dropout_rate
+
+    def forward(self, x):
+        x = self.conv_block1(x)
+        x = self.conv_block2(x)
+        x = self.conv_block3(x)
+
+        # Flatten dynamically
+        x = x.view(x.size(0), -1)
+
+        # Initialize FC layers dynamically
+        if self.fc_layers is None:
+            fc_input_size = x.size(1)
+            self.fc_layers = nn.Sequential(
+                nn.Linear(fc_input_size, 512),
+                nn.BatchNorm1d(512),
+                nn.ReLU(),
+                nn.Dropout(self.dropout_rate),
+                nn.Linear(512, 256),
+                nn.BatchNorm1d(256),
+                nn.ReLU(),
+                nn.Dropout(self.dropout_rate),
+                nn.Linear(256, self.num_classes)
+            ).to(self.device)
+
+        x = self.fc_layers(x)
+        return x
+
+
+class MusicCRNN2D(nn.Module):
+    def __init__(self, num_classes, dropout_rate=0.1, gru_hidden_size=32, device="cuda"):
+        super(MusicCRNN2D, self).__init__()
+        self.device = device
+
+        # Input batch normalization
+        self.input_bn = nn.BatchNorm2d(1).to(device)
+
+        # Convolutional blocks
+        self.conv_block1 = nn.Sequential(
+            nn.Conv2d(1, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ELU(),
+            nn.MaxPool2d((2, 2)),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.conv_block2 = nn.Sequential(
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ELU(),
+            nn.MaxPool2d((4, 2)),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.conv_block3 = nn.Sequential(
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ELU(),
+            nn.MaxPool2d((4, 2)),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.conv_block4 = nn.Sequential(
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ELU(),
+            nn.MaxPool2d((4, 2)),
+            nn.Dropout2d(dropout_rate)
+        ).to(device)
+
+        self.gru_stack = None  # GRU layers will be initialized later
+        self.classifier = None
+        self.num_classes = num_classes
+        self.dropout_rate = dropout_rate
+        self.gru_hidden_size = gru_hidden_size
+
+    def forward(self, x):
+        x = self.input_bn(x)
+        x = self.conv_block1(x)
+        x = self.conv_block2(x)
+        x = self.conv_block3(x)
+        x = self.conv_block4(x)
+
+        # Reshape for GRU
+        batch_size, _, freq, time = x.shape
+        x = x.permute(0, 3, 1, 2)  # (batch, time, channels, freq)
+        x = x.reshape(batch_size, time, -1)
+
+        # Initialize GRU dynamically
+        if self.gru_stack is None:
+            gru_input_size = x.size(2)
+            self.gru_stack = nn.GRU(
+                input_size=gru_input_size,
+                hidden_size=self.gru_hidden_size,
+                batch_first=True,
+                bidirectional=True,
+            ).to(self.device)
+            self.classifier = nn.Sequential(
+                nn.Dropout(self.dropout_rate * 3),
+                nn.Linear(self.gru_hidden_size * 2, self.num_classes)  # * 2 for bidirectional
+            ).to(self.device)
+
+        x, _ = self.gru_stack(x)
+
+        # Take the last time step
+        x = x[:, -1, :]
+
+        # Classification
+        x = self.classifier(x)
+        return x

src/utility.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+def slice_songs(X, Y, S,
+                sr=22050,
+                hop_length=512,
+                length_in_seconds=30,
+                overlap=0.5):
+    """
+    Slice spectrograms into smaller splits with overlap.
+
+    Parameters:
+        X: Array of spectrograms
+        Y: Array of labels
+        S: Array of song names
+        sr: Sample rate (default: 22050)
+        hop_length: Hop length used in spectrogram creation (default: 512)
+        length_in_seconds: Length of each slice in seconds (default: 30)
+        overlap: Overlap ratio between consecutive slices (default: 0.5 for 50% overlap)
+    """
+    # Compute the number of frames for the desired slice length
+    frames_per_second = sr / hop_length
+    slice_length_frames = int(length_in_seconds * frames_per_second)
+
+    # Calculate hop size for overlapping (stride)
+    stride = int(slice_length_frames * (1 - overlap))
+
+    # Initialize lists for sliced data
+    X_slices = []
+    Y_slices = []
+    S_slices = []
+
+    # Slice each spectrogram
+    for i, spectrogram in enumerate(X):
+        num_frames = spectrogram.shape[1]
+
+        # Calculate start positions for all slices
+        start_positions = range(0, num_frames - slice_length_frames + 1, stride)
+
+        for start_frame in start_positions:
+            end_frame = start_frame + slice_length_frames
+
+            # Extract the slice
+            slice_ = spectrogram[:, start_frame:end_frame]
+
+            # Only add if the slice is the expected length
+            if slice_.shape[1] == slice_length_frames:
+                X_slices.append(slice_)
+                Y_slices.append(Y[i])
+                S_slices.append(S[i])
+
+    # Convert lists to numpy arrays
+    X_slices = np.array(X_slices)
+    Y_slices = np.array(Y_slices)
+    S_slices = np.array(S_slices)
+
+    return X_slices, Y_slices, S_slices