Auto-deploy from GitHub: e4d0ee2ddb3dc15442ce902b31f6de26098a6291

app/schemas.py

@@ -40,8 +40,17 @@ class PredictionXAIResponse(BaseModel):
     results: Optional[Dict] = None
 
 
-# Pydantic model for the error response
-class ErrorResponse(BaseModel):
-    status: str = "error"
-    code: int
-    message: str
+class AudioOnlyPredictionResponse(BaseModel):
+    status: str
+    audio_file_name: str
+    audio_content_type: str
+    audio_file_size: int
+    results: dict
+
+
+class AudioOnlyPredictionXAIResponse(BaseModel):
+    status: str
+    audio_file_name: str
+    audio_content_type: str
+    audio_file_size: int
+    results: dict

app/server.py

@@ -1,26 +1,27 @@
 # Fast API imports
-from fastapi import Depends, FastAPI, File, Form, HTTPException, UploadFile
+from fastapi import Depends, FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 
 # Utils/schemas imports
 from app.schemas import (
-    ErrorResponse,
     ModelInfoResponse,
     PredictionResponse,
     PredictionXAIResponse,
+    AudioOnlyPredictionResponse,
+    AudioOnlyPredictionXAIResponse,
     WelcomeResponse,
 )
-from app.utils import load_server_config, load_model_config, download_youtube_audio
+from app.utils import load_server_config, load_model_config
+from app.validators import validate_lyrics, validate_audio_source, validate_audio_only
 
 # Model/XAI-related imports
-from scripts.explain import musiclime
-from scripts.predict import predict_multimodal
+from scripts.explain import musiclime_multimodal, musiclime_unimodal
+from scripts.predict import predict_multimodal, predict_unimodal
 
 # Other imports
 import io
 import librosa
-from typing import Optional, Tuple
-
+from typing import Tuple
 
 # Load configs at startup
 server_config = load_server_config()
@@ -47,70 +48,9 @@ app.add_middleware(
 )
 
 
-def validate_lyrics(lyrics: str = Form(...)):
-    """Validate lyrics length and content."""
-    if len(lyrics) > MAX_LYRICS_LENGTH:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Lyrics too long. Maximum length is {MAX_LYRICS_LENGTH} characters.",
-        )
-
-    # Basic sanitization, remove excessive whitespace
-    lyrics = lyrics.strip()
-    if not lyrics:
-        raise HTTPException(
-            status_code=400,
-            detail="Lyrics cannot be empty.",
-        )
-
-    return lyrics
-
-
-async def validate_audio_source(
-    audio_file: Optional[UploadFile] = File(None),
-    youtube_url: Optional[str] = Form(None),
-) -> Tuple[Optional[bytes], str, str]:
-    """
-    Validate and process audio source (either file or YouTube URL).
-    Returns: (audio_content, file_name, content_type)
-    """
-    if not audio_file and not youtube_url:
-        raise HTTPException(
-            status_code=400, detail="Either audio_file or youtube_url must be provided"
-        )
-
-    if audio_file and youtube_url:
-        raise HTTPException(
-            status_code=400, detail="Provide either audio_file or youtube_url, not both"
-        )
-
-    # Process YouTube URL
-    if youtube_url:
-        audio_content = download_youtube_audio(youtube_url)
-        return audio_content, "youtube_audio.wav", "audio/wav"
-
-    # Process uploaded file
-    if audio_file.content_type not in ALLOWED_AUDIO_TYPES:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid file type. Supported formats: {', '.join(ALLOWED_AUDIO_TYPES)}",
-        )
-
-    audio_content = await audio_file.read()
-    if len(audio_content) > MAX_FILE_SIZE:
-        raise HTTPException(
-            status_code=400,
-            detail=f"File too large. Maximum size is {MAX_FILE_SIZE // (1024*1024)}MB.",
-        )
-
-    return audio_content, audio_file.filename, audio_file.content_type
-
-
 @app.get("/", response_model=WelcomeResponse, tags=["Root"])
 def root():
-    """
-    Root endpoint to check if the API is running.
-    """
+    """Root endpoint to check if the API is running."""
     return WelcomeResponse(
         status="success",
         message="Welcome to Bach or Bot API!",
@@ -118,18 +58,38 @@ def root():
             "/": "This welcome message",
             "/docs": "FastAPI auto-generated API docs",
             "/api/v1/model/info": "Model information and capabilities",
-            "/api/v1/predict": "POST endpoint for bach-or-bot prediction",
-            "/api/v1/explain": "POST endpoint for prediction with explainability",
+            "/api/v1/predict": "POST endpoint for bach-or-bot prediction (legacy)",
+            "/api/v1/explain": "POST endpoint for prediction with explainability (legacy)",
+            "/api/v1/predict/multimodal": "POST endpoint for multimodal prediction",
+            "/api/v1/explain/multimodal": "POST endpoint for multimodal explainability",
+            "/api/v1/predict/audio": "POST endpoint for audio-only prediction",
+            "/api/v1/explain/audio": "POST endpoint for audio-only explainability",
         },
     )
 
 
-@app.post(
-    "/api/v1/predict",
-    response_model=PredictionResponse,
-    responses={400: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
-)
-async def predict_music(
+# Legacy endpoints (backward compatibility)
+@app.post("/api/v1/predict", response_model=PredictionResponse)
+async def predict_music_legacy(
+    lyrics: str = Depends(validate_lyrics),
+    audio_data_tuple: Tuple = Depends(validate_audio_source),
+):
+    """Legacy multimodal prediction endpoint."""
+    return await predict_multimodal_endpoint(lyrics, audio_data_tuple)
+
+
+@app.post("/api/v1/explain", response_model=PredictionXAIResponse)
+async def explain_music_legacy(
+    lyrics: str = Depends(validate_lyrics),
+    audio_data_tuple: Tuple = Depends(validate_audio_source),
+):
+    """Legacy multimodal explanation endpoint."""
+    return await explain_multimodal_endpoint(lyrics, audio_data_tuple)
+
+
+# New multimodal endpoints
+@app.post("/api/v1/predict/multimodal", response_model=PredictionResponse)
+async def predict_multimodal_endpoint(
     lyrics: str = Depends(validate_lyrics),
     audio_data_tuple: Tuple = Depends(validate_audio_source),
 ):
@@ -164,12 +124,8 @@ async def predict_music(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post(
-    "/api/v1/explain",
-    response_model=PredictionXAIResponse,
-    responses={400: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
-)
-async def predict_music_with_xai(
+@app.post("/api/v1/explain/multimodal", response_model=PredictionXAIResponse)
+async def explain_multimodal_endpoint(
     lyrics: str = Depends(validate_lyrics),
     audio_data_tuple: Tuple = Depends(validate_audio_source),
 ):
@@ -188,7 +144,7 @@ async def predict_music_with_xai(
             raise HTTPException(status_code=400, detail=f"Invalid audio file: {str(e)}")
 
         # Call musiclime runner script
-        results = musiclime(audio_data, lyrics)
+        results = musiclime_multimodal(audio_data, lyrics)
 
         return PredictionXAIResponse(
             status="success",
@@ -204,6 +160,63 @@ async def predict_music_with_xai(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+# New audio-only endpoints
+@app.post("/api/v1/predict/audio", response_model=AudioOnlyPredictionResponse)
+async def predict_audio_only_endpoint(
+    audio_data_tuple: Tuple = Depends(validate_audio_only),
+):
+    """Audio-only prediction endpoint."""
+    try:
+        audio_content, audio_file_name, audio_content_type = audio_data_tuple
+
+        try:
+            audio_data, sr = librosa.load(io.BytesIO(audio_content))
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid audio file: {str(e)}")
+
+        results = predict_unimodal(audio_data)
+
+        return AudioOnlyPredictionResponse(
+            status="success",
+            audio_file_name=audio_file_name,
+            audio_content_type=audio_content_type,
+            audio_file_size=len(audio_content),
+            results=results,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/v1/explain/audio", response_model=AudioOnlyPredictionXAIResponse)
+async def explain_audio_only_endpoint(
+    audio_data_tuple: Tuple = Depends(validate_audio_only),
+):
+    """Audio-only explanation endpoint."""
+    try:
+        audio_content, audio_file_name, audio_content_type = audio_data_tuple
+
+        try:
+            audio_data, sr = librosa.load(io.BytesIO(audio_content))
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid audio file: {str(e)}")
+
+        results = musiclime_unimodal(audio_data, modality="audio")
+
+        return AudioOnlyPredictionXAIResponse(
+            status="success",
+            audio_file_name=audio_file_name,
+            audio_content_type=audio_content_type,
+            audio_file_size=len(audio_content),
+            results=results,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.get("/api/v1/model/info", response_model=ModelInfoResponse, tags=["Model"])
 async def get_model_info():
     """

app/validators.py

@@ -0,0 +1,75 @@
+from fastapi import File, Form, HTTPException, UploadFile
+from typing import Optional, Tuple
+from app.utils import download_youtube_audio
+
+
+# Import config values
+def get_config_values():
+    from app.server import MAX_FILE_SIZE, MAX_LYRICS_LENGTH, ALLOWED_AUDIO_TYPES
+
+    return MAX_FILE_SIZE, MAX_LYRICS_LENGTH, ALLOWED_AUDIO_TYPES
+
+
+def validate_lyrics(lyrics: str = Form(...)):
+    """Validate lyrics length and content for multimodal endpoints."""
+    _, MAX_LYRICS_LENGTH, _ = get_config_values()
+
+    if len(lyrics) > MAX_LYRICS_LENGTH:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Lyrics too long. Maximum length is {MAX_LYRICS_LENGTH} characters.",
+        )
+
+    lyrics = lyrics.strip()
+    if not lyrics:
+        raise HTTPException(
+            status_code=400,
+            detail="Lyrics cannot be empty.",
+        )
+    return lyrics
+
+
+async def validate_audio_source(
+    audio_file: Optional[UploadFile] = File(None),
+    youtube_url: Optional[str] = Form(None),
+) -> Tuple[Optional[bytes], str, str]:
+    """Validate and process audio source from file upload or YouTube URL."""
+    MAX_FILE_SIZE, _, ALLOWED_AUDIO_TYPES = get_config_values()
+
+    if not audio_file and not youtube_url:
+        raise HTTPException(
+            status_code=400, detail="Either audio_file or youtube_url must be provided"
+        )
+
+    if audio_file and youtube_url:
+        raise HTTPException(
+            status_code=400, detail="Provide either audio_file or youtube_url, not both"
+        )
+
+    if youtube_url:
+        audio_content = download_youtube_audio(youtube_url)
+        return audio_content, "youtube_audio.wav", "audio/wav"
+
+    if audio_file.content_type not in ALLOWED_AUDIO_TYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid file type. Supported formats: {', '.join(ALLOWED_AUDIO_TYPES)}",
+        )
+
+    audio_content = await audio_file.read()
+    if len(audio_content) > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Maximum size is {MAX_FILE_SIZE // (1024*1024)}MB.",
+        )
+
+    return audio_content, audio_file.filename, audio_file.content_type
+
+
+async def validate_audio_only(
+    audio_file: Optional[UploadFile] = File(None),
+    youtube_url: Optional[str] = Form(None),
+) -> Tuple[Optional[bytes], str, str]:
+    """Validate audio source for audio-only endpoints (no lyrics required)."""
+    # Same validation as validate_audio_source but clearer naming for audio-only
+    return await validate_audio_source(audio_file, youtube_url)

scripts/explain.py

@@ -2,17 +2,25 @@ import os
 import numpy as np
 from datetime import datetime
 from src.musiclime.explainer import MusicLIMEExplainer
-from src.musiclime.wrapper import MusicLIMEPredictor
+from src.musiclime.wrapper import MusicLIMEPredictor, AudioOnlyPredictor
 
 
-def musiclime(audio_data, lyrics_text):
+def musiclime_multimodal(audio_data, lyrics_text):
     """
-    MusicLIME wrapper for API usage.
-    Args:
-        audio_data: Audio array (from librosa.load or similar)
-        lyrics_text: String containing lyrics
-    Returns:
-        dict: Structured explanation results
+    Generate multimodal MusicLIME explanations for audio and lyrics.
+
+    Parameters
+    ----------
+    audio_data : array-like
+        Audio waveform data from librosa.load or similar
+    lyrics_text : str
+        String containing song lyrics
+
+    Returns
+    -------
+    dict
+        Structured explanation results containing prediction info, feature explanations,
+        and processing metadata
     """
     start_time = datetime.now()
 
@@ -77,3 +85,97 @@ def musiclime(audio_data, lyrics_text):
             "timestamp": start_time.isoformat(),
         },
     }
+
+
+def musiclime_unimodal(audio_data, modality="audio"):
+    """
+    Generate unimodal MusicLIME explanations for single modality.
+
+    Parameters
+    ----------
+    audio_data : array-like
+        Audio waveform data from librosa.load or similar
+    modality : str, default='audio'
+        Explanation modality, currently only supports 'audio'
+
+    Returns
+    -------
+    dict
+        Structured explanation results containing prediction info, audio-only feature
+        explanations, and processing metadata
+
+    Raises
+    ------
+    ValueError
+        If modality is not 'audio' (lyrics is not yet implemented)
+    """
+    if modality != "audio":
+        raise ValueError(
+            "Currently only 'audio' modality is supported for unimodal explanations"
+        )
+
+    start_time = datetime.now()
+
+    # Get number of samples from environment variable, default to 1000
+    num_samples = int(os.getenv("MUSICLIME_NUM_SAMPLES", "1000"))
+    num_features = int(os.getenv("MUSICLIME_NUM_FEATURES", "10"))
+
+    print(
+        f"[MusicLIME] Using num_samples={num_samples}, num_features={num_features} (audio-only mode)"
+    )
+
+    # Create musiclime instances
+    explainer = MusicLIMEExplainer(random_state=42)
+    predictor = AudioOnlyPredictor()
+
+    # Use empty lyrics for audio-only since they're ignored anyways
+    dummy_lyrics = ""
+
+    # Generate explanation
+    explanation = explainer.explain_instance(
+        audio=audio_data,
+        lyrics=dummy_lyrics,
+        predict_fn=predictor,
+        num_samples=num_samples,
+        labels=(1,),
+        modality=modality,
+    )
+
+    # Get prediction info
+    original_prediction = explanation.predictions[0]
+    predicted_class = np.argmax(original_prediction)
+    confidence = float(np.max(original_prediction))
+
+    # Get top features
+    top_features = explanation.get_explanation(label=1, num_features=num_features)
+
+    # Calculate runtime
+    end_time = datetime.now()
+    runtime_seconds = (end_time - start_time).total_seconds()
+
+    return {
+        "prediction": {
+            "class": int(predicted_class),
+            "class_name": "Human-Composed" if predicted_class == 1 else "AI-Generated",
+            "confidence": confidence,
+            "probabilities": original_prediction.tolist(),
+        },
+        "explanations": [
+            {
+                "rank": i + 1,
+                "modality": item["type"],  # "audio" for all features
+                "feature_text": item["feature"],
+                "weight": float(item["weight"]),
+                "importance": abs(float(item["weight"])),
+            }
+            for i, item in enumerate(top_features)
+        ],
+        "summary": {
+            "total_features_analyzed": len(top_features),
+            "audio_features_count": len(top_features),  # All features are audio
+            "lyrics_features_count": 0,  # No lyrics features
+            "runtime_seconds": runtime_seconds,
+            "samples_generated": num_samples,
+            "timestamp": start_time.isoformat(),
+        },
+    }

scripts/explain_runner.py

@@ -1,30 +1,69 @@
 import librosa
-from scripts.explain import musiclime
+from scripts.explain import musiclime_multimodal, musiclime_unimodal
 
-# Load test audio and lyrics
-audio_path = "data/external/sample_1.mp3"
-lyrics_path = "data/external/sample_1.txt"
 
-# Load audio
-audio_data, sr = librosa.load(audio_path)
+def explain_multimodal_runner(sample: str):
+    # Load test audio and lyrics
+    audio_path = f"data/external/{sample}.mp3"
+    lyrics_path = f"data/external/{sample}.txt"
 
-# Load lyrics
-with open(lyrics_path, "r", encoding="utf-8") as f:
-    lyrics_text = f.read()
+    # Load audio
+    audio_data, sr = librosa.load(audio_path)
 
-print("Running MusicLIME explanation...")
-result = musiclime(audio_data, lyrics_text)
+    # Load lyrics
+    with open(lyrics_path, "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
 
-print("\n=== EXPLANATION RESULTS ===")
-print(
-    f"Prediction: {result['prediction']['class_name']} ({result['prediction']['confidence']:.3f})"
-)
-print(f"Runtime: {result['summary']['runtime_seconds']:.2f}s")
+    print("Running multimodal MusicLIME explanation...")
+    result = musiclime_multimodal(audio_data, lyrics_text)
 
-print("\n=== TOP FEATURES (by absolute importance) ===")
-for feature in result["explanations"]:
+    print("\n=== MULTIMODAL EXPLANATION RESULTS ===")
     print(
-        f"Rank {feature['rank']}: {feature['modality']} | Weight: {feature['weight']:.4f} | Importance: {feature['importance']:.4f}"
+        f"Prediction: {result['prediction']['class_name']} ({result['prediction']['confidence']:.3f})"
     )
-    print(f"  Feature: {feature['feature_text'][:80]}...")
-    print()
+    print(f"Runtime: {result['summary']['runtime_seconds']:.2f}s")
+
+    print("\n=== TOP FEATURES (by absolute importance) ===")
+    for feature in result["explanations"]:
+        print(
+            f"Rank {feature['rank']}: {feature['modality']} | Weight: {feature['weight']:.4f} | Importance: {feature['importance']:.4f}"
+        )
+        print(f"  Feature: {feature['feature_text'][:80]}...")
+        print()
+
+
+def explain_unimodal_runner(sample: str):
+    # Load test audio
+    audio_path = f"data/external/{sample}.mp3"
+
+    # Load audio
+    audio_data, sr = librosa.load(audio_path)
+
+    print("Running audio-only MusicLIME explanation...")
+    result = musiclime_unimodal(audio_data, modality="audio")
+
+    print("\n=== AUDIO-ONLY EXPLANATION RESULTS ===")
+    print(
+        f"Prediction: {result['prediction']['class_name']} ({result['prediction']['confidence']:.3f})"
+    )
+    print(f"Runtime: {result['summary']['runtime_seconds']:.2f}s")
+
+    print("\n=== TOP FEATURES (by absolute importance) ===")
+    for feature in result["explanations"]:
+        print(
+            f"Rank {feature['rank']}: {feature['modality']} | Weight: {feature['weight']:.4f} | Importance: {feature['importance']:.4f}"
+        )
+        print(f"  Feature: {feature['feature_text'][:80]}...")
+        print()
+
+
+if __name__ == "__main__":
+    sample = "sample"
+
+    # Run multimodal explanation
+    explain_multimodal_runner(sample)
+
+    print("\n" + "=" * 60 + "\n")
+
+    # Run audio-only explanation
+    explain_unimodal_runner(sample)

scripts/predict.py

@@ -1,4 +1,7 @@
-from src.preprocessing.preprocessor import single_preprocessing, single_audio_preprocessing
+from src.preprocessing.preprocessor import (
+    single_preprocessing,
+    single_audio_preprocessing,
+)
 from src.spectttra.spectttra_trainer import spectttra_predict
 from src.llm2vectrain.model import load_llm2vec_model
 from src.llm2vectrain.llm2vec_trainer import l2vec_single_train, load_pca_model
@@ -55,7 +58,7 @@ def predict_multimodal(audio_file, lyrics):
     classifier = build_mlp(input_dim=results.shape[1], config=config)
 
     # 7.) Load trained weights
-    model_path = "models/mlp/mlp_best.pth"
+    model_path = "models/mlp/mlp_best_multimodal.pth"
     classifier.load_model(model_path)
     classifier.model.eval()
 
@@ -106,7 +109,7 @@ def predict_unimodal(audio_file):
     classifier = build_mlp(input_dim=audio_features.shape[1], config=config)
 
     # 6.) Load trained weights
-    model_path = "models/spectttra/mlp_best.pth"
+    model_path = "models/mlp/mlp_best_unimodal.pth"
     classifier.load_model(model_path)
     classifier.model.eval()
 

scripts/predict_runner.py

@@ -14,28 +14,33 @@ def predict_multimodal_runner(sample: str):
     with open(lyrics_path, "r", encoding="utf-8") as f:
         lyrics_text = f.read()
 
-    print("Running prediction pipeline...")
+    print("Running multimodal prediction pipeline...")
     prediction = predict_multimodal(audio_data, lyrics_text)
 
-    print(f"\n=== PREDICTION RESULT ===")
+    print("\n=== MULTIMODAL PREDICTION RESULT ===")
     print(f"Prediction: {prediction}")
 
 
 def predict_unimodal_runner(sample: str):
-    # Load test audio and lyrics
-    audio_path = f"data/raw/{sample}.mp3"
+    # Load test audio
+    audio_path = f"data/external/{sample}.mp3"
 
     # Load audio
     audio_data, sr = librosa.load(audio_path)
 
-    print("Running prediction pipeline...")
+    print("Running audio-only prediction pipeline...")
     prediction = predict_unimodal(audio_data)
 
-    print(f"\n=== PREDICTION RESULT ===")
+    print("\n=== AUDIO-ONLY PREDICTION RESULT ===")
     print(f"Prediction: {prediction}")
 
 
 if __name__ == "__main__":
-    sample = "fake_sunshine"
+    sample = "sample"
+
+    # Run both predictions
+    predict_multimodal_runner(sample)
+
+    print("\n" + "=" * 50 + "\n")
 
-    predict_unimodal_runner(sample)
+    predict_unimodal_runner(sample)

src/musiclime/explainer.py

@@ -57,9 +57,15 @@ class MusicLIMEExplainer:
         num_samples=1000,
         labels=(1,),
         temporal_segments=10,
+        modality="both",
     ):
         """
-        Generate LIME explanations for a music instance using audio and lyrics.
+        Generate LIME explanations for a music instance using audio and/or lyrics.
+
+        This method creates local explanations by perturbing audio components (via source
+        separation) and/or lyrics lines, then analyzing their impact on model predictions.
+        Supports three modality modes: 'both' (multimodal), 'audio' (audio-only), and
+        'lyrical' (lyrics-only) following the original MusicLIME paper implementation.
 
         Parameters
         ----------
@@ -75,18 +81,26 @@ class MusicLIMEExplainer:
             Target labels to explain (0=AI-Generated, 1=Human-Composed)
         temporal_segments : int, default=10
             Number of temporal segments for audio factorization
+        modality : str, default='both'
+            Explanation modality: 'both' (multimodal), 'audio' (audio-only), or 'lyrical' (lyrics-only)
 
         Returns
         -------
         MusicLIMEExplanation
-            Explanation object containing feature importance weights
+            Explanation object containing feature importance weights and metadata
         """
+        # Validation for modality choice
+        if modality not in ["both", "audio", "lyrical"]:
+            raise ValueError("Set modality argument to 'both', 'audio', 'lyrical'.")
+
         # These are for debugging only I have to see THAT progress
         print("[MusicLIME] Starting MusicLIME explanation...")
         print(
             f"[MusicLIME] Audio length: {len(audio)/22050:.1f}s, Temporal segments: {temporal_segments}"
         )
         print(f"[MusicLIME] Lyrics lines: {len(lyrics.split(chr(10)))}")
+        print("[MusicLIME] Starting MusicLIME explanation...")
+        print(f"[MusicLIME] Modality: {modality}")
 
         # Create factorizations
         print("[MusicLIME] Creating audio factorization (source separation)...")
@@ -111,7 +125,7 @@ class MusicLIMEExplainer:
         # Generate perturbations and get predictions
         print(f"[MusicLIME] Generating {num_samples} perturbations...")
         data, predictions, distances = self._generate_neighborhood(
-            audio_factorization, text_factorization, predict_fn, num_samples
+            audio_factorization, text_factorization, predict_fn, num_samples, modality
         )
 
         # LIME fitting, create explanation object
@@ -140,33 +154,55 @@ class MusicLIMEExplainer:
 
         return explanation
 
-    def _generate_neighborhood(self, audio_fact, text_fact, predict_fn, num_samples):
+    def _generate_neighborhood(
+        self, audio_fact, text_fact, predict_fn, num_samples, modality="both"
+    ):
         """
-        Generate perturbed samples and predictions for LIME explanation.
+        Generate perturbed samples and predictions for LIME explanation based on modality.
+
+        Creates binary perturbation masks and generates corresponding perturbed audio-text
+        pairs. The perturbation strategy depends on the specified modality:
+        - 'both': Perturbs both audio components and lyrics lines independently
+        - 'audio': Perturbs only audio components, keeps original lyrics constant
+        - 'lyrical': Perturbs only lyrics lines, keeps original audio constant
 
         Parameters
         ----------
         audio_fact : OpenUnmixFactorization
-            Audio factorization object for source separation
+            Audio factorization object for source separation-based perturbations
         text_fact : LineIndexedString
-            Text factorization object for line-based perturbations
+            Text factorization object for line-based lyrics perturbations
         predict_fn : callable
-            Model prediction function
+            Model prediction function that processes (texts, audios) batches
         num_samples : int
-            Number of perturbations to generate
+            Number of perturbation samples to generate for LIME
+        modality : str, default='both'
+            Perturbation modality: 'both', 'audio', or 'lyrical'
 
         Returns
         -------
         data : ndarray
-            Binary perturbation masks (num_samples, total_features)
+            Binary perturbation masks of shape (num_samples, total_features)
         predictions : ndarray
-            Model predictions for perturbed instances
+            Model predictions for perturbed instances of shape (num_samples, n_classes)
         distances : ndarray
-            Cosine distances from original instance
+            Cosine distances from original instance of shape (num_samples,)
+
+        Notes
+        -----
+        The first sample (index 0) is always the original unperturbed instance.
+        Feature ordering: [audio_components, lyrics_lines] for 'both' modality.
         """
         n_audio = audio_fact.get_number_components()
         n_text = text_fact.num_words()
-        total_features = n_audio + n_text
+
+        # Set total features based on modality
+        if modality == "both":
+            total_features = n_audio + n_text
+        elif modality == "audio":
+            total_features = n_audio
+        elif modality == "lyrical":
+            total_features = n_text
 
         print(
             f"[MusicLIME] Total features: {total_features} ({n_audio} audio + {n_text} text)"
@@ -187,22 +223,46 @@ class MusicLIMEExplainer:
         texts = []
         audios = []
 
-        for i, row in enumerate(data):
-            # Progress check for every hundred samples
-            if i % 100 == 0:
-                print(f"[MusicLIME]     Progress: {i}/{num_samples} samples")
+        for _, row in enumerate(data):
+            if modality == "both":
+                # Audio perturbation & reconstruction
+                audio_mask = row[:n_audio]
+                active_audio_components = np.where(audio_mask != 0)[0]
+                perturbed_audio = audio_fact.compose_model_input(
+                    active_audio_components
+                )
+                audios.append(perturbed_audio)
+
+                # Text perturbation & reconstruction
+                text_mask = row[n_audio:]
+                inactive_lines = np.where(text_mask == 0)[0]
+                perturbed_text = text_fact.inverse_removing(inactive_lines)
+                texts.append(perturbed_text)
+
+            elif modality == "audio":
+                # Audio perturbation, original lyrics
+                active_audio_components = np.where(row != 0)[0]
+                perturbed_audio = audio_fact.compose_model_input(
+                    active_audio_components
+                )
+                audios.append(perturbed_audio)
+
+                # Use original lyrics (no perturbation)
+                perturbed_text = text_fact.inverse_removing(
+                    []
+                )  # Empty array = no removal
+                texts.append(perturbed_text)
 
-            # Audio perturbation & reconstruction
-            audio_mask = row[:n_audio]
-            active_audio_components = np.where(audio_mask != 0)[0]
-            perturbed_audio = audio_fact.compose_model_input(active_audio_components)
-            audios.append(perturbed_audio)
+            elif modality == "lyrical":
+                # Original audio, lyrics perturbation
+                all_audio_components = np.arange(n_audio)  # Use all audio components
+                perturbed_audio = audio_fact.compose_model_input(all_audio_components)
+                audios.append(perturbed_audio)
 
-            # Text perturbation & reconstruction
-            text_mask = row[n_audio:]
-            inactive_lines = np.where(text_mask == 0)[0]
-            perturbed_text = text_fact.inverse_removing(inactive_lines)
-            texts.append(perturbed_text)
+                # Perturb lyrics
+                inactive_lines = np.where(row == 0)[0]
+                perturbed_text = text_fact.inverse_removing(inactive_lines)
+                texts.append(perturbed_text)
 
         perturbation_time = time.time() - start_time
         print(
@@ -221,7 +281,7 @@ class MusicLIMEExplainer:
         confidence = original_prediction[predicted_class]
 
         # Print original prediction
-        print(f"[MusicLIME] Original Prediction:")
+        print("[MusicLIME] Original Prediction:")
         print(
             f"  Raw probabilities: [AI: {original_prediction[0]:.3f}, Human: {original_prediction[1]:.3f}]"
         )

src/musiclime/wrapper.py

@@ -3,7 +3,10 @@ import joblib
 import numpy as np
 import torch
 
-from src.preprocessing.preprocessor import single_preprocessing
+from src.preprocessing.preprocessor import (
+    single_preprocessing,
+    single_audio_preprocessing,
+)
 from src.spectttra.spectttra_trainer import spectttra_train
 from src.llm2vectrain.llm2vec_trainer import l2vec_train
 from src.llm2vectrain.model import load_llm2vec_model
@@ -159,7 +162,7 @@ class MusicLIMEPredictor:
             self.classifier = build_mlp(
                 input_dim=combined_features_batch.shape[1], config=self.config
             )
-            self.classifier.load_model("models/mlp/mlp_best.pth")
+            self.classifier.load_model("models/mlp/mlp_best_multimodal.pth")
 
         probabilities, predictions = self.classifier.predict(combined_features_batch)
 
@@ -172,7 +175,7 @@ class MusicLIMEPredictor:
         total_time = (
             preprocessing_time + audio_time + lyrics_time + scaling_time + mlp_time
         )
-        print(f"[MusicLIME] Batch processing complete!")
+        print("[MusicLIME] Batch processing complete!")
         print(
             green_bold(
                 f"[MusicLIME] Total time: {total_time:.2f}s (Preprocessing: {preprocessing_time:.2f}s, Audio: {audio_time:.2f}s, Lyrics: {lyrics_time:.2f}s, Scaling: {scaling_time:.2f}s, MLP: {mlp_time:.2f}s)"
@@ -180,3 +183,143 @@ class MusicLIMEPredictor:
         )
 
         return np.array(batch_results)
+
+
+class AudioOnlyPredictor:
+    """
+    Audio-only prediction wrapper for MusicLIME explanations.
+
+    Integrates the audio-only Bach or Bot pipeline (SpecTTTra + MLP) into a single
+    callable for LIME perturbation processing. Optimized for batch processing of
+    multiple perturbed audio samples while ignoring lyrics input. Mirrors the
+    multimodal MusicLIMEPredictor but processes only audio features.
+
+    This predictor is specifically designed for audio-only explainability where
+    lyrics are kept constant and only audio components are perturbed through
+    source separation techniques.
+
+    Attributes
+    ----------
+    classifier : MLPClassifier or None
+        Lazy-loaded MLP classifier for audio-only predictions
+    config : dict
+        Model configuration parameters loaded from config files
+    """
+
+    def __init__(self):
+        """
+        Initialize audio-only prediction wrapper.
+
+        Loads model configuration for batch processing of perturbed audio samples
+        during LIME explanation. The MLP classifier is lazy-loaded on first use
+        to optimize memory usage.
+        """
+        print("[MusicLIME] Loading models for Audio-Only MusicLIME...")
+        config = load_config("config/model_config.yml")
+        self.classifier = None
+        self.config = config
+
+    def __call__(self, texts, audios):
+        """
+        Batch prediction function for audio-only MusicLIME perturbations.
+
+        Processes multiple perturbed audio samples through the audio-only pipeline:
+        preprocessing -> SpecTTTra feature extraction -> scaling -> MLP prediction.
+        Text inputs are ignored as this is audio-only mode. Optimized for batch
+        processing of LIME perturbations with detailed timing analysis.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of text strings (ignored in audio-only mode, kept for API compatibility)
+        audios : list of array-like
+            List of perturbed audio waveforms from LIME perturbations
+
+        Returns
+        -------
+        ndarray
+            Prediction probabilities in format [[P(AI), P(Human)], ...]
+            for each input audio sample, shape (n_samples, 2)
+        """
+        print(
+            f"[MusicLIME] Processing {len(audios)} samples with batch functions (audio-only mode)..."
+        )
+
+        # Step 1: Preprocess all audio samples
+        start_time = time.time()
+        print("[MusicLIME] Preprocessing audio samples...")
+        processed_audios = []
+
+        for audio in audios:
+            processed_audio = single_audio_preprocessing(audio)
+            processed_audios.append(processed_audio)
+
+        preprocessing_time = time.time() - start_time
+        print(
+            green_bold(
+                f"[MusicLIME] Audio preprocessing completed in {preprocessing_time:.2f}s"
+            )
+        )
+
+        # Step 2: Batch audio feature extraction
+        start_time = time.time()
+        print("[MusicLIME] Extracting audio features (batch)...")
+        audio_features_batch = spectttra_train(processed_audios)
+
+        # Clear GPU cache after audio processing
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        audio_time = time.time() - start_time
+        print(
+            green_bold(
+                f"[MusicLIME] Audio feature extraction completed in {audio_time:.2f}s"
+            )
+        )
+
+        # Step 3: Scale audio features in batch
+        start_time = time.time()
+        print("[MusicLIME] Scaling audio features (batch)...")
+
+        # Load the audio scaler
+        audio_scaler = joblib.load("models/fusion/audio_scaler.pkl")
+        scaled_audio_batch = audio_scaler.transform(audio_features_batch)
+
+        scaling_time = time.time() - start_time
+        print(green_bold(f"[MusicLIME] Audio scaling completed in {scaling_time:.2f}s"))
+
+        # Step 4: Audio-only MLP prediction
+        start_time = time.time()
+        print("[MusicLIME] Running audio-only MLP predictions (batch)...")
+
+        if self.classifier is None:
+            self.classifier = build_mlp(
+                input_dim=scaled_audio_batch.shape[1], config=self.config
+            )
+            self.classifier.load_model("models/mlp/mlp_best_unimodal.pth")
+
+        probabilities, predictions = self.classifier.predict(scaled_audio_batch)
+
+        # Clear GPU cache after MLP processing
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        # Convert to expected format
+        batch_results = [[1 - prob, prob] for prob in probabilities]
+        mlp_time = time.time() - start_time
+        print(
+            green_bold(
+                f"[MusicLIME] Audio-only MLP prediction completed in {mlp_time:.2f}s"
+            )
+        )
+
+        # Total time summary
+        total_time = preprocessing_time + audio_time + scaling_time + mlp_time
+        print("[MusicLIME] Audio-only batch processing complete!")
+        print(
+            green_bold(
+                f"[MusicLIME] Total time: {total_time:.2f}s (Preprocessing: {preprocessing_time:.2f}s, Audio: {audio_time:.2f}s, Scaling: {scaling_time:.2f}s, MLP: {mlp_time:.2f}s)"
+            )
+        )
+
+        return np.array(batch_results)