Upload inference.py

inference.py

@@ -20,6 +20,7 @@ Updated: 2026-01-13 - Migrated to class-based interface
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
 
 import cv2
@@ -106,19 +107,29 @@ class ModelInference:
         except Exception as e:
             raise RuntimeError(f"Failed to load class_list.yaml: {e}") from e
 
-        # Build class_ids list based on YAML format
-        # The YAML can be formatted as either {int: str} or {str: int}
-        inv_class = {v: k for k, v in self.class_map.items()}
+        # The YAML can be formatted as either {int_str: species_name} or {species_name: int}
+        # IMPORTANT: The model was trained using LEXICOGRAPHIC sorting of YAML keys!
+        # This means '10' comes before '2' in the sorted order, which creates a specific
+        # class ordering that the model learned during training. We MUST use the same
+        # lexicographic sort to match the model's expectations.
 
         # Check if keys are numeric (int:label format) or string (label:int format)
         formatted_int_label = self._can_all_keys_be_converted_to_int(self.class_map)
 
         if formatted_int_label:
-            # Format: {0: "species1", 1: "species2", ...}
-            self.class_ids = [self.class_map[i] for i in sorted(inv_class.values())]
+            # Format: {'0': 'species1', '1': 'species2', ...}
+            # Sort keys LEXICOGRAPHICALLY (as strings) to match model training
+            # This creates: ['0', '1', '10', '100', '108', '11', '117', '118', '12', '13', '14', ...]
+            inv_class = {v: k for k, v in self.class_map.items()}
+            yaml_keys_sorted = sorted(inv_class.values())  # Lexicographic sort on string keys
+
+            # Build dense list: model_output[i] → class_ids[i] = species at yaml_keys_sorted[i]
+            self.class_ids = [self.class_map[yaml_key] for yaml_key in yaml_keys_sorted]
         else:
             # Format: {"species1": 0, "species2": 1, ...}
-            self.class_ids = sorted(inv_class.values())
+            # Invert to create list where list[i] = species
+            inv_class = {v: k for k, v in self.class_map.items()}
+            self.class_ids = [inv_class[i] for i in sorted(inv_class.keys())]
 
     def _can_all_keys_be_converted_to_int(self, d: dict) -> bool:
         """
@@ -168,6 +179,7 @@ class ModelInference:
 
         # Check for invalid bounding boxes (zero or negative dimensions)
         if w_box <= 0 or h_box <= 0:
+            print(f"[TAS get_crop] Rejecting bbox with zero/negative dims: w={w_box}, h={h_box}", file=sys.stderr, flush=True)
             return None
 
         # Convert normalized coordinates to pixel coordinates
@@ -197,13 +209,20 @@ class ModelInference:
         crop_height = bottom - top
 
         if crop_width <= 0 or crop_height <= 0:
+            print(
+                f"[TAS get_crop] Rejecting bbox after clipping - crop size {crop_width:.1f}x{crop_height:.1f}\n"
+                f"  Original bbox: x={x1:.4f}, y={y1:.4f}, w={w_box:.4f}, h={h_box:.4f}\n"
+                f"  Image size: {im_width}x{im_height}\n"
+                f"  Pixel coords after clip: ({left:.1f},{top:.1f}) to ({right:.1f},{bottom:.1f})",
+                file=sys.stderr, flush=True
+            )
             return None
 
         # Crop image
         image_cropped = image.crop((left, top, right, bottom))
         return image_cropped
 
-    def get_classification(self, crop: Image.Image) -> list[tuple[str, float]]:
+    def get_classification(self, crop: Image.Image) -> list[list[str, float]]:
         """
         Run MEWC-Keras classification on cropped image.
 
@@ -211,14 +230,15 @@ class ModelInference:
         1. Convert PIL Image to numpy array
         2. Resize to 384x384 (MEWC input size)
         3. Run model prediction
-        4. Return all class probabilities
+        4. Return all class probabilities (unsorted - worker handles sorting)
 
         Args:
             crop: Cropped PIL Image
 
         Returns:
-            List of (class_name, confidence) tuples for ALL classes, in model order.
-            Example: [("tasmanian_pademelon", 0.50674), ("bennetts_wallaby", 0.46682), ...]
+            List of [class_name, confidence] lists for ALL classes, in model order.
+            Example: [["unknown_animal", 0.00234], ["tasmanian_pademelon", 0.50674], ...]
+            NOTE: Sorting by confidence is handled by classification_worker.py
 
         Raises:
             RuntimeError: If model not loaded or inference fails
@@ -230,6 +250,7 @@ class ModelInference:
             raise RuntimeError("Class IDs not loaded - call load_model() first")
 
         if crop is None:
+            print("[TAS get_classification] Received None crop, returning empty", file=sys.stderr, flush=True)
             return []
 
         try:
@@ -237,6 +258,7 @@ class ModelInference:
             img = np.array(crop)
 
             if img.size == 0:
+                print("[TAS get_classification] Zero-size numpy array, returning empty", file=sys.stderr, flush=True)
                 return []
 
             # Resize to MEWC input size (384x384)
@@ -248,14 +270,16 @@ class ModelInference:
             # Run prediction (verbose=0 suppresses progress bar)
             pred = self.model.predict(img, verbose=0)[0]
 
-            # Build list of (class_name, confidence) tuples
+            # Build list of [class_name, confidence] pairs (as lists, not tuples!)
             # class_ids is already in the correct order from class_list.yaml
             classifications = []
             for i in range(len(pred)):
                 class_name = self.class_ids[i]  # Get species name from class_list.yaml
                 confidence = float(pred[i])
-                classifications.append((class_name, confidence))
+                classifications.append([class_name, confidence])
 
+            # NOTE: Sorting by confidence is handled by classification_worker.py
+            # Model developers don't need to sort - just return all class predictions
             return classifications
 
         except Exception as e:
@@ -265,9 +289,15 @@ class ModelInference:
         """
         Get mapping of class IDs to species names from class_list.yaml.
 
+        Returns a 1-indexed contiguous mapping that matches the model's output order.
+        The model was trained with lexicographic sorting of YAML keys, so we create
+        a simple 1-indexed mapping: {1: species_at_position_0, 2: species_at_position_1, ...}
+
+        This matches the MegaDetector JSON format and the original MEWC implementation.
+
         Returns:
             Dict mapping class ID (1-indexed string) to species name
-            Example: {"1": "bait", "2": "unknown_animal", ...}
+            Example: {"1": "unknown_animal", "2": "tasmanian_pademelon", ..., "10": "fallow_deer", ...}
 
         Raises:
             RuntimeError: If class_ids not loaded
@@ -275,7 +305,8 @@ class ModelInference:
         if self.class_ids is None:
             raise RuntimeError("Class IDs not loaded - call load_model() first")
 
-        # Build 1-indexed mapping
+        # Build 1-indexed mapping: model position i → JSON ID str(i+1)
+        # class_ids[0] → "1", class_ids[1] → "2", ..., class_ids[9] → "10" (fallow_deer)
         class_names = {}
         for i, class_name in enumerate(self.class_ids):
             class_id_str = str(i + 1)  # 1-indexed