Spaces:
Configuration error
Configuration error
| 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 | |