Reference for ultralytics/models/yolo/pose/val.py

def eval_json(self, stats: Dict[str, Any]) -> Dict[str, Any]:
    """Evaluate object detection model using COCO JSON format."""
    anno_json = self.data["path"] / "annotations/person_keypoints_val2017.json"  # annotations
    pred_json = self.save_dir / "predictions.json"  # predictions
    return super().coco_evaluate(stats, pred_json, anno_json, ["bbox", "keypoints"], suffix=["Box", "Pose"])

def get_desc(self) -> str:
    """Return description of evaluation metrics in string format."""
    return ("%22s" + "%11s" * 10) % (
        "Class",
        "Images",
        "Instances",
        "Box(P",
        "R",
        "mAP50",
        "mAP50-95)",
        "Pose(P",
        "R",
        "mAP50",
        "mAP50-95)",
    )

def init_metrics(self, model: torch.nn.Module) -> None:
    """
    Initialize evaluation metrics for YOLO pose validation.

    Args:
        model (torch.nn.Module): Model to validate.
    """
    super().init_metrics(model)
    self.kpt_shape = self.data["kpt_shape"]
    is_pose = self.kpt_shape == [17, 3]
    nkpt = self.kpt_shape[0]
    self.sigma = OKS_SIGMA if is_pose else np.ones(nkpt) / nkpt

def postprocess(self, preds: torch.Tensor) -> Dict[str, torch.Tensor]:
    """
    Postprocess YOLO predictions to extract and reshape keypoints for pose estimation.

    This method extends the parent class postprocessing by extracting keypoints from the 'extra'
    field of predictions and reshaping them according to the keypoint shape configuration.
    The keypoints are reshaped from a flattened format to the proper dimensional structure
    (typically [N, 17, 3] for COCO pose format).

    Args:
        preds (torch.Tensor): Raw prediction tensor from the YOLO pose model containing
            bounding boxes, confidence scores, class predictions, and keypoint data.

    Returns:
        (Dict[torch.Tensor]): Dict of processed prediction dictionaries, each containing:
            - 'bboxes': Bounding box coordinates
            - 'conf': Confidence scores
            - 'cls': Class predictions
            - 'keypoints': Reshaped keypoint coordinates with shape (-1, *self.kpt_shape)

    Note:
        If no keypoints are present in a prediction (empty keypoints), that prediction
        is skipped and continues to the next one. The keypoints are extracted from the
        'extra' field which contains additional task-specific data beyond basic detection.
    """
    preds = super().postprocess(preds)
    for pred in preds:
        pred["keypoints"] = pred.pop("extra").view(-1, *self.kpt_shape)  # remove extra if exists
    return preds

def pred_to_json(self, predn: Dict[str, torch.Tensor], filename: str) -> None:
    """
    Convert YOLO predictions to COCO JSON format.

    This method takes prediction tensors and a filename, converts the bounding boxes from YOLO format
    to COCO format, and appends the results to the internal JSON dictionary (self.jdict).

    Args:
        predn (Dict[str, torch.Tensor]): Prediction dictionary containing 'bboxes', 'conf', 'cls',
            and 'keypoints' tensors.
        filename (str): Path to the image file for which predictions are being processed.

    Notes:
        The method extracts the image ID from the filename stem (either as an integer if numeric, or as a string),
        converts bounding boxes from xyxy to xywh format, and adjusts coordinates from center to top-left corner
        before saving to the JSON dictionary.
    """
    stem = Path(filename).stem
    image_id = int(stem) if stem.isnumeric() else stem
    box = ops.xyxy2xywh(predn["bboxes"])  # xywh
    box[:, :2] -= box[:, 2:] / 2  # xy center to top-left corner
    for b, s, c, k in zip(
        box.tolist(),
        predn["conf"].tolist(),
        predn["cls"].tolist(),
        predn["keypoints"].flatten(1, 2).tolist(),
    ):
        self.jdict.append(
            {
                "image_id": image_id,
                "category_id": self.class_map[int(c)],
                "bbox": [round(x, 3) for x in b],
                "keypoints": k,
                "score": round(s, 5),
            }
        )

def preprocess(self, batch: Dict[str, Any]) -> Dict[str, Any]:
    """Preprocess batch by converting keypoints data to float and moving it to the device."""
    batch = super().preprocess(batch)
    batch["keypoints"] = batch["keypoints"].to(self.device).float()
    return batch

def save_one_txt(self, predn: Dict[str, torch.Tensor], save_conf: bool, shape: Tuple[int, int], file: Path) -> None:
    """
    Save YOLO pose detections to a text file in normalized coordinates.

    Args:
        predn (Dict[str, torch.Tensor]): Dictionary containing predictions with keys 'bboxes', 'conf', 'cls' and 'keypoints.
        save_conf (bool): Whether to save confidence scores.
        shape (Tuple[int, int]): Shape of the original image (height, width).
        file (Path): Output file path to save detections.

    Notes:
        The output format is: class_id x_center y_center width height confidence keypoints where keypoints are
        normalized (x, y, visibility) values for each point.
    """
    from ultralytics.engine.results import Results

    Results(
        np.zeros((shape[0], shape[1]), dtype=np.uint8),
        path=None,
        names=self.names,
        boxes=torch.cat([predn["bboxes"], predn["conf"].unsqueeze(-1), predn["cls"].unsqueeze(-1)], dim=1),
        keypoints=predn["keypoints"],
    ).save_txt(file, save_conf=save_conf)