initial commit

.gitattributes

@@ -0,0 +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

.gitignore

@@ -0,0 +1,5 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+/.vs

README.md

@@ -0,0 +1,90 @@
+---
+title: MusicGenClassify
+emoji: 🎼
+colorFrom: red
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.25.2
+app_file: app.py
+pinned: false
+short_description: Classify a song for use in MusicGen model training
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/6346595c9e5f0fe83fc60444/1O6woCP6rRcUAE6dZqbuB.png
+---
+
+# Audio Classifier for MusicGen Fine-Tuning
+
+## Overview
+The **Audio Classifier for MusicGen Fine-Tuning** is a web-based application designed to generate metadata for `.wav` audio files, facilitating dataset preparation for fine-tuning music generation models like MusicGen from Audiocraft. Built using **Gradio**, the app allows users to upload a single `.wav` file, input a custom label, and receive a JSON output containing detailed metadata. This tool is optimized for deployment as a **Hugging Face Space**, enabling community use for music classification tasks.
+
+## Functionality
+The application processes an uploaded `.wav` file to extract key audio features and predict its music genre, producing a JSON metadata file suitable for MusicGen training. The main features include:
+
+- **User Inputs**:
+  - **Audio File**: Upload a `.wav` file via a Gradio `Audio` component.
+  - **Custom Label**: Enter a descriptive label (e.g., "A calm melody") in a textbox.
+- **Audio Processing**:
+  - **Duration**: Extracts the audio file's length in seconds using `librosa`.
+  - **Tempo**: Estimates beats per minute (BPM) with `librosa.beat.tempo`.
+  - **Sample Rate**: Retrieves the native sample rate (e.g., 44.1kHz) of the `.wav` file.
+  - **Genre Prediction**: Uses a pre-trained audio classification model (`sanchit-gandhi/distilhubert-finetuned-gtzan`) to predict one of 10 genres: blues, classical, country, disco, hiphop, jazz, metal, pop, reggae, or rock.
+- **Output**: A JSON object displayed in a Gradio `JSON` component, containing:
+  - `filename`: Name of the uploaded file.
+  - `duration`: Length in seconds (rounded to 3 decimal places).
+  - `description`: The user-provided label.
+  - `genre`: Predicted music genre.
+  - `tempo`: Tempo in BPM (rounded to 2 decimal places).
+  - `sample_rate`: Native sample rate in Hz.
+
+## Example Output
+For a file `song.wav` with the user-provided label "A calm melody," the JSON output might be:
+```json
+{
+    "filename": "song.wav",
+    "duration": 5.123,
+    "description": "A calm melody",
+    "genre": "jazz",
+    "tempo": 90.5,
+    "sample_rate": 44100
+}
+```
+
+## Technical Details
+- **Framework**: Built with Gradio 5.24.0 for a user-friendly web interface.
+- **Libraries**:
+  - `librosa`: Audio feature extraction (duration, tempo, sample rate).
+  - `transformers` and `torch`: Genre prediction using a pre-trained model.
+  - `numpy`: Numerical operations for probability calculations.
+- **Model**: Utilizes `sanchit-gandhi/distilhubert-finetuned-gtzan`, a DistilHuBERT model fine-tuned on the GTZAN dataset for music genre classification.
+- **Audio Processing**: Resamples audio to 16kHz for the model if the native sample rate differs, ensuring compatibility.
+- **Error Handling**: Returns a JSON error message if processing fails (e.g., invalid file).
+
+## Deployment
+The application is designed for deployment as a **Hugging Face Space**, making it accessible to the community for MusicGen fine-tuning. Deployment steps include:
+- Creating a Space with Gradio as the framework.
+- Uploading the script as `app.py`.
+- Including a `requirements.txt` with dependencies:
+
+    transformers
+    torch
+    torchaudio
+    librosa
+    numpy
+
+- Committing files to build and host the app.
+
+## Use Case
+This tool is ideal for users preparing datasets for MusicGen fine-tuning, particularly those with collections of `.wav` files from games, music, or movies. It automates the generation of metadata, reducing manual effort in labeling audio files. The JSON output is compatible with Audiocraft’s training requirements, enabling users to fine-tune music generation models efficiently.
+
+## Benefits
+- **User-Friendly**: Simple interface for uploading files and entering labels.
+- **Automated Metadata**: Generates detailed metadata (genre, tempo, sample rate) to enhance descriptions.
+- **Community Access**: Deployment on Hugging Face Spaces allows others to use it for similar tasks.
+- **Audiocraft Compatibility**: Produces JSON files with required fields (`duration`, `description`) for MusicGen training.
+
+## Limitations
+- **Single File Processing**: Processes one file at a time, suitable for individual classification but not batch processing.
+- **Genre Scope**: Limited to 10 genres from the GTZAN dataset, which may not cover all music types.
+- **Label Dependency**: Relies on user input for the description, requiring manual effort for custom labels.
+
+This application streamlines the preparation of audio datasets for MusicGen fine-tuning, offering a practical tool for researchers and enthusiasts in music generation.

app.py

@@ -0,0 +1,79 @@
+import gradio as gr
+import librosa
+from transformers import AutoModelForAudioClassification, AutoFeatureExtractor
+import torch
+import numpy as np
+import os
+
+# Load the pre-trained model and feature extractor for genre prediction
+model_name = "sanchit-gandhi/distilhubert-finetuned-gtzan"
+feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
+model = AutoModelForAudioClassification.from_pretrained(model_name)
+
+# List of genres the model can predict
+genres = ["blues", "classical", "country", "disco", "hiphop", "jazz", "metal", "pop", "reggae", "rock"]
+
+# Function to process the uploaded audio file
+def process_audio(audio_file, user_label):
+    try:
+        # Extract filename from the uploaded file path
+        filename = os.path.basename(audio_file)
+        
+        # Load the audio file with its native sample rate
+        audio, sr = librosa.load(audio_file, sr=None)
+        
+        # Extract duration
+        duration = librosa.get_duration(y=audio, sr=sr)
+        
+        # Extract tempo
+        tempo = librosa.beat.tempo(y=audio, sr=sr)[0]
+        
+        # Preprocess audio for the model (resample to 16kHz if needed)
+        target_sr = 16000
+        if sr != target_sr:
+            audio = librosa.resample(audio, orig_sr=sr, target_sr=target_sr)
+            sr_model = target_sr
+        else:
+            sr_model = sr
+        inputs = feature_extractor(audio, sampling_rate=sr_model, return_tensors="pt")
+        
+        # Predict genre using the model
+        with torch.no_grad():
+            logits = model(**inputs).logits
+        probabilities = torch.nn.functional.softmax(logits, dim=-1).squeeze().numpy()
+        predicted_genre = genres[np.argmax(probabilities)]
+        
+        # Use the user-provided label as the description
+        description = f"{user_label}, {predicted_genre}, {tempo:.2f} BPM, {sr} Hz"
+        
+        # Create metadata dictionary
+        metadata = {
+            "filename": filename,
+            "duration": np.round(duration, 3),
+            "description": description,
+            "genre": predicted_genre,
+            "tempo":  np.round(tempo, 2),
+            "sample_rate": sr
+        }
+        
+        return metadata
+    except Exception as e:
+        return {"error": str(e)}
+
+# Gradio interface
+with gr.Blocks(theme="Surn/beeuty") as app:
+    gr.Markdown("# Audio Classifier for MusicGen Fine Tuning")
+    gr.Markdown("Upload a audio file (preferred `.wav`), provide a label, and get metadata for MusicGen training.")
+    
+    with gr.Row():
+        audio_input = gr.Audio(label="Upload Audio File", type="filepath")
+        label_input = gr.Textbox(label="Enter Label", placeholder="e.g., A calm melody")
+    
+    submit_button = gr.Button("Classify")
+    
+    output_json = gr.JSON(label="Metadata Output")
+    
+    submit_button.click(process_audio, inputs=[audio_input, label_input], outputs=output_json)
+
+# Launch the app
+app.launch()

requirements.txt

@@ -0,0 +1,5 @@
+transformers
+torch
+torchaudio
+librosa==0.10.2.post1
+numpy