mblt-vision-python 0.0.0__tar.gz → 0.0.2__tar.gz

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mblt-vision-python
-Version: 0.0.0
+Version: 0.0.2
 Summary: Mobilint NPU vision models: classification, detection, segmentation, pose
 Author: Mobilint
 License: BSD-3-Clause
@@ -44,6 +44,16 @@ Dynamic: license-file
 
 # Mobilint Vision Python
 
+<!-- markdownlint-disable MD033 -->
+<div align="center">
+<p>
+<a href="https://www.mobilint.com/" target="_blank">
+<img src="https://raw.githubusercontent.com/mobilint/.github/main/assets/Mobilint_Logo_Primary.png" alt="Mobilint Logo" width="60%">
+</a>
+</p>
+</div>
+<!-- markdownlint-enable MD033 -->
+
 Run pre-trained Mobilint Vision models from Python. `mblt-vision-python` provides
 model configuration, artifact loading, preprocessing, inference integration, and
 typed postprocessing results for image classification, depth estimation, face and
@@ -54,6 +64,10 @@ Version `0.0.0` is the initial standalone release.
 
 ## Installation
 
+[![PyPI - Version](https://img.shields.io/pypi/v/mblt-vision-python?logo=pypi&logoColor=white)](https://pypi.org/project/mblt-vision-python/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mblt-vision-python?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://clickpy.clickhouse.com/dashboard/mblt-vision-python)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mblt-vision-python?logo=python&logoColor=gold)](https://pypi.org/project/mblt-vision-python/)
+
 ```bash
 pip install mblt-vision-python
 ```

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/README.md

@@ -1,5 +1,15 @@
 # Mobilint Vision Python
 
+<!-- markdownlint-disable MD033 -->
+<div align="center">
+<p>
+<a href="https://www.mobilint.com/" target="_blank">
+<img src="https://raw.githubusercontent.com/mobilint/.github/main/assets/Mobilint_Logo_Primary.png" alt="Mobilint Logo" width="60%">
+</a>
+</p>
+</div>
+<!-- markdownlint-enable MD033 -->
+
 Run pre-trained Mobilint Vision models from Python. `mblt-vision-python` provides
 model configuration, artifact loading, preprocessing, inference integration, and
 typed postprocessing results for image classification, depth estimation, face and
@@ -10,6 +20,10 @@ Version `0.0.0` is the initial standalone release.
 
 ## Installation
 
+[![PyPI - Version](https://img.shields.io/pypi/v/mblt-vision-python?logo=pypi&logoColor=white)](https://pypi.org/project/mblt-vision-python/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mblt-vision-python?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://clickpy.clickhouse.com/dashboard/mblt-vision-python)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mblt-vision-python?logo=python&logoColor=gold)](https://pypi.org/project/mblt-vision-python/)
+
 ```bash
 pip install mblt-vision-python
 ```

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/__init__.py

@@ -19,7 +19,7 @@ from ._api import list_models as list_models
 from ._api import list_tasks as list_tasks
 from .wrapper import MBLT_Engine as MBLT_Engine
 
-__version__ = "0.0.0"
+__version__ = "0.0.2"
 
 _TASK_MODULES = (
     face_detection,

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/cli/val.py

@@ -439,10 +439,9 @@ def _run_validation(args: argparse.Namespace) -> float:
             )
             print(
                 "Validation score "
-                f"(Easy AP): {widerface_result.easy_ap:.5f}, "
-                f"(Medium AP): {widerface_result.medium_ap:.5f}, "
-                f"(Hard AP): {widerface_result.hard_ap:.5f}, "
-                f"(Mean AP): {widerface_result.mean_ap:.5f}"
+                f"(Hard AP, primary): {widerface_result.hard_ap:.5f}, "
+                f"(Medium AP, secondary): {widerface_result.medium_ap:.5f}, "
+                f"(Easy AP, secondary): {widerface_result.easy_ap:.5f}"
             )
             return widerface_result.primary_score
 

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/datasets/readiness.py

@@ -120,6 +120,27 @@ def _has_positive_polygon_area(polygon: list[int | float]) -> bool:
     return bool(abs(signed_double_area) > 0)
 
 
+def _polygon_union_has_rasterized_foreground(
+    polygons: list[list[int | float]], image_shape: tuple[int, int] | None
+) -> bool:
+    """Return whether the combined COCO polygons rasterize to foreground.
+
+    COCO polygons describe one instance as a union.  Individual components can
+    be thinner than a pixel (as occurs in the official validation annotations),
+    so only the combined raster needs to contain foreground.
+    """
+
+    if image_shape is None:
+        return False
+    height, width = image_shape
+    try:
+        encoded = coco_mask.frPyObjects(polygons, height, width)
+        decoded = np.asarray(coco_mask.decode(encoded))
+    except (RuntimeError, TypeError, ValueError):
+        return False
+    return bool(np.any(decoded))
+
+
 def _canonicalize_quadrilateral(
     coordinates: list[int | float] | tuple[int | float, ...],
 ) -> tuple[float, ...]:
@@ -406,27 +427,32 @@ def _coco_task_annotations_valid(
             or iscrowd not in {0, 1}
         ):
             return False
-        if task == "pose_estimation" and area > bbox[2] * bbox[3]:
+        if task == "pose_estimation" and not iscrowd and area > bbox[2] * bbox[3]:
             return False
         if task == "instance_segmentation":
             segmentation = record.get("segmentation")
             if isinstance(segmentation, list):
-                if not segmentation or any(
-                    not isinstance(polygon, list)
-                    or len(polygon) < 6
-                    or len(polygon) % 2
+                if (
+                    not segmentation
                     or any(
-                        not isinstance(value, (int, float))
-                        or isinstance(value, bool)
-                        or not np.isfinite(value)
-                        for value in polygon
+                        not isinstance(polygon, list)
+                        or len(polygon) < 6
+                        or len(polygon) % 2
+                        or any(
+                            not isinstance(value, (int, float))
+                            or isinstance(value, bool)
+                            or not np.isfinite(value)
+                            for value in polygon
+                        )
+                        or not _has_positive_polygon_area(polygon)
+                        or not _polygon_has_positive_image_overlap(
+                            polygon, image_shapes.get(image_id)
+                        )
+                        for polygon in segmentation
                     )
-                    or not _has_positive_polygon_area(polygon)
-                    or not _polygon_has_positive_image_overlap(
-                        polygon, image_shapes.get(image_id)
+                    or not _polygon_union_has_rasterized_foreground(
+                        segmentation, image_shapes.get(image_id)
                     )
-                    or not _valid_coco_polygon(polygon, image_shapes.get(image_id))
-                    for polygon in segmentation
                 ):
                     return False
             elif isinstance(segmentation, dict):
@@ -545,22 +571,6 @@ def _valid_coco_rle(
     return decoded.shape == tuple(size) and bool(np.any(decoded))
 
 
-def _valid_coco_polygon(
-    polygon: list[int | float], image_shape: tuple[int, int] | None
-) -> bool:
-    """Require a COCO polygon to rasterize to foreground in its image."""
-
-    if image_shape is None:
-        return True
-    height, width = image_shape
-    try:
-        encoded = coco_mask.frPyObjects([polygon], height, width)
-        decoded = np.asarray(coco_mask.decode(encoded))
-    except (RuntimeError, TypeError, ValueError):
-        return False
-    return bool(np.any(decoded))
-
-
 def _coco_ready(root: Path, task: str) -> bool:
     """Check the complete COCO 2017 image split and task annotation metadata."""
 
@@ -734,24 +744,12 @@ def _widerface_difficulty_metadata_ready(
                 or not np.issubdtype(face_array.dtype, np.number)
                 or np.issubdtype(face_array.dtype, np.complexfloating)
                 or not np.isfinite(face_array).all()
-                or (face_array[:, 2:] <= 0).any()
-                or len(np.unique(face_array, axis=0)) != len(face_array)
             ):
                 return False
-            if image_shapes is not None:
-                height, width = image_shapes[event_index][image_index]
-                if (
-                    height <= 0
-                    or width <= 0
-                    or not (
-                        (face_array[:, 0] < width)
-                        & (face_array[:, 0] + face_array[:, 2] > 0)
-                        & (face_array[:, 1] < height)
-                        & (face_array[:, 1] + face_array[:, 3] > 0)
-                    ).all()
-                ):
-                    return False
-            face_counts.append(len(face_array))
+            no_face_sentinel = face_array.shape == (1, 4) and not bool(
+                np.any(face_array)
+            )
+            face_counts.append(0 if no_face_sentinel else len(face_array))
         for difficulty_index, table in enumerate(difficulties):
             try:
                 event_indices = table[event_index][0]
@@ -990,10 +988,6 @@ def dense_dataset_ready(data_path: str | Path, dataset: str) -> bool:
             and all(
                 path.suffix.lower() in {".jpg", ".jpeg"} for path in images.values()
             )
-            and all(
-                not (root / file_name).is_symlink() and (root / file_name).is_file()
-                for file_name in ADE20K_METADATA_FILES
-            )
         )
     if normalized == "cityscapes":
         city_counts: dict[str, int] = {}

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/evaluation/eval_nyu_depth.py

@@ -31,27 +31,33 @@ class NYUDepthResult:
 
     @property
     def secondary_score(self) -> float:
-        """Return the secondary NYU Depth validation metric."""
+        """Return abs_rel for singular-score compatibility."""
 
         return self.abs_rel
 
+    @property
+    def secondary_scores(self) -> tuple[float, float]:
+        """Return abs_rel and RMSE in secondary-metric order."""
+
+        return self.abs_rel, self.rmse
+
 
 class NYUDepthMetricAccumulator:
-    """Accumulate median-aligned metrics over every valid NYU depth pixel."""
+    """Accumulate median-aligned metrics with equal weight for each image."""
 
     MIN_DEPTH = 0.001
     MAX_DEPTH = 100.0
 
     def __init__(self) -> None:
-        """Initialize zero-valued pixel sums."""
+        """Initialize zero-valued per-image metric sums."""
 
         self.delta1_sum = 0.0
         self.abs_rel_sum = 0.0
-        self.squared_error_sum = 0.0
-        self.valid_pixel_count = 0
+        self.rmse_sum = 0.0
+        self.valid_sample_count = 0
 
     def update(self, prediction: np.ndarray, target: np.ndarray) -> None:
-        """Median-align one prediction and add its valid-pixel statistics."""
+        """Median-align one prediction and add its per-image metric values."""
 
         prediction = _as_real_float32(prediction, "prediction")
         target = _as_real_float32(target, "target")
@@ -66,8 +72,7 @@ class NYUDepthMetricAccumulator:
         valid = (
             np.isfinite(target) & (target > self.MIN_DEPTH) & (target < self.MAX_DEPTH)
         )
-        valid_pixel_count = int(valid.sum())
-        if valid_pixel_count == 0:
+        if not valid.any():
             raise ValueError(
                 "NYU Depth sample has no valid pixels in the (0.001, 100.0) range."
             )
@@ -83,20 +88,22 @@ class NYUDepthMetricAccumulator:
         aligned = predicted * (median_target / median_prediction)
         aligned = np.clip(aligned, self.MIN_DEPTH, self.MAX_DEPTH)
         ratio = np.maximum(actual / aligned, aligned / actual)
-        self.delta1_sum += float(np.sum(ratio < 1.25))
-        self.abs_rel_sum += float(np.sum(np.abs(actual - aligned) / actual))
-        self.squared_error_sum += float(np.sum((actual - aligned) ** 2))
-        self.valid_pixel_count += valid_pixel_count
+        # Match Ultralytics' depth validator: median-align and calculate all
+        # metrics per image, then average validation images equally.
+        self.delta1_sum += float(np.mean(ratio < 1.25))
+        self.abs_rel_sum += float(np.mean(np.abs(actual - aligned) / actual))
+        self.rmse_sum += float(np.sqrt(np.mean((actual - aligned) ** 2)))
+        self.valid_sample_count += 1
 
     def result(self) -> NYUDepthResult:
-        """Return metrics pooled over all accumulated valid pixels."""
+        """Return mean per-image metrics."""
 
-        if self.valid_pixel_count == 0:
+        if self.valid_sample_count == 0:
             raise ValueError("NYU Depth evaluation received no valid pixels.")
         return NYUDepthResult(
-            delta1=self.delta1_sum / self.valid_pixel_count,
-            abs_rel=self.abs_rel_sum / self.valid_pixel_count,
-            rmse=float(np.sqrt(self.squared_error_sum / self.valid_pixel_count)),
+            delta1=self.delta1_sum / self.valid_sample_count,
+            abs_rel=self.abs_rel_sum / self.valid_sample_count,
+            rmse=self.rmse_sum / self.valid_sample_count,
         )
 
 
@@ -116,7 +123,7 @@ def _as_real_float32(values: np.ndarray, name: str) -> np.ndarray:
 def calculate_nyu_depth_metrics(
     prediction: np.ndarray, target: np.ndarray
 ) -> NYUDepthResult:
-    """Calculate official pooled metrics for one median-aligned NYU sample."""
+    """Calculate median-aligned NYU metrics for one sample."""
 
     accumulator = NYUDepthMetricAccumulator()
     accumulator.update(prediction, target)

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/evaluation/eval_widerface.py

@@ -34,22 +34,22 @@ class WiderFaceResult(NamedTuple):
     hard_ap: float
 
     @property
-    def mean_ap(self) -> float:
-        """Return the mean AP across Easy, Medium, and Hard."""
+    def primary_score(self) -> float:
+        """Return Hard-set AP as the primary WiderFace metric."""
 
-        return (self.easy_ap + self.medium_ap + self.hard_ap) / 3.0
+        return self.hard_ap
 
     @property
-    def primary_score(self) -> float:
-        """Return mean AP across the three validation splits."""
+    def secondary_score(self) -> float:
+        """Return Medium-set AP for singular-score compatibility."""
 
-        return self.mean_ap
+        return self.medium_ap
 
     @property
-    def secondary_score(self) -> float:
-        """Return Hard-set AP."""
+    def secondary_scores(self) -> tuple[float, float]:
+        """Return Medium- and Easy-set AP in secondary-metric order."""
 
-        return self.hard_ap
+        return self.medium_ap, self.easy_ap
 
 
 def _empty_prediction() -> np.ndarray:
@@ -263,6 +263,27 @@ def get_gt_boxes(gt_dir: str) -> tuple[Any, ...]:
     )
 
 
+def _normalize_ground_truth_boxes(boxes: np.ndarray) -> np.ndarray:
+    """Convert WiderFace's all-zero no-face sentinel into an empty box table."""
+
+    if boxes.shape == (1, 4) and not bool(np.any(boxes)):
+        return np.empty((0, 4), dtype=boxes.dtype)
+    return boxes
+
+
+def _empty_ground_truth_prediction_contribution(
+    thresh_num: int, pred_info: np.ndarray
+) -> np.ndarray:
+    """Return precision-recall counts for predictions on a no-face image."""
+
+    return img_pr_info(
+        thresh_num,
+        pred_info,
+        np.ones(len(pred_info), dtype=np.float32),
+        np.zeros(len(pred_info), dtype=np.float32),
+    )
+
+
 def norm_score(pred: dict[str, Any]) -> dict[str, Any]:
     """Normalize WiderFace prediction scores to ``[0, 1]``."""
 
@@ -413,11 +434,19 @@ def evaluation(
             gt_bbx_list = facebox_list[event_index][0]
             for image_index, img_info in enumerate(img_list):
                 pred_info = pred_list[str(img_info[0][0])]
-                gt_boxes = np.array(gt_bbx_list[image_index][0], dtype=np.float32)
+                gt_boxes = _normalize_ground_truth_boxes(
+                    np.array(gt_bbx_list[image_index][0], dtype=np.float32)
+                )
                 keep_index = np.array(sub_gt_list[image_index][0], dtype=np.int64)
                 count_face += len(keep_index)
 
-                if len(gt_boxes) == 0 or len(pred_info) == 0:
+                if len(gt_boxes) == 0:
+                    if len(pred_info) != 0:
+                        pr_curve += _empty_ground_truth_prediction_contribution(
+                            thresh_num, pred_info
+                        )
+                    continue
+                if len(pred_info) == 0:
                     continue
                 ignore = np.zeros(gt_boxes.shape[0])
                 if len(keep_index) != 0:

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/base.py

@@ -195,7 +195,7 @@ class YOLODetectionPostBase(PostBase):
         conf_thres: float | None = None,
         iou_thres: float | None = None,
         multi_label: bool = False,
-    ) -> list[Any]:
+    ) -> Any:
         """Executes YOLO postprocessing.
 
         Includes rearranging, decoding, and NMS.
@@ -214,6 +214,10 @@ class YOLODetectionPostBase(PostBase):
         final_detections, proto_outs = self.extract_final_outputs(x)
         if final_detections is not None:
             if proto_outs is not None:
+                if not isinstance(final_detections, list):
+                    raise TypeError(
+                        "Mask prototypes require detections as a per-image list."
+                    )
                 return self.masking(final_detections, proto_outs)
             return final_detections
         checked_input = self.check_input(x)
@@ -291,7 +295,7 @@ class YOLODetectionPostBase(PostBase):
     def extract_final_outputs(
         self,
         x: TensorLike | ListTensorLike,
-    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+    ) -> tuple[list[torch.Tensor] | torch.Tensor | None, torch.Tensor | None]:
         """Extract already-decoded ONNX-style detections when present.
 
         Args:

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_anchor_post.py

@@ -99,15 +99,35 @@ class YOLOAnchorDetectionPost(YOLODetectionPostBase):
                 ``(batch, anchors, no)`` format, optionally paired with prototype masks in
                 segmentation subclasses.
         """
-        if len(x) != self.nl:
-            raise ValueError(f"Expected {self.nl} detection heads, got {len(x)}.")
+        # Decode-enabled MXQ artifacts prepend their already-decoded
+        # ``(batch, anchors, features)`` output to the raw detection heads.
+        # Only raw heads participate in anchor-grid decoding.
+        heads = [
+            tmp
+            for tmp in x
+            if (tmp.ndim == 4 and tmp.shape[3] == self.no * self.na)
+            or (tmp.ndim == 5 and tmp.shape[1] == self.na and tmp.shape[-1] == self.no)
+        ]
+        if len(heads) != self.nl:
+            shapes = ", ".join(str(tuple(tmp.shape)) for tmp in x)
+            raise ValueError(
+                f"Expected {self.nl} raw detection heads, got {len(heads)} "
+                f"from outputs: {shapes}."
+            )
         y = []
-        for i in range(self.nl):
-            tmp = x[i]
-            if tmp.shape[3] == self.no * self.na:
+        for tmp in heads:
+            if tmp.ndim == 4 and tmp.shape[3] == self.no * self.na:
                 y.append(
                     tmp.permute(0, 3, 1, 2)
                 )  # (b, 80, 80, 255) -> (b, 255, 80, 80)
+            elif tmp.ndim == 5 and tmp.shape[1] == self.na and tmp.shape[-1] == self.no:
+                # WongKinYiu YOLOv7 ONNX exports each head as
+                # (batch, anchors, height, width, features).
+                y.append(
+                    tmp.permute(0, 1, 4, 2, 3).reshape(
+                        tmp.shape[0], self.na * self.no, tmp.shape[2], tmp.shape[3]
+                    )
+                )
             else:
                 raise NotImplementedError(
                     f"Got unsupported shape for input: {tmp.shape}."

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_anchorless_post.py

@@ -9,6 +9,7 @@ from typing import Literal
 
 import torch
 
+from ..types import ListTensorLike, TensorLike
 from .base import YOLODetectionPostBase
 from .common import (
     YOLOOBBPostMixin,
@@ -563,6 +564,62 @@ class YOLOAnchorlessSegPost(YOLOSegPostMixin, YOLOAnchorlessDetectionPost):
 class YOLOAnchorlessPosePost(YOLOPosePostMixin, YOLOAnchorlessDetectionPost):
     """Postprocessing for YOLO pose estimation models without anchors."""
 
+    def extract_final_outputs(
+        self, x: TensorLike | ListTensorLike
+    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+        """Accept QBCompiler's decode-enabled candidate-first pose output.
+
+        Decode-enabled MXQs emit ``(B, anchors, 5 + keypoints)`` containing
+        ``xywh`` boxes, confidence, and decoded keypoint coordinates. Add the
+        single-class label column and convert the boxes once. QBCompiler leaves
+        visibility as near-zero logits in this layout, so normalize them as the
+        split-head pose decoder does.
+        """
+        if self.e2e and isinstance(x, (list, tuple)) and len(x) == 1:
+            value = x[0]
+            if isinstance(value, torch.Tensor):
+                tensor = value
+            else:
+                try:
+                    tensor = torch.as_tensor(value)
+                except (TypeError, ValueError):
+                    tensor = None
+            expected_dim = 5 + self.n_extra
+            if (
+                tensor is not None
+                and tensor.ndim == 3
+                and tensor.shape[-1] == expected_dim
+                # P6 decode-enabled artifacts do not preserve a valid
+                # keypoint-to-candidate association. Fall back to the legacy
+                # path (boxes only) rather than draw misleading skeletons.
+                and self.nl != 4
+            ):
+                labels = torch.zeros_like(tensor[..., :1])
+                boxes = tensor[..., :4].clone()
+                boxes[..., :2] -= boxes[..., 2:] / 2
+                boxes[..., 2:] += boxes[..., :2]
+                keypoints = tensor[..., 5:].reshape(*tensor.shape[:2], -1, 3).clone()
+                if not bool(torch.isfinite(keypoints[..., 2]).all()):
+                    raise ValueError("Decoded pose visibility logits must be finite.")
+                keypoints[..., 2] = keypoints[..., 2].sigmoid()
+                detections = torch.cat(
+                    (boxes, tensor[..., 4:5], labels, keypoints.flatten(2)), dim=-1
+                )
+                # Final-output extraction normally bypasses ``nms``.  These
+                # compiler candidates are dense, so retain the standard
+                # confidence-sorted NMS step before rendering pose skeletons.
+                retained_batches = self._final_detection_batches(detections)
+                selected_batches = []
+                for batch in retained_batches:
+                    order = torch.argsort(batch[:, 4], descending=True)
+                    ordered = batch[order]
+                    keep = non_max_suppression(
+                        ordered[:, :4], ordered[:, 4], self.iou_thres, max_output=300
+                    )
+                    selected_batches.append(ordered[keep])
+                return selected_batches, None
+        return super().extract_final_outputs(x)
+
     def rearrange(self, x: list[torch.Tensor]) -> torch.Tensor:
         """Rearranges model output tensors for pose estimation tasks.
 

{mblt_vision_python-0.0.0 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_dflfree_post.py

@@ -4,6 +4,7 @@ from typing import Any, cast
 
 import torch
 
+from ..types import ListTensorLike, TensorLike
 from .base import YOLODetectionPostBase
 from .common import (
     YOLOOBBPostMixin,
@@ -14,6 +15,7 @@ from .common import (
     dist2bbox,
     dist2rbox,
     dual_topk,
+    non_max_suppression,
     rotated_nms,
     yolo_multilabel_candidates,
 )
@@ -554,6 +556,41 @@ class YOLODFLFreeSegPost(YOLOSegPostMixin, YOLODFLFreeDetectionPost):
 class YOLODFLFreePosePost(YOLOPosePostMixin, YOLODFLFreeDetectionPost):
     """Postprocessing for YOLO NMS-free pose estimation models."""
 
+    def extract_final_outputs(
+        self, x: TensorLike | ListTensorLike
+    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+        """Accept YOLO26's decode-enabled score, xyxy, and keypoint outputs."""
+        if self.e2e and isinstance(x, (list, tuple)) and len(x) == 4:
+            tensors = [
+                value if isinstance(value, torch.Tensor) else torch.as_tensor(value)
+                for value in x
+            ]
+            converted_parts = self._collect_converted_parts(tensors, require_extra=True)
+            if converted_parts is not None:
+                converted, _ = converted_parts
+                boxes = converted[..., :4]
+                scores = converted[..., 4 : 4 + self.nc]
+                keypoints = converted[..., 4 + self.nc :]
+                keypoints = keypoints.reshape(*keypoints.shape[:2], -1, 3).clone()
+                if not bool(torch.isfinite(keypoints[..., 2]).all()):
+                    raise ValueError("Decoded pose visibility logits must be finite.")
+                keypoints[..., 2] = keypoints[..., 2].sigmoid()
+                labels = torch.zeros_like(scores)
+                detections = torch.cat(
+                    (boxes, scores, labels, keypoints.flatten(2)), dim=-1
+                )
+                retained_batches = self._final_detection_batches(detections)
+                selected_batches = []
+                for batch in retained_batches:
+                    order = torch.argsort(batch[:, 4], descending=True)
+                    ordered = batch[order]
+                    keep = non_max_suppression(
+                        ordered[:, :4], ordered[:, 4], self.iou_thres, max_output=300
+                    )
+                    selected_batches.append(ordered[keep])
+                return selected_batches, None
+        return super().extract_final_outputs(x)
+
     def non_e2e(self, x: list[torch.Tensor]) -> torch.Tensor | list[torch.Tensor]:
         """Return export-style pose outputs for both converted and raw split heads."""