Upload 6 files

README.md

@@ -1,13 +1,84 @@
----
-title: Healing Music Classifier
-emoji: 🦀
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 5.8.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Healing Music Classifier
+
+This project uses machine learning to classify whether a piece of music has healing properties or not. It analyzes various audio features including MFCC, spectral characteristics, rhythm, and harmonic content to make predictions.
+
+## Features
+
+- Audio feature extraction using librosa
+- Machine learning classification using Random Forest
+- Web interface for easy music upload and analysis
+- Visual results with healing probability score
+- Cross-validation for model evaluation
+
+## Installation
+
+1. Clone this repository
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+1. First, train the model:
+```bash
+python train_model.py
+```
+
+2. Run the web application:
+```bash
+streamlit run app.py
+```
+
+3. Open your browser and upload a music file to analyze
+
+## Project Structure
+
+- `train_model.py`: Feature extraction and model training
+- `predict.py`: Prediction functionality
+- `app.py`: Streamlit web interface
+- `requirements.txt`: Project dependencies
+- `model.joblib`: Trained model (generated after training)
+- `scaler.joblib`: Feature scaler (generated after training)
+
+## Technical Details
+
+The classifier uses the following features:
+- Mel-frequency cepstral coefficients (MFCC)
+- Spectral centroid
+- Spectral rolloff
+- Zero crossing rate
+- Chroma features
+- Tempo
+- RMS energy
+
+## Deployment
+
+### Local Deployment
+1. Clone this repository
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+3. Run the web application:
+```bash
+streamlit run app.py
+```
+
+### Cloud Deployment (Streamlit Cloud)
+1. Fork this repository to your GitHub account
+2. Visit [Streamlit Cloud](https://streamlit.io/cloud)
+3. Sign in with your GitHub account
+4. Click "New app" and select this repository
+5. Select the main branch and the app.py file
+6. Click "Deploy"
+
+Note: Make sure to include some sample music files in the `healing_music` and `non_healing_music` folders for training the model.
+
+## License
+
+MIT License
+
+## Contributing
+
+Feel free to open issues and pull requests!

app_gradio.py

@@ -0,0 +1,369 @@
+import gradio as gr
+import os
+from predict import predict_healing_music
+import train_model
+import logging
+import tempfile
+import time
+import shutil
+import socket
+import joblib
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def find_free_port(start_port=7860, max_port=7960):
+    """Find a free port in the given range."""
+    for port in range(start_port, max_port + 1):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('', port))
+                return port
+            except OSError:
+                continue
+    return None
+
+# Ensure model directory exists
+model_dir = os.path.join(os.path.dirname(__file__), "models")
+os.makedirs(model_dir, exist_ok=True)
+
+# Model file paths
+model_path = os.path.join(model_dir, "model.joblib")
+scaler_path = os.path.join(model_dir, "scaler.joblib")
+
+# Check if model exists
+if not os.path.exists(model_path) or not os.path.exists(scaler_path):
+    print('First run: Training the model...')
+    try:
+        train_model.train_and_evaluate_model()
+        print('Model training completed!')
+    except Exception as e:
+        print(f'Model training failed: {str(e)}')
+        raise e
+
+def process_audio(audio_path):
+    """
+    Process and analyze the audio file
+    """
+    if audio_path is None:
+        return None, None, None, "Please upload an audio file"
+    
+    model_dir = os.path.join(os.path.dirname(__file__), "models")
+    model_path = os.path.join(model_dir, "model.joblib")
+    scaler_path = os.path.join(model_dir, "scaler.joblib")
+
+    try:
+        # Load model and scaler
+        model = joblib.load(model_path)
+        scaler = joblib.load(scaler_path)
+        
+        tmp_file = None
+        try:
+            # Create temporary file
+            suffix = os.path.splitext(audio_path)[1]
+            tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+            shutil.copy2(audio_path, tmp_file.name)
+            
+            # Make prediction
+            healing_probability = predict_healing_music(tmp_file.name)
+            
+            if healing_probability is not None:
+                # Calculate percentage
+                healing_percentage = healing_probability * 100
+                
+                # Generate description
+                if healing_percentage >= 75:
+                    description = "This music has strong healing properties! ✨"
+                    color = "#15803d"  # Dark green
+                elif healing_percentage >= 50:
+                    description = "This music has moderate healing effects. 🌟"
+                    color = "#0369a1"  # Dark blue
+                else:
+                    description = "This music has limited healing potential. 🎵"
+                    color = "#b91c1c"  # Dark red
+                
+                return f"{healing_percentage:.1f}%", f'<div style="background-color: {color}; color: white; padding: 1rem; border-radius: 8px; text-align: center;">{description}</div>', None, None
+            else:
+                return "Error", "Error analyzing file. Please ensure it's a valid MP3 or WAV file.", None, None
+                
+        except Exception as e:
+            logger.error(f"Error during analysis: {str(e)}")
+            return "Error", f"An unexpected error occurred: {str(e)}", None, None
+        
+        finally:
+            # Clean up temporary file
+            if tmp_file is not None:
+                try:
+                    tmp_file.close()
+                    os.unlink(tmp_file.name)
+                except Exception as e:
+                    logger.error(f"Failed to clean up temporary file: {str(e)}")
+
+    except Exception as e:
+        logger.error(f"Error during model loading: {str(e)}")
+        return "Error", f"An unexpected error occurred: {str(e)}", None, None
+
+def analyze_audio(audio):
+    """Analyze the audio file"""
+    try:
+        if audio is None:
+            return [
+                gr.update(visible=False),  # results
+                gr.update(visible=False),  # analyzing
+                "",                        # healing_index
+                ""                         # result_text
+            ]
+
+        # Show analyzing status first
+        yield [
+            gr.update(visible=False),      # results
+            gr.update(visible=True),       # analyzing
+            "",                            # healing_index
+            ""                            # result_text
+        ]
+
+        # Process audio and get results
+        index, desc, _, _ = process_audio(audio)
+        desc_with_hint = f'{desc}<div style="margin-top: 1rem; color: #9ca3af; font-size: 0.9rem;">To analyze another file, please refresh the page</div>'
+
+        # Return final results
+        yield [
+            gr.update(visible=True),       # results
+            gr.update(visible=False),      # analyzing
+            index,                         # healing_index
+            desc_with_hint                # result_text
+        ]
+
+    except Exception as e:
+        logger.error(f"Error in analyze_audio: {str(e)}")
+        yield [
+            gr.update(visible=True),       # results
+            gr.update(visible=False),      # analyzing
+            "Error",                       # healing_index
+            f"An error occurred: {str(e)}" # result_text
+        ]
+
+# Custom CSS styles
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    max-width: 800px !important;
+    margin: auto;
+    padding: 0 1rem;
+    background-color: #0f1117;
+}
+.container {
+    max-width: 700px;
+    margin: 0 auto;
+    padding-top: 2rem;
+}
+.header {
+    text-align: center;
+    margin-bottom: 1rem;
+    width: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+.title {
+    font-size: 2.5rem !important;
+    font-weight: 700 !important;
+    color: white !important;
+    margin: 0 !important;
+    line-height: 1.2 !important;
+    text-align: center !important;
+    white-space: nowrap !important;
+}
+.subtitle {
+    font-size: 1.2rem !important;
+    text-align: center;
+    color: #9ca3af !important;
+    margin-top: 0.5rem !important;
+    max-width: 800px;
+    margin-left: auto;
+    margin-right: auto;
+    white-space: nowrap !important;
+}
+.upload-box {
+    background-color: #1f2937;
+    border-radius: 12px;
+    padding: 2rem;
+    margin-bottom: 1rem;
+    border: 2px dashed #374151;
+    transition: all 0.3s ease;
+}
+.upload-box:hover {
+    border-color: #3b82f6;
+    box-shadow: 0 0 10px rgba(59, 130, 246, 0.2);
+}
+.upload-area {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 1rem;
+    padding: 1.5rem 0;
+}
+.icon-text-container {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.2rem;
+    white-space: nowrap;
+}
+.upload-icon {
+    color: #9ca3af;
+    font-size: 2rem;
+    line-height: 1;
+    margin-right: 0.1rem;
+}
+.upload-text {
+    color: white;
+    font-size: 1.1rem;
+    font-weight: 500;
+    line-height: 1;
+}
+.upload-hint {
+    color: #6b7280 !important;
+    font-size: 0.85rem !important;
+    margin-top: 0.5rem !important;
+    font-style: italic !important;
+}
+.progress-area {
+    margin: 1rem 0;
+    background-color: #1f2937;
+    border-radius: 12px;
+    padding: 1.5rem;
+    text-align: center;
+}
+.progress-text {
+    color: #60a5fa !important;
+    font-size: 1.2rem !important;
+    font-weight: 500 !important;
+    margin: 0 !important;
+}
+.results-container {
+    background-color: #1f2937;
+    border-radius: 12px;
+    padding: 1.25rem;
+    margin-top: 1rem;
+    animation: fadeIn 0.5s ease;
+}
+.result-title {
+    color: white !important;
+    font-size: 1.25rem !important;
+    font-weight: 600 !important;
+    margin-bottom: 0.5rem !important;
+}
+.healing-index {
+    font-size: 2.5rem !important;
+    font-weight: 700 !important;
+    text-align: center;
+    color: white !important;
+    margin: 0.5rem 0 !important;
+    animation: scaleIn 0.5s ease;
+}
+.result-text {
+    animation: slideIn 0.5s ease;
+}
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(20px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+@keyframes scaleIn {
+    from { transform: scale(0.8); opacity: 0; }
+    to { transform: scale(1); opacity: 1; }
+}
+@keyframes slideIn {
+    from { transform: translateY(10px); opacity: 0; }
+    to { transform: translateY(0); opacity: 1; }
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(
+    title="Healing Music Classifier",
+    css=custom_css,
+    theme=gr.themes.Default()
+) as demo:
+    with gr.Column(elem_classes="container"):
+        with gr.Row(elem_classes="header"):
+            gr.Markdown("&#127925; Healing Music Classifier", elem_classes="title")
+        
+        gr.Markdown(
+            "Upload your music file, and our model will analyze its healing potential!",
+            elem_classes="subtitle"
+        )
+        
+        with gr.Column(elem_classes="upload-box"):
+            with gr.Column(elem_classes="upload-area"):
+                gr.Markdown("&#9729;&#65039; Drop your audio file here", elem_classes="icon-text-container")
+                audio_input = gr.Audio(
+                    label="Audio Input",
+                    sources=["upload"],
+                    type="filepath",
+                    elem_classes="audio-input",
+                    interactive=True,
+                    label_visible=False,
+                    text="Drop audio file here or click to upload"
+                )
+            gr.Markdown("Limit 200MB per file • MP3, WAV", elem_classes="upload-hint")
+        
+        # Add analyzing status
+        with gr.Column(elem_classes="analyzing-status", visible=False) as analyzing:
+            gr.Markdown(
+                """<div style="display: flex; align-items: center; justify-content: center; gap: 0.5rem;">
+                   <div class="loading-spinner"></div>
+                   <span style="color: #60a5fa;">Analyzing your music...</span>
+                   </div>""",
+                elem_classes="analyzing-text"
+            )
+        
+        with gr.Column(elem_classes="results-container", visible=False) as results:
+            gr.Markdown("Analysis Results", elem_classes="result-title")
+            healing_index = gr.Markdown("", elem_classes="healing-index")
+            result_text = gr.Markdown("", elem_classes="result-text")
+
+    # Add loading spinner CSS
+    demo.load(None, None, None, _js="""
+        () => {
+            const style = document.createElement('style');
+            style.textContent = `
+                .loading-spinner {
+                    width: 20px;
+                    height: 20px;
+                    border: 3px solid #60a5fa;
+                    border-top: 3px solid transparent;
+                    border-radius: 50%;
+                    animation: spin 1s linear infinite;
+                }
+                @keyframes spin {
+                    0% { transform: rotate(0deg); }
+                    100% { transform: rotate(360deg); }
+                }
+            `;
+            document.head.appendChild(style);
+        }
+    """)
+
+    # Audio analysis event
+    audio_input.upload(
+        fn=analyze_audio,
+        inputs=[audio_input],
+        outputs=[
+            results,
+            analyzing,
+            healing_index,
+            result_text
+        ],
+        queue=True
+    )
+
+# Launch application
+if __name__ == "__main__":
+    demo.launch()  # 简化启动配置，让Hugging Face处理端口等
+ 

model.joblib

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

predict.py

@@ -0,0 +1,162 @@
+import joblib
+from train_model import extract_features
+import numpy as np
+import os
+import logging
+import soundfile as sf
+import librosa
+import traceback
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def verify_audio_file(file_path):
+    """Verify if the audio file is valid and can be processed."""
+    try:
+        print(f"[DEBUG] Starting audio file verification for: {file_path}")
+        logger.debug(f"Starting audio file verification for: {file_path}")
+        
+        # Check basic file properties
+        if not os.path.exists(file_path):
+            print(f"[ERROR] File not found: {file_path}")
+            logger.error(f"File not found: {file_path}")
+            return False
+            
+        file_size = os.path.getsize(file_path)
+        print(f"[DEBUG] File size: {file_size} bytes")
+        logger.debug(f"File size: {file_size} bytes")
+        if file_size == 0:
+            print("[ERROR] File is empty")
+            logger.error("File is empty")
+            return False
+            
+        # Try reading with soundfile
+        try:
+            print("[DEBUG] Attempting to read with soundfile...")
+            logger.debug("Attempting to read with soundfile...")
+            with sf.SoundFile(file_path) as audio_file:
+                print(f"[DEBUG] SoundFile success - Sample rate: {audio_file.samplerate}Hz, "
+                      f"Channels: {audio_file.channels}, Frames: {audio_file.frames}")
+                logger.debug(f"SoundFile success - Sample rate: {audio_file.samplerate}Hz, "
+                          f"Channels: {audio_file.channels}, Frames: {audio_file.frames}")
+                if audio_file.frames == 0:
+                    print("[ERROR] Audio file has no frames")
+                    logger.error("Audio file has no frames")
+                    return False
+        except Exception as e:
+            print(f"[WARNING] SoundFile read failed: {str(e)}")
+            logger.warning(f"SoundFile read failed with error: {str(e)}")
+            logger.debug(f"Full traceback: {traceback.format_exc()}")
+            # Don't return False here, try librosa as backup
+            
+        # Try reading with librosa
+        try:
+            print("[DEBUG] Attempting to read with librosa...")
+            logger.debug("Attempting to read with librosa...")
+            y, sr = librosa.load(file_path, duration=1, sr=None)
+            print(f"[DEBUG] Librosa success - Sample rate: {sr}Hz, Length: {len(y)} samples")
+            logger.debug(f"Librosa success - Sample rate: {sr}Hz, Length: {len(y)} samples")
+            if len(y) == 0:
+                print("[ERROR] Librosa loaded empty audio data")
+                logger.error("Librosa loaded empty audio data")
+                return False
+            return True
+        except Exception as e:
+            print(f"[ERROR] Librosa read failed: {str(e)}")
+            logger.error(f"Librosa read failed with error: {str(e)}")
+            logger.debug(f"Full traceback: {traceback.format_exc()}")
+            return False
+            
+    except Exception as e:
+        print(f"[ERROR] Error in verify_audio_file: {str(e)}")
+        logger.error(f"Error in verify_audio_file: {str(e)}")
+        logger.debug(f"Full traceback: {traceback.format_exc()}")
+        return False
+
+def predict_healing_music(audio_path):
+    """
+    Predict whether a music file is healing or not.
+    Returns: probability of being healing music (0-1)
+    """
+    try:
+        # Step 1: Verify audio file
+        print(f"[DEBUG] Starting prediction process for: {audio_path}")
+        logger.info(f"Starting prediction process for: {audio_path}")
+        if not verify_audio_file(audio_path):
+            print("[ERROR] Audio file verification failed")
+            logger.error("Audio file verification failed")
+            return None
+            
+        # Step 2: Load model and scaler
+        try:
+            print("[DEBUG] Loading model and scaler...")
+            logger.info("Loading model and scaler...")
+            if not os.path.exists('model.joblib') or not os.path.exists('scaler.joblib'):
+                print("[ERROR] Model or scaler file not found")
+                logger.error("Model or scaler file not found")
+                return None
+                
+            model = joblib.load('model.joblib')
+            scaler = joblib.load('scaler.joblib')
+            print("[DEBUG] Model and scaler loaded successfully")
+            logger.info("Model and scaler loaded successfully")
+        except Exception as e:
+            print(f"[ERROR] Error loading model or scaler: {str(e)}")
+            logger.error(f"Error loading model or scaler: {str(e)}")
+            return None
+        
+        # Step 3: Extract features
+        try:
+            print("[DEBUG] Starting feature extraction...")
+            logger.info("Starting feature extraction...")
+            features = extract_features(audio_path)
+            if features is None:
+                print("[ERROR] Feature extraction returned None")
+                logger.error("Feature extraction returned None")
+                return None
+                
+            # Verify feature dimensions
+            expected_features = 38  # Updated to match our current feature extraction (26 MFCC + 12 Chroma)
+            if len(features) != expected_features:
+                print(f"[ERROR] Incorrect number of features. Expected {expected_features}, got {len(features)}")
+                logger.error(f"Incorrect number of features. Expected {expected_features}, got {len(features)}")
+                return None
+                
+            print(f"[DEBUG] Successfully extracted {len(features)} features")
+            logger.info(f"Successfully extracted {len(features)} features")
+            logger.debug(f"Feature values: {features}")
+        except Exception as e:
+            print(f"[ERROR] Error during feature extraction: {str(e)}")
+            logger.error(f"Error during feature extraction: {str(e)}")
+            logger.debug(f"Full traceback: {traceback.format_exc()}")
+            return None
+        
+        # Step 4: Scale features
+        try:
+            print("[DEBUG] Scaling features...")
+            logger.info("Scaling features...")
+            features_scaled = scaler.transform(features.reshape(1, -1))
+            print("[DEBUG] Features scaled successfully")
+            logger.info("Features scaled successfully")
+        except Exception as e:
+            print(f"[ERROR] Error scaling features: {str(e)}")
+            logger.error(f"Error scaling features: {str(e)}")
+            return None
+        
+        # Step 5: Make prediction
+        try:
+            print("[DEBUG] Making prediction...")
+            logger.info("Making prediction...")
+            probability = model.predict_proba(features_scaled)[0][1]
+            print(f"[DEBUG] Prediction successful: {probability:.2f}")
+            logger.info(f"Prediction successful: {probability:.2f}")
+            return probability
+        except Exception as e:
+            print(f"[ERROR] Error making prediction: {str(e)}")
+            logger.error(f"Error making prediction: {str(e)}")
+            return None
+            
+    except Exception as e:
+        print(f"[ERROR] Unexpected error during prediction: {str(e)}")
+        logger.error(f"Unexpected error during prediction: {str(e)}")
+        return None

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=3.50.2
+librosa>=0.10.1
+numpy>=1.24.3
+scikit-learn>=1.3.0
+soundfile>=0.12.1
+joblib>=1.3.2
+pandas>=2.0.3

scaler.joblib

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