| 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 successfully.") |
| return model |
|
|
| def prepare_input_for_model(features, model): |
| """Resize and batch the features to match model input.""" |
| features = np.asarray(features, dtype=np.float32) |
| target_shape = model.input_shape[1:] |
|
|
| if len(target_shape) == 2: |
| target_T, target_D = target_shape |
| if target_D is not None and target_D != features.shape[1]: |
| features = features.T |
| if target_T is not None: |
| cur_T = features.shape[0] |
| if cur_T < target_T: |
| pad = np.zeros((target_T - cur_T, features.shape[1])) |
| features = np.vstack([features, pad]) |
| else: |
| features = features[:target_T, :] |
| elif len(target_shape) == 1: |
| 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])) |
| else: |
| flat = flat[:target_len] |
| features = flat |
| else: |
| raise ValueError(f"Unsupported input shape {target_shape}") |
|
|
| return np.expand_dims(features, axis=0) |
|
|
| def interpret_prediction(raw_pred): |
| """Turn model output into readable Real/Fake probabilities.""" |
| raw = np.asarray(raw_pred).squeeze() |
| if raw.size == 1: |
| val = float(raw) |
| prob_fake = val if 0.0 <= val <= 1.0 else 1 / (1 + 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, 1)) |
| prob_real = 1 - prob_fake |
| return {"Fake": prob_fake, "Real": prob_real} |
|
|
