usage of pickle instead of joblib

models/audio_model.pkl

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

tasks/audio.py

@@ -1,52 +1,52 @@
 from fastapi import APIRouter, HTTPException
 from datetime import datetime
-from datasets import load_dataset, get_dataset_config_names
+from datasets import load_dataset
 from sklearn.metrics import accuracy_score
 import os
-import joblib
+import pickle
+from pathlib import Path
 import numpy as np
 import librosa
-from pathlib import Path
-
+from sklearn.preprocessing import StandardScaler
+from dotenv import load_dotenv
 from .utils.evaluation import AudioEvaluationRequest
 from .utils.emissions import tracker, clean_emissions_data, get_space_info
 
-# Router setup
+# Charger les variables d'environnement
+load_dotenv()
+
+# Configuration du router
 router = APIRouter()
 
-DESCRIPTION = "Chainsaw Detection Model"
+DESCRIPTION = "Random Forest with Feature Engineering"
 ROUTE = "/audio"
+MODEL_PATH = Path(__file__).parent.parent / "models" / "audio_model.pkl"
+    
+SAMPLING_RATE = 12000
+N_MFCC = 13
 
-# Model loading
-MODEL_PATH = Path(__file__).parent.parent / "models" / "audio_model.joblib"
-try:
-    model_data = joblib.load(MODEL_PATH)
-    model = model_data["model"]
-    scaler = model_data["scaler"]
-except Exception as e:
-    raise RuntimeError(f"Failed to load model: {e}")
-
-def extract_features(audio_array, sr=12000):
-    """Extract audio features using Librosa"""
+def extract_features(audio_array):
+    """Feature engineering identical to the training phase."""
     try:
+        if not isinstance(audio_array, np.ndarray) or len(audio_array) == 0:
+            return None
+
         # Convert to mono if stereo
-        y = np.mean(audio_array, axis=1) if len(audio_array.shape) > 1 else audio_array
-        
-        # Extract MFCCs
+        y = np.mean(audio_array, axis=1) if audio_array.ndim > 1 else audio_array
+
+        # Extract MFCCs and additional features
         mfccs = librosa.feature.mfcc(
             y=y,
-            sr=sr,
-            n_mfcc=13,
+            sr=SAMPLING_RATE,
+            n_mfcc=N_MFCC,
             n_fft=2048,
             hop_length=512
         )
-        
-        # Extract additional features
         zcr = librosa.feature.zero_crossing_rate(y)
         rms = librosa.feature.rms(y=y)
-        spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
-        
-        # Calculate statistics
+        spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=SAMPLING_RATE)
+
+        # Combine features into a single vector
         feature_vector = np.concatenate([
             np.mean(mfccs, axis=1),
             np.std(mfccs, axis=1),
@@ -54,93 +54,82 @@ def extract_features(audio_array, sr=12000):
             [np.mean(rms)],
             [np.mean(spectral_centroid)]
         ])
-        
+
         return feature_vector
-        
+
     except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Feature extraction failed: {str(e)}")
+        raise ValueError(f"Feature extraction error: {str(e)}")
 
 @router.post(ROUTE, tags=["Audio Task"], description=DESCRIPTION)
 async def evaluate_audio(request: AudioEvaluationRequest):
+    """
+    Evaluate audio classification for rainforest sound detection using Random Forest.
+    """
     try:
-        # Get Space info
+        # Get space information (username and URL)
         username, space_url = get_space_info()
 
-        # Load dataset with proper error handling
-        try:
-            # Get available configs
-            configs = get_dataset_config_names(request.dataset_name)
-            
-            # Set up dataset loading arguments
-            dataset_args = {
-                "path": request.dataset_name,
-                "token": os.getenv("HF_TOKEN"),
-                "trust_remote_code": True
-            }
-            
-            # If configs exist, automatically use 'default' if it's the only one
-            if configs:
-                if len(configs) == 1 and configs[0] == 'default':
-                    dataset_args["name"] = "default"
-                else:
-                    raise HTTPException(
-                        status_code=400,
-                        detail=f"Config name is required for this dataset. Available configs: {configs}"
-                    )
-            
-            dataset = load_dataset(**dataset_args)
-            
-        except Exception as e:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Failed to load dataset: {str(e)}"
-            )
-
-        # Split dataset
-        split = dataset["train"].train_test_split(
+        # Load dataset from Hugging Face
+        dataset = load_dataset(
+            request.dataset_name,
+            token=os.getenv("HF_TOKEN")
+        )
+
+        # Split dataset into train and test sets
+        train_test = dataset["train"].train_test_split(
             test_size=request.test_size,
             seed=request.test_seed
         )
-        test_data = split["test"]
+        test_dataset = train_test["test"]
 
-        # Track emissions
+        # Start emissions tracking for inference phase
         tracker.start()
         tracker.start_task("inference")
+
+        # Prepare test data using the same feature engineering as in training
+        x_test = []
+        true_labels = []
         
-        # Process features
-        features = []
-        valid_samples = []
-        for sample in test_data:
-            try:
-                if 'audio' in sample and isinstance(sample['audio'], dict) and 'array' in sample['audio']:
-                    feature = extract_features(sample['audio']['array'])
-                    if feature is not None:
-                        features.append(feature)
-                        valid_samples.append(sample)
-            except Exception as e:
-                print(f"Skipping sample due to error: {e}")
-                continue
-
-        if not features:
-            raise HTTPException(
-                status_code=400,
-                detail="No valid features could be extracted from the audio samples"
-            )
-
-        # Scale features and make predictions
-        scaled_features = scaler.transform(features)
-        predictions = model.predict(scaled_features)
-        true_labels = [sample["label"] for sample in valid_samples]
-
-        # Calculate results
+        for sample in test_dataset:
+            features = extract_features(sample["audio"]["array"])
+            if features is not None:
+                x_test.append(features)
+                true_labels.append(sample["label"])
+
+        if len(x_test) == 0:
+            raise ValueError("No valid features could be extracted from the test dataset.")
+
+        x_test = np.array(x_test)
+
+        # Load the trained model and scaler from pickle file
+        with open(MODEL_PATH, 'rb') as f:
+            model_data = pickle.load(f)
+
+        model = model_data['model']
+        scaler = model_data['scaler']
+
+        # Scale the test data using the scaler from training phase
+        if scaler is not None:
+            x_test_scaled = scaler.transform(x_test)
+        else:
+            x_test_scaled = x_test
+
+        # Make predictions on the test set
+        predictions = model.predict(x_test_scaled)
+
+        # Stop emissions tracking and get data
         emissions_data = tracker.stop_task()
-        
+
+        # Calculate accuracy score for evaluation
+        accuracy = accuracy_score(true_labels, predictions)
+
+        # Prepare and return results as JSON response
         return {
             "username": username,
             "space_url": space_url,
             "submission_timestamp": datetime.now().isoformat(),
             "model_description": DESCRIPTION,
-            "accuracy": float(accuracy_score(true_labels, predictions)),
+            "accuracy": float(accuracy),
             "energy_consumed_wh": emissions_data.energy_consumed * 1000,
             "emissions_gco2eq": emissions_data.emissions * 1000,
             "emissions_data": clean_emissions_data(emissions_data),
@@ -148,12 +137,12 @@ async def evaluate_audio(request: AudioEvaluationRequest):
             "dataset_config": {
                 "dataset_name": request.dataset_name,
                 "test_size": request.test_size,
-                "test_seed": request.test_seed
-            }
+                "test_seed": request.test_seed,
+            },
         }
 
     except Exception as e:
         raise HTTPException(
             status_code=500,
-            detail=f"An error occurred during audio evaluation: {str(e)}"
+            detail=f"An error occurred during evaluation: {str(e)}"
         )