Modified detection flow to prioritize HF Inference API execution first, falling back to local model if API fails. Added backward compatibility logic to handle both new (transformers >=4.44) and legacy (transformers <4.44) post-processing syntax for Grounding DINO results.

gptoss_wrapper.py

@@ -452,8 +452,17 @@ class GPTOSSWrapper:
 
     def _detect_grounding_dino(self, image_path: str, text_queries: list, threshold: float) -> dict:
         """
-        Detect objects using Grounding DINO running on HF GPU.
+        Detect objects using Grounding DINO. Try HF API first, then local model.
         """
+        # Try HF API first (more reliable)
+        if self.hf_token:
+            try:
+                return self._detect_grounding_dino_api(image_path, text_queries, threshold)
+            except Exception as e:
+                print(f"Grounding DINO API failed: {e}")
+                print("Falling back to local model...")
+
+        # Fallback to local model
         try:
             from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
 
@@ -479,14 +488,28 @@ class GPTOSSWrapper:
             with torch.no_grad():
                 outputs = model(**inputs)
 
-            # Post-process results (usar sintaxis correcta)
-            results = processor.post_process_grounded_object_detection(
-                outputs,
-                inputs.input_ids,
-                box_threshold=threshold,
-                text_threshold=0.3,
-                target_sizes=[image.size[::-1]]
-            )
+            # Post-process results (detectar sintaxis automáticamente)
+            try:
+                # Intentar sintaxis nueva (transformers >= 4.44)
+                results = processor.post_process_grounded_object_detection(
+                    outputs,
+                    inputs.input_ids,
+                    box_threshold=threshold,
+                    text_threshold=0.3,
+                    target_sizes=[image.size[::-1]]
+                )
+            except TypeError as e:
+                if "box_threshold" in str(e):
+                    # Fallback a sintaxis antigua (transformers < 4.44)
+                    print("Using legacy post_process_grounded_object_detection syntax")
+                    results = processor.post_process_grounded_object_detection(
+                        outputs,
+                        inputs.input_ids,
+                        threshold=threshold,
+                        target_sizes=[image.size[::-1]]
+                    )
+                else:
+                    raise e
 
             # Convert to our format
             detections = []
@@ -514,6 +537,70 @@ class GPTOSSWrapper:
         except Exception as e:
             raise RuntimeError(f"Grounding DINO detection failed: {e}")
 
+    def _detect_grounding_dino_api(self, image_path: str, text_queries: list, threshold: float) -> dict:
+        """
+        Detect objects using Grounding DINO via HF Inference API.
+        """
+        if not self.hf_token:
+            raise RuntimeError("HF token required for Grounding DINO API")
+
+        try:
+            import base64
+
+            # Encode image to base64
+            with open(image_path, "rb") as image_file:
+                base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+
+            # Prepare text queries (VERY important: lowercase + end with dot)
+            text = ". ".join([query.lower() for query in text_queries]) + "."
+            print(f"Grounding DINO API text query: {text}")
+
+            # Use Grounding DINO model via API
+            model_id = "IDEA-Research/grounding-dino-base"
+            url = f"https://api-inference.huggingface.co/models/{model_id}"
+            headers = {"Authorization": f"Bearer {self.hf_token}"}
+
+            # Prepare payload for Grounding DINO API
+            payload = {
+                "inputs": {
+                    "image": base64_image,
+                    "text": text
+                },
+                "parameters": {
+                    "threshold": threshold
+                }
+            }
+
+            response = requests.post(url, headers=headers, json=payload, timeout=30)
+
+            if response.status_code == 200:
+                data = response.json()
+
+                # Convert API response to our format
+                detections = []
+                if isinstance(data, list):
+                    for detection in data:
+                        if detection.get("score", 0) >= threshold:
+                            box = detection.get("box", {})
+                            detections.append({
+                                "label": detection.get("label", "unknown"),
+                                "confidence": float(detection.get("score", 0)),
+                                "bbox": [
+                                    int(box.get("xmin", 0)),
+                                    int(box.get("ymin", 0)),
+                                    int(box.get("xmax", 0)),
+                                    int(box.get("ymax", 0))
+                                ]
+                            })
+
+                print(f"Grounding DINO API found {len(detections)} detections")
+                return {"detections": detections}
+            else:
+                raise RuntimeError(f"API call failed with status {response.status_code}: {response.text}")
+
+        except Exception as e:
+            raise RuntimeError(f"Grounding DINO API detection failed: {e}")
+
     def _detect_owlv2_local(self, image_path: str, text_queries: list, threshold: float) -> dict:
         """
         Detect objects using OWL-V2 running on HF GPU.