Update model_utilis.py

model_utilis.py

@@ -2,54 +2,50 @@ import numpy as np
 import tensorflow as tf
 
 def load_model(model_path):
-    print(f"Loading model from {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)
+    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)
-    input_shape = model.input_shape[1:]
+    target_shape = model.input_shape[1:]
 
-    if len(input_shape) == 2:
-        target_T, target_D = input_shape
+    if len(target_shape) == 2:
+        target_T, target_D = target_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]}")
-
+            features = features.T
         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:
+                pad = np.zeros((target_T - cur_T, features.shape[1]))
+                features = np.vstack([features, pad])
+            else:
                 features = features[:target_T, :]
-
-    elif len(input_shape) == 1:
+    elif len(target_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]
+        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 model input shape: {input_shape}")
+        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.0 / (1.0 + np.exp(-val))
+        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.0, 1.0))
-    prob_real = 1.0 - prob_fake
+    prob_fake = float(np.clip(prob_fake, 0, 1))
+    prob_real = 1 - prob_fake
     return {"Fake": prob_fake, "Real": prob_real}