update: Add de logs

app.py

@@ -1,14 +1,23 @@
 import sys
 import os
+import logging
+
+logging.info("[app.py] starting...")
 
 ROOT = os.path.dirname(__file__)
 SRC = os.path.join(ROOT, "src")
+logging.info(f"[app.py] ROOT={ROOT}")
+logging.info(f"[app.py] SRC={SRC}")
+
 if SRC not in sys.path:
     sys.path.insert(0, SRC)
 
+logging.info("[app.py] importing main...")
 from main import demo
+logging.info("[app.py] imported main successfully")
 
 if __name__ == "__main__":
+    logging.info("[app.py] launching gradio...")
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", 7860)),

src/models/inference.py

@@ -1,16 +1,21 @@
-import torch
-import numpy as np
-import matplotlib.pyplot as plt
 import os
+import logging
 from glob import glob
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
 from models.preprocessing import process_image_pil, process_metadata_pad20
 from models.model_loader import load_model, find_last_conv
 from models.cam import GradCAMPlusPlus
 
+logging.basicConfig(level=logging.INFO)
+
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
 
-CLASS_LIST = ["NEV","BCC","ACK","SEK","SCC","MEL"]
+CLASS_LIST = ["NEV", "BCC", "ACK", "SEK", "SCC", "MEL"]
 
 ENCODER_DIR = os.path.join(PROJECT_ROOT, "data", "preprocess_data")
 MODEL_ROOT_PATTERNS = [
@@ -35,6 +40,7 @@ MODEL_ROOT_PATTERNS = [
         "model_*_with_one-hot-encoder_512_with_best_architecture",
     ),
 ]
+
 PREFERRED_FOLD = 3
 IMPLEMENTED_ATTENTION_MECHANISMS = {
     "no-metadata",
@@ -56,9 +62,31 @@ MODEL_CONFIGS = {}
 MODEL_LABELS = {}
 MODEL_CACHE = {}
 DEFAULT_MODEL_KEY = None
+_DISCOVERED = False
+
+
+def _debug_paths() -> None:
+    print(f"[inference] DEVICE={DEVICE}")
+    print(f"[inference] PROJECT_ROOT={PROJECT_ROOT}")
+    print(f"[inference] ENCODER_DIR={ENCODER_DIR}")
+    print(f"[inference] ENCODER_DIR exists? {os.path.exists(ENCODER_DIR)}")
 
+    data_root = os.path.join(PROJECT_ROOT, "data")
+    weights_root = os.path.join(data_root, "weights")
+    to_be_used_root = os.path.join(weights_root, "TO_BE_USED")
 
-def _parse_cnn_model_name(model_dir_name):
+    print(f"[inference] data root={data_root}")
+    print(f"[inference] data root exists? {os.path.exists(data_root)}")
+    print(f"[inference] weights root={weights_root}")
+    print(f"[inference] weights root exists? {os.path.exists(weights_root)}")
+    print(f"[inference] TO_BE_USED root={to_be_used_root}")
+    print(f"[inference] TO_BE_USED root exists? {os.path.exists(to_be_used_root)}")
+
+    for pattern in MODEL_ROOT_PATTERNS:
+        print(f"[inference] MODEL_ROOT_PATTERN={pattern}")
+
+
+def _parse_cnn_model_name(model_dir_name: str):
     prefix = "model_"
     suffix = "_with_one-hot-encoder_512_with_best_architecture"
     if not model_dir_name.startswith(prefix) or not model_dir_name.endswith(suffix):
@@ -66,7 +94,7 @@ def _parse_cnn_model_name(model_dir_name):
     return model_dir_name[len(prefix):-len(suffix)]
 
 
-def _find_fold_dir(model_root, cnn_model_name):
+def _find_fold_dir(model_root: str, cnn_model_name: str):
     fold_dirs = sorted(glob(os.path.join(model_root, f"{cnn_model_name}_fold_*")))
     if not fold_dirs:
         return None
@@ -82,12 +110,12 @@ def _find_fold_dir(model_root, cnn_model_name):
     return None
 
 
-def _extract_fold_number(fold_dir):
+def _extract_fold_number(fold_dir: str) -> str:
     name = os.path.basename(fold_dir)
     return name.split("_fold_")[-1] if "_fold_" in name else "?"
 
 
-def _extract_path_metadata(model_root):
+def _extract_path_metadata(model_root: str):
     parts = os.path.normpath(model_root).split(os.sep)
     mechanism = os.path.basename(os.path.dirname(model_root))
     unfreeze_weights = "unfrozen_weights"
@@ -105,25 +133,45 @@ def _extract_path_metadata(model_root):
     return mechanism, unfreeze_weights, num_heads
 
 
-def _discover_models():
+def _discover_models() -> None:
     global DEFAULT_MODEL_KEY
+
+    print("[inference] starting model discovery...")
+    MODEL_CONFIGS.clear()
+    MODEL_LABELS.clear()
+    DEFAULT_MODEL_KEY = None
+
     model_roots = sorted({
         path
         for pattern in MODEL_ROOT_PATTERNS
         for path in glob(pattern)
     })
+
+    print(f"[inference] candidate model roots found: {len(model_roots)}")
+    for idx, path in enumerate(model_roots[:20], start=1):
+        print(f"[inference] candidate[{idx}] = {path}")
+    if len(model_roots) > 20:
+        print("[inference] ... additional candidates omitted from log ...")
+
     for model_root in model_roots:
         mechanism, unfreeze_weights, num_heads = _extract_path_metadata(model_root)
         model_dir_name = os.path.basename(model_root)
         cnn_model_name = _parse_cnn_model_name(model_dir_name)
+
         if cnn_model_name is None:
+            print(f"[inference] skipping invalid model dir name: {model_dir_name}")
             continue
 
         fold_dir = _find_fold_dir(model_root, cnn_model_name)
         if fold_dir is None:
+            print(f"[inference] no valid fold dir found for: {model_root}")
             continue
 
         model_path = os.path.join(fold_dir, "model.pth")
+        if not os.path.exists(model_path):
+            print(f"[inference] missing model.pth: {model_path}")
+            continue
+
         fold_number = _extract_fold_number(fold_dir)
         model_key = f"{mechanism}|{cnn_model_name}|{unfreeze_weights}|{num_heads}|{fold_number}"
         supported = mechanism in IMPLEMENTED_ATTENTION_MECHANISMS
@@ -140,6 +188,7 @@ def _discover_models():
             "label": label,
         }
         MODEL_LABELS[model_key] = label
+        print(f"[inference] registered model: {label}")
 
     preferred_defaults = [
         key for key, cfg in MODEL_CONFIGS.items()
@@ -154,27 +203,49 @@ def _discover_models():
     elif MODEL_CONFIGS:
         DEFAULT_MODEL_KEY = sorted(MODEL_CONFIGS.keys())[0]
 
+    print(f"[inference] discovery done. models={len(MODEL_CONFIGS)}")
+    print(f"[inference] DEFAULT_MODEL_KEY={DEFAULT_MODEL_KEY}")
+
+
+def ensure_models_discovered() -> None:
+    global _DISCOVERED
+    if _DISCOVERED:
+        return
 
-_discover_models()
+    _debug_paths()
+    _discover_models()
+    _DISCOVERED = True
 
 
 def get_available_model_choices():
+    ensure_models_discovered()
     return [(MODEL_LABELS[key], key) for key in sorted(MODEL_LABELS.keys())]
 
 
 def get_default_model_key():
+    ensure_models_discovered()
     return DEFAULT_MODEL_KEY
 
 
 def get_model_label(model_key):
+    ensure_models_discovered()
     return MODEL_LABELS.get(model_key, "Unknown model")
 
 
 def _get_model_and_cam(model_key):
+    ensure_models_discovered()
+
     if not MODEL_CONFIGS:
         raise RuntimeError(
-            f"No compatible model checkpoints were found in {os.path.join(PROJECT_ROOT, 'data', 'weights')}. "
-            "Please check that model assets are available."
+            f"No compatible model checkpoints were found in "
+            f"{os.path.join(PROJECT_ROOT, 'data', 'weights')}. "
+            f"Please verify that the model assets were uploaded to the Space."
+        )
+
+    if not os.path.exists(ENCODER_DIR):
+        raise RuntimeError(
+            f"Metadata encoder directory not found: {ENCODER_DIR}. "
+            "Please verify that preprocess artifacts were uploaded to the Space."
         )
 
     if model_key is None:
@@ -195,7 +266,8 @@ def _get_model_and_cam(model_key):
 
     if model_key not in MODEL_CACHE:
         model_path = cfg["model_path"]
-        print(f"Loading model from {model_path}...")
+        print(f"[inference] loading model from: {model_path}")
+
         model = load_model(
             device=DEVICE,
             model_path=model_path,
@@ -204,9 +276,13 @@ def _get_model_and_cam(model_key):
             num_heads=cfg["num_heads"],
             unfreeze_weights=cfg["unfreeze_weights"],
         )
+
+        print("[inference] locating final conv layer...")
         target_layer = find_last_conv(model.image_encoder)
+
+        print("[inference] creating GradCAM++ object...")
         MODEL_CACHE[model_key] = (model, GradCAMPlusPlus(model, target_layer))
-        print("Model ready.")
+        print("[inference] model ready.")
 
     return MODEL_CACHE[model_key]
 
@@ -214,14 +290,17 @@ def _get_model_and_cam(model_key):
 def run_inference(image_pil, metadata_text, model_key=None):
     model, cam = _get_model_and_cam(model_key)
 
+    print("[inference] processing image...")
     image_tensor = process_image_pil(image_pil, DEVICE)
 
+    print("[inference] processing metadata...")
     metadata_tensor = process_metadata_pad20(
         metadata_text,
         ENCODER_DIR,
         DEVICE
     )
 
+    print("[inference] running forward pass...")
     with torch.no_grad():
         logits = model(image_tensor, metadata_tensor)
         probs = torch.softmax(logits, dim=1)
@@ -229,13 +308,14 @@ def run_inference(image_pil, metadata_text, model_key=None):
     pred_class = torch.argmax(probs, dim=1).item()
     confidence = probs[0, pred_class].item()
 
+    print("[inference] generating heatmap...")
     heatmap = cam.generate(
         image_tensor,
         metadata_tensor,
         pred_class
     )
 
-    fig, ax = plt.subplots(figsize=(6,6))
+    fig, ax = plt.subplots(figsize=(6, 6))
     ax.imshow(image_pil)
     ax.imshow(heatmap, cmap="jet", alpha=0.4)
     ax.axis("off")
@@ -247,4 +327,5 @@ def run_inference(image_pil, metadata_text, model_key=None):
     result = np.array(fig.canvas.renderer.buffer_rgba())
     plt.close(fig)
 
-    return result, title
+    print(f"[inference] inference complete: {title}")
+    return result, title