Use original online structural extractors

submission_task1.py

@@ -216,28 +216,82 @@ def load_model():
 
 
 def _pil_to_tensor(image: Image.Image) -> torch.Tensor:
-    image = image.convert("RGB").resize(DEFAULT_IMAGE_SIZE, Image.BILINEAR)
-    arr = np.asarray(image).astype(np.float32) / 255.0
+    import cv2
+
+    image_rgb = np.asarray(image.convert("RGB")).astype(np.uint8)
+    image_rgb = cv2.resize(image_rgb, DEFAULT_IMAGE_SIZE[::-1], interpolation=cv2.INTER_AREA)
+    arr = image_rgb.astype(np.float32) / 255.0
     arr = np.transpose(arr, (2, 0, 1))
     return torch.from_numpy(arr).float().unsqueeze(0)
 
 
-def _default_structural_tensors(batch_size: int = 1) -> Dict[str, torch.Tensor]:
-    """Fallback structural tensors for hidden validation without manifests.
+_STRUCTURAL_EXTRACTORS = None
+
+
+def _get_structural_extractors():
+    """Create the same structural extractors used by offline precompute."""
+
+    global _STRUCTURAL_EXTRACTORS
+    if _STRUCTURAL_EXTRACTORS is not None:
+        return _STRUCTURAL_EXTRACTORS
+
+    from src.topology.lesion_prior import LesionPriorExtractor
+    from src.topology.tda_morphology import TopologicalExtractor as MorphologyTopologicalExtractor
+
+    prior_extractor = LesionPriorExtractor(
+        image_size=DEFAULT_IMAGE_SIZE,
+        grid_size=DEFAULT_GRID_SIZE,
+        use_morphology=False,
+    )
+    morpho_extractor = MorphologyTopologicalExtractor(
+        grid_size=DEFAULT_GRID_SIZE,
+        image_size=DEFAULT_IMAGE_SIZE,
+    )
+    _STRUCTURAL_EXTRACTORS = (prior_extractor, morpho_extractor)
+    return _STRUCTURAL_EXTRACTORS
+
+
+def _extract_online_structural_tensors(image: Image.Image) -> Dict[str, torch.Tensor]:
+    """Compute structural features online with the original precompute logic.
+
+    This mirrors `scripts/precompute_structural_features.py`:
+      prior_output = LesionPriorExtractor.extract_prior(image_bgr)
+      morpho_output = MorphologyTopologicalExtractor.extract_features(image_bgr)
 
-    The trained model expects prior/topological features. Official validation is
-    likely image+question only, so this fallback keeps inference runnable. If a
-    lightweight structural feature extractor is later added to the repo, replace
-    this function with real per-image features.
+    Shapes:
+      - prior_mask: [1, 14, 14]
+      - topo_features: [1, 14, 14, 12]
+      - global_features: [1, 8]
     """
 
-    grid_h, grid_w = DEFAULT_GRID_SIZE
-    prior = torch.ones(batch_size, 1, grid_h, grid_w, dtype=torch.float32)
-    prior = prior / prior.flatten(1).sum(dim=1).view(batch_size, 1, 1, 1).clamp_min(1e-6)
+    import cv2
+
+    prior_extractor, morpho_extractor = _get_structural_extractors()
+
+    image_rgb = np.asarray(image.convert("RGB")).astype(np.uint8)
+    image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+
+    prior_output = prior_extractor.extract_prior(image_bgr)
+    morpho_output = morpho_extractor.extract_features(image_bgr)
+
+    prior_mask = prior_output["prior_mask"].astype(np.float32)
+    topo_features = morpho_output["topo_features"].astype(np.float32)
+    global_features = morpho_output["global_features"].astype(np.float32)
+
+    if prior_mask.shape != DEFAULT_GRID_SIZE:
+        raise ValueError(f"prior_mask shape {prior_mask.shape} != {DEFAULT_GRID_SIZE}")
+    expected_topo_shape = (*DEFAULT_GRID_SIZE, DEFAULT_TOPO_FEATURE_DIM)
+    if topo_features.shape != expected_topo_shape:
+        raise ValueError(f"topo_features shape {topo_features.shape} != {expected_topo_shape}")
+    if global_features.shape != (DEFAULT_GLOBAL_FEATURE_DIM,):
+        raise ValueError(
+            f"global_features shape {global_features.shape} != {(DEFAULT_GLOBAL_FEATURE_DIM,)}"
+        )
+
     return {
-        "prior_mask": prior,
-        "topo_features": torch.zeros(batch_size, DEFAULT_TOPO_FEATURE_DIM, dtype=torch.float32),
-        "global_features": torch.zeros(batch_size, DEFAULT_GLOBAL_FEATURE_DIM, dtype=torch.float32),
+        "prior_mask": torch.from_numpy(prior_mask).float().unsqueeze(0),
+        "topo_features": torch.from_numpy(topo_features).float().unsqueeze(0),
+        "global_features": torch.from_numpy(global_features).float().unsqueeze(0),
     }
 
 
@@ -245,7 +299,7 @@ def predict_one(image: Image.Image, question: str, max_new_tokens: int = 48) ->
     model = load_model()
     device = _DEVICE or _select_device()
     image_tensor = _pil_to_tensor(image).to(device)
-    structural = {key: value.to(device) for key, value in _default_structural_tensors(1).items()}
+    structural = {key: value.to(device) for key, value in _extract_online_structural_tensors(image).items()}
 
     with torch.inference_mode():
         prediction = model.generate(