Rename app.py to model_utilis.py

app.py

@@ -1,199 +0,0 @@
-import os
-import numpy as np
-import tensorflow as tf
-import librosa
-import gradio as gr
-
-# -----------------------
-
-# Config
-
-# -----------------------
-
-MODEL_PATH = "your_model.keras"   # <-- replace if your model filename differs
-SR = 16000
-N_COEFFS = 20
-
-# -----------------------
-
-# Feature extraction (adapted from your code)
-
-# -----------------------
-
-def extract_mfcc(y, sr, n_mfcc=N_COEFFS):
-mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc)
-return mfccs
-
-def extract_lfcc(y, sr, n_lfcc=N_COEFFS):
-S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_lfcc, fmin=0, fmax=sr/2)
-lfccs = librosa.power_to_db(S)
-return lfccs
-
-def extract_features_with_time_series(file_path, sr=SR, n_coeffs=N_COEFFS):
-try:
-y, _ = librosa.load(file_path, sr=sr, mono=True)
-y, _ = librosa.effects.trim(y)
-
-```
-    # Normalize amplitude
-    if np.max(np.abs(y)) > 0:
-        y = y / np.max(np.abs(y))
-
-    # Extract features
-    mfccs = extract_mfcc(y, sr, n_mfcc=n_coeffs)
-    lfccs = extract_lfcc(y, sr, n_lfcc=n_coeffs)
-    chroma = librosa.feature.chroma_stft(y=y, sr=sr)
-    spec_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
-    spec_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)
-    zcr = librosa.feature.zero_crossing_rate(y)
-
-    features_to_stack = [mfccs, lfccs, chroma, spec_centroid, spec_bandwidth, zcr]
-
-    # Pad/truncate along time axis (axis=1 for these matrices)
-    max_len = max([f.shape[1] for f in features_to_stack])
-    padded_features = []
-    for f in features_to_stack:
-        # librosa.util.fix_length works on axis=-1 by default; specify axis=1 for time axis
-        padded = librosa.util.fix_length(f, size=max_len, axis=1)
-        padded_features.append(padded)
-
-    stacked_features = np.vstack(padded_features).astype(np.float32)  # shape: (feature_dim, time)
-    # transpose to (time, feature_dim)
-    return stacked_features.T
-
-except Exception as e:
-    print(f"[extract_features] Error processing {file_path}: {e}")
-    return None
-```
-
-# -----------------------
-
-# Load model
-
-# -----------------------
-
-print(f"Loading model from {MODEL_PATH} ...")
-model = tf.keras.models.load_model(MODEL_PATH)
-print("Model loaded. input_shape =", model.input_shape)
-
-# Helper to prepare features for model input
-
-def prepare_input_for_model(features, model):
-"""
-features: np.array of shape (time, feature_dim)
-model: loaded keras model
-Returns: np.array shaped as model expects, with batch dim
-"""
-features = np.asarray(features, dtype=np.float32)
-input_shape = model.input_shape  # e.g. (None, T, D) or (None, some_flat_len)
-
-```
-# Remove batch dim
-target_shape = input_shape[1:]
-
-if len(target_shape) == 2:
-    # model expects (timesteps, dim)
-    target_T, target_D = target_shape
-    # If the feature dim does not match, try transpose
-    if target_D is not None and target_D != features.shape[1]:
-        if target_D == features.shape[0]:
-            features = features.T
-        else:
-            raise ValueError(f"Model expects feature dim {target_D} but got {features.shape[1]}")
-
-    # Pad/truncate time axis if target_T is specified
-    if target_T is not None:
-        cur_T = features.shape[0]
-        if cur_T < target_T:
-            pad_amount = target_T - cur_T
-            pad_width = ((0, pad_amount), (0, 0))
-            features = np.pad(features, pad_width, mode="constant")
-        elif cur_T > target_T:
-            features = features[:target_T, :]
-
-elif len(target_shape) == 1:
-    # model expects 1D input, flatten features
-    flat = features.flatten()
-    target_len = target_shape[0]
-    if target_len is not None:
-        if flat.shape[0] < target_len:
-            flat = np.pad(flat, (0, target_len - flat.shape[0]), mode="constant")
-        else:
-            flat = flat[:target_len]
-    features = flat
-
-else:
-    raise ValueError(f"Unsupported model input shape: {input_shape}")
-
-# Add batch dimension
-return np.expand_dims(features, axis=0)
-```
-
-# -----------------------
-
-# Prediction function for Gradio
-
-# -----------------------
-
-def predict(audio_filepath):
-"""audio_filepath: path to uploaded audio (Gradio provides this when type='filepath')"""
-try:
-if audio_filepath is None:
-return {"error": "No audio file provided."}
-
-```
-    feats = extract_features_with_time_series(audio_filepath)
-    if feats is None:
-        return {"error": "Feature extraction failed."}
-
-    X = prepare_input_for_model(feats, model)
-    raw_pred = model.predict(X)
-
-    # Interpret raw_pred to a probability for the 'Fake' class
-    raw = np.asarray(raw_pred).squeeze()
-    # If single value per sample
-    if raw.size == 1:
-        val = float(raw)
-        # If value already in [0,1], assume probability; otherwise pass through sigmoid
-        if 0.0 <= val <= 1.0:
-            prob_fake = val
-        else:
-            prob_fake = 1.0 / (1.0 + np.exp(-val))
-    else:
-        # multi-class: assume class index 1 == Fake if present
-        import tensorflow as _tf
-        probs = _tf.nn.softmax(raw).numpy()
-        if probs.size >= 2:
-            prob_fake = float(probs[1])
-        else:
-            prob_fake = float(probs.max())
-
-    prob_fake = float(np.clip(prob_fake, 0.0, 1.0))
-    prob_real = 1.0 - prob_fake
-    label = "Fake" if prob_fake > 0.5 else "Real"
-
-    # Return mapping suitable for gr.Label: {"Fake": prob, "Real": prob}
-    return {"Fake": prob_fake, "Real": prob_real}
-except Exception as e:
-    return {"error": f"Prediction error: {e}"}
-```
-
-# -----------------------
-
-# Gradio UI
-
-# -----------------------
-
-title = "Deepfake Audio Detector"
-description = "Upload an audio file (wav/mp3). The app runs the embedded preprocessing to extract MFCC/LFCC/etc., then runs your .keras model. The Space expects the model file named 'your_model.keras' in the repo root."
-
-iface = gr.Interface(
-fn=predict,
-inputs=gr.Audio(source="upload", type="filepath", label="Upload audio file"),
-outputs=gr.Label(num_top_classes=2, label="Prediction (probabilities)"),
-title=title,
-description=description,
-)
-
-if **name** == "**main**":
-iface.launch()

model_utilis.py

@@ -0,0 +1,59 @@
+import numpy as np
+import tensorflow as tf
+
+def load_model(model_path):
+print(f"Loading model from {model_path} ...")
+model = tf.keras.models.load_model(model_path)
+print("Model loaded. Input shape =", model.input_shape)
+return model
+
+def prepare_input_for_model(features, model):
+features = np.asarray(features, dtype=np.float32)
+input_shape = model.input_shape[1:]
+
+```
+if len(input_shape) == 2:
+    target_T, target_D = input_shape
+    if target_D is not None and target_D != features.shape[1]:
+        if target_D == features.shape[0]:
+            features = features.T
+        else:
+            raise ValueError(f"Model expects feature dim {target_D}, got {features.shape[1]}")
+
+    if target_T is not None:
+        cur_T = features.shape[0]
+        if cur_T < target_T:
+            pad = target_T - cur_T
+            features = np.pad(features, ((0, pad), (0, 0)), mode="constant")
+        elif cur_T > target_T:
+            features = features[:target_T, :]
+
+elif len(input_shape) == 1:
+    flat = features.flatten()
+    target_len = input_shape[0]
+    if flat.shape[0] < target_len:
+        flat = np.pad(flat, (0, target_len - flat.shape[0]), mode="constant")
+    else:
+        flat = flat[:target_len]
+    features = flat
+
+else:
+    raise ValueError(f"Unsupported model input shape: {input_shape}")
+
+return np.expand_dims(features, axis=0)
+```
+
+def interpret_prediction(raw_pred):
+raw = np.asarray(raw_pred).squeeze()
+if raw.size == 1:
+val = float(raw)
+prob_fake = val if 0.0 <= val <= 1.0 else 1.0 / (1.0 + np.exp(-val))
+else:
+probs = tf.nn.softmax(raw).numpy()
+prob_fake = float(probs[1]) if probs.size >= 2 else float(probs.max())
+
+```
+prob_fake = float(np.clip(prob_fake, 0.0, 1.0))
+prob_real = 1.0 - prob_fake
+return {"Fake": prob_fake, "Real": prob_real}
+```