Auto-deploy from GitHub: f3f5c5a060663701fed0a46fe5870df177796716

scripts/explain.py

@@ -26,12 +26,6 @@ def musiclime(audio_data, lyrics_text):
     explainer = MusicLIMEExplainer()
     predictor = MusicLIMEPredictor()
 
-    # Truncate raw audio to 2 minutes before any processing
-    target_samples = int(2 * 60 * 22050)
-    if len(audio_data) > target_samples:
-        # Keep first 2 minutes
-        audio_data = audio_data[:target_samples]
-
     # Then generate explanations
     explanation = explainer.explain_instance(
         audio=audio_data,

scripts/explain_runner.py

@@ -0,0 +1,30 @@
+import librosa
+from scripts.explain import musiclime
+
+# 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)
+
+# Load lyrics
+with open(lyrics_path, "r", encoding="utf-8") as f:
+    lyrics_text = f.read()
+
+print("Running MusicLIME explanation...")
+result = musiclime(audio_data, lyrics_text)
+
+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("\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()

scripts/predict.py

@@ -37,13 +37,9 @@ def predict_pipeline(audio_file, lyrics):
     # 2.) Preprocess both audio and lyrics
     audio, lyrics = single_preprocessing(audio_file, lyrics)
 
-    # Truncate to 2 minutes to match explain pipeline
-    target_samples = int(2 * 60 * 22050)
-    if len(audio) > target_samples:
-        audio = audio[:target_samples]
-
     # 3.) Call the train method for both models
     audio_features = spectttra_predict(audio)
+    audio_features = audio_features.reshape(1, -1)
     lyrics_features = l2vec_single_train(llm2vec_model, lyrics)
 
     # 4.) Scale the vectors using Z-Score
@@ -52,10 +48,6 @@ def predict_pipeline(audio_file, lyrics):
     # 5.) Reduce the lyrics using saved PCA model
     reduced_lyrics = load_pca_model(lyrics_features)
 
-    # 6.) Apply PCA scaler to PCA-reduced lyrics
-    pca_scaler = joblib.load("models/fusion/pca_scaler.pkl")
-    reduced_lyrics = pca_scaler.transform(reduced_lyrics)
-
     # 6.) Concatenate the vectors of audio_features + lyrics_features
     results = np.concatenate([audio_features, reduced_lyrics], axis=1)
 

scripts/predict_runner.py

@@ -0,0 +1,19 @@
+import librosa
+from scripts.predict import predict_pipeline
+
+# 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)
+
+# Load lyrics
+with open(lyrics_path, "r", encoding="utf-8") as f:
+    lyrics_text = f.read()
+
+print("Running prediction pipeline...")
+prediction = predict_pipeline(audio_data, lyrics_text)
+
+print(f"\n=== PREDICTION RESULT ===")
+print(f"Prediction: {prediction}")

src/models/mlp.py

@@ -438,13 +438,11 @@ class MLPClassifier:
 
         probabilities = np.array(probabilities).flatten()
         # Threshold at 0.5
-        predictions = (probabilities > 0.5).astype(int)
+        predictions = (probabilities >= 0.5).astype(int)
 
         return probabilities, predictions
 
-    def predict_single(
-        self, features: np.ndarray, temperature: float = 2.5
-    ) -> Tuple[float, int, str]:
+    def predict_single(self, features: np.ndarray) -> Tuple[float, int, str]:
         """
         Predict whether a single song is AI-generated or human-composed.
 
@@ -488,17 +486,17 @@ class MLPClassifier:
         self.model.eval()
         with torch.no_grad():
             features_tensor = torch.FloatTensor(features).to(self.device)
-            outputs = self.model(features_tensor)
-            probabilities = outputs.item()  # Just use raw output
+            probability = self.model(features_tensor).item()
+
+        probability = np.clip(probability, 0.0, 1.0)
 
         # Extract single results
-        prediction = int(probabilities >= 0.5)
+        prediction = int(probability >= 0.5)
         label = "Human-Composed" if prediction == 1 else "AI-Generated"
-        probability = (
-            probabilities * 100 if prediction == 1 else (1 - probabilities) * 100
-        )
 
-        return probability, prediction, label
+        confidence = probability * 100 if prediction == 1 else (1 - probability) * 100
+
+        return confidence, prediction, label
 
     def predict_batch(self, features: np.ndarray, return_details: bool = False) -> Dict:
         """

src/musiclime/explainer.py

@@ -84,7 +84,7 @@ class MusicLIMEExplainer:
         # These are for debugging only I have to see THAT progress
         print("[MusicLIME] Starting MusicLIME explanation...")
         print(
-            f"[MusicLIME] Audio length: {len(audio)/44100:.1f}s, Temporal segments: {temporal_segments}"
+            f"[MusicLIME] Audio length: {len(audio)/22050:.1f}s, Temporal segments: {temporal_segments}"
         )
         print(f"[MusicLIME] Lyrics lines: {len(lyrics.split(chr(10)))}")
 
@@ -214,7 +214,6 @@ class MusicLIMEExplainer:
         # Get predictions
         print(f"[MusicLIME] Getting predictions for {len(texts)} samples...")
         predictions = predict_fn(texts, audios)
-        prediction_time = time.time() - start_time
 
         # Show the original prediction (first row is always the unperturbed original)
         original_prediction = predictions[0]

src/musiclime/wrapper.py

@@ -71,7 +71,7 @@ class MusicLIMEPredictor:
         processed_audios = []
         processed_lyrics = []
 
-        for i, (text, audio) in enumerate(zip(texts, audios)):
+        for _, (text, audio) in enumerate(zip(texts, audios)):
             processed_audio, processed_lyric = single_preprocessing(audio, text)
             processed_audios.append(processed_audio)
             processed_lyrics.append(processed_lyric)
@@ -127,21 +127,14 @@ class MusicLIMEPredictor:
         pca_model = joblib.load("models/fusion/pca.pkl")
         reduced_lyrics_batch = pca_model.transform(scaled_lyrics_batch)  # (batch, 512)
 
-        # Step 5: Apply scaler to PCA-scaled lyrics batch
-        print("[MusicLIME] Reapplying scaler to PCA-scaled batch")
-        pca_scaler = joblib.load("models/fusion/pca_scaler.pkl")
-        reduced_lyrics_batch = pca_scaler.transform(
-            reduced_lyrics_batch
-        )  # (batch, 512)
-
-        # Step 6: Concatenate features
+        # Step 5: Concatenate features
         combined_features_batch = np.concatenate(
             [scaled_audio_batch, reduced_lyrics_batch], axis=1
         )  # (batch, sum of lyrics & audio vector dims)
         scaling_time = time.time() - start_time
         print(green_bold(f"[MusicLIME] Scaling completed in {scaling_time:.2f}s"))
 
-        # Step 7: Batch MLP prediction
+        # Step 6: Batch MLP prediction
         start_time = time.time()
         print("[MusicLIME] Running MLP predictions (batch)...")
         if self.classifier is None:

src/utils/dataset.py

@@ -9,7 +9,9 @@ import numpy as np
 import logging
 import pandas as pd
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 
@@ -51,18 +53,20 @@ def dataset_splitter(X: np.ndarray, Y: np.ndarray, ids: np.ndarray = None):
         X_train, y_train, test_size=0.2222, random_state=42, stratify=y_train
     )
 
-    logger.info(f"Train: {X_train.shape}, Validation: {X_val.shape}, Test: {X_test.shape}")
+    logger.info(
+        f"Train: {X_train.shape}, Validation: {X_val.shape}, Test: {X_test.shape}"
+    )
 
     data = {
         "train": (X_train, y_train),
-        "val":   (X_val, y_val),
-        "test":  (X_test, y_test),
+        "val": (X_val, y_val),
+        "test": (X_test, y_test),
     }
 
     return data
 
 
-def scale_pca(data : dict):
+def scale_pca(data: dict):
     """
     Script that scales the splits, and applies PCA to the lyrics vector.
 
@@ -79,8 +83,8 @@ def scale_pca(data : dict):
 
     # Destructure the dictionary to get data split
     X_train, y_train = data["train"]
-    X_val, y_val     = data["val"]
-    X_test, y_test   = data["test"]
+    X_val, y_val = data["val"]
+    X_test, y_test = data["test"]
 
     # Segment the concatenated embedding to audio and lyrics
     X_train_audio, X_train_lyrics = X_train[:, :384], X_train[:, 384:]
@@ -104,7 +108,7 @@ def scale_pca(data : dict):
     batch_size = 1000
 
     for i in range(0, X_train_lyrics.shape[0], batch_size):
-        ipca.partial_fit(X_train_lyrics[i:i + batch_size])
+        ipca.partial_fit(X_train_lyrics[i : i + batch_size])
 
     # Transform in batches
     X_train_lyrics = ipca.transform(X_train_lyrics)
@@ -136,7 +140,7 @@ def scale_pca(data : dict):
     return data
 
 
-def scale_pca_lyrics(data : dict):
+def scale_pca_lyrics(data: dict):
     """
     Script that scales the splits, and applies PCA to the lyrics vector.
 
@@ -153,8 +157,8 @@ def scale_pca_lyrics(data : dict):
 
     # Destructure the dictionary to get data split
     X_train, y_train = data["train"]
-    X_val, y_val     = data["val"]
-    X_test, y_test   = data["test"]
+    X_val, y_val = data["val"]
+    X_test, y_test = data["test"]
 
     lyric_scaler = StandardScaler().fit(X_train)
     joblib.dump(lyric_scaler, LYRICS_SCALER)
@@ -168,7 +172,7 @@ def scale_pca_lyrics(data : dict):
     batch_size = 1000
 
     for i in range(0, X_train.shape[0], batch_size):
-        ipca.partial_fit(X_train[i:i + batch_size])
+        ipca.partial_fit(X_train[i : i + batch_size])
 
     # Transform in batches
     X_train = ipca.transform(X_train)
@@ -186,7 +190,7 @@ def scale_pca_lyrics(data : dict):
     return data
 
 
-def scale(data : dict):
+def scale(data: dict):
     """
     Script that scales the splits, and applies PCA to the lyrics vector.
 
@@ -203,8 +207,8 @@ def scale(data : dict):
 
     # Destructure the dictionary to get data split
     X_train, y_train = data["train"]
-    X_val, y_val     = data["val"]
-    X_test, y_test   = data["test"]
+    X_val, y_val = data["val"]
+    X_test, y_test = data["test"]
 
     audio_scaler = StandardScaler(with_mean=False).fit(X_train)
     joblib.dump(audio_scaler, AUDIO_SCALER)
@@ -222,6 +226,7 @@ def scale(data : dict):
 
     return data
 
+
 def dataset_scaler(audio: np.ndarray, lyrics: np.ndarray):
     """
     Method to scale both audio and lyric vectors using Z-Score.
@@ -279,7 +284,7 @@ def instance_scaler(audio: np.ndarray, lyrics: np.ndarray):
     audio_scaler = joblib.load(AUDIO_SCALER)
     lyric_scaler = joblib.load(LYRICS_SCALER)
 
-    scaled_audio = audio_scaler.transform([audio])
+    scaled_audio = audio_scaler.transform(audio)
     scaled_lyric = lyric_scaler.transform(lyrics)
 
-    return scaled_audio, scaled_lyric
+    return scaled_audio, scaled_lyric