Create app.py

app.py

@@ -0,0 +1,199 @@
+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()