dgenerate-ultralytics-headless 8.3.190__py3-none-any.whl → 8.3.191__py3-none-any.whl

ultralytics/utils/metrics.py

@@ -1,11 +1,13 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 """Model validation metrics."""
 
+from __future__ import annotations
+
 import math
 import warnings
 from collections import defaultdict
 from pathlib import Path
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any
 
 import numpy as np
 import torch
@@ -165,7 +167,7 @@ def mask_iou(mask1: torch.Tensor, mask2: torch.Tensor, eps: float = 1e-7) -> tor
 
 
 def kpt_iou(
-    kpt1: torch.Tensor, kpt2: torch.Tensor, area: torch.Tensor, sigma: List[float], eps: float = 1e-7
+    kpt1: torch.Tensor, kpt2: torch.Tensor, area: torch.Tensor, sigma: list[float], eps: float = 1e-7
 ) -> torch.Tensor:
     """
     Calculate Object Keypoint Similarity (OKS).
@@ -188,7 +190,7 @@ def kpt_iou(
     return ((-e).exp() * kpt_mask[:, None]).sum(-1) / (kpt_mask.sum(-1)[:, None] + eps)
 
 
-def _get_covariance_matrix(boxes: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+def _get_covariance_matrix(boxes: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """
     Generate covariance matrix from oriented bounding boxes.
 
@@ -254,9 +256,7 @@ def probiou(obb1: torch.Tensor, obb2: torch.Tensor, CIoU: bool = False, eps: flo
     return iou
 
 
-def batch_probiou(
-    obb1: Union[torch.Tensor, np.ndarray], obb2: Union[torch.Tensor, np.ndarray], eps: float = 1e-7
-) -> torch.Tensor:
+def batch_probiou(obb1: torch.Tensor | np.ndarray, obb2: torch.Tensor | np.ndarray, eps: float = 1e-7) -> torch.Tensor:
     """
     Calculate the probabilistic IoU between oriented bounding boxes.
 
@@ -293,7 +293,7 @@ def batch_probiou(
     return 1 - hd
 
 
-def smooth_bce(eps: float = 0.1) -> Tuple[float, float]:
+def smooth_bce(eps: float = 0.1) -> tuple[float, float]:
     """
     Compute smoothed positive and negative Binary Cross-Entropy targets.
 
@@ -322,7 +322,7 @@ class ConfusionMatrix(DataExportMixin):
         matches (dict): Contains the indices of ground truths and predictions categorized into TP, FP and FN.
     """
 
-    def __init__(self, names: Dict[int, str] = [], task: str = "detect", save_matches: bool = False):
+    def __init__(self, names: dict[int, str] = [], task: str = "detect", save_matches: bool = False):
         """
         Initialize a ConfusionMatrix instance.
 
@@ -337,7 +337,7 @@ class ConfusionMatrix(DataExportMixin):
         self.names = names  # name of classes
         self.matches = {} if save_matches else None
 
-    def _append_matches(self, mtype: str, batch: Dict[str, Any], idx: int) -> None:
+    def _append_matches(self, mtype: str, batch: dict[str, Any], idx: int) -> None:
         """
         Append the matches to TP, FP, FN or GT list for the last batch.
 
@@ -363,7 +363,7 @@ class ConfusionMatrix(DataExportMixin):
                 # NOTE: masks.max() > 1.0 means overlap_mask=True with (1, H, W) shape
                 self.matches[mtype][k] += [v[0] == idx + 1] if v.max() > 1.0 else [v[idx]]
 
-    def process_cls_preds(self, preds: List[torch.Tensor], targets: List[torch.Tensor]) -> None:
+    def process_cls_preds(self, preds: list[torch.Tensor], targets: list[torch.Tensor]) -> None:
         """
         Update confusion matrix for classification task.
 
@@ -377,8 +377,8 @@ class ConfusionMatrix(DataExportMixin):
 
     def process_batch(
         self,
-        detections: Dict[str, torch.Tensor],
-        batch: Dict[str, Any],
+        detections: dict[str, torch.Tensor],
+        batch: dict[str, Any],
         conf: float = 0.25,
         iou_thres: float = 0.45,
     ) -> None:
@@ -404,7 +404,7 @@ class ConfusionMatrix(DataExportMixin):
         no_pred = len(detections["cls"]) == 0
         if gt_cls.shape[0] == 0:  # Check if labels is empty
             if not no_pred:
-                detections = {k: detections[k][detections["conf"] > conf] for k in detections.keys()}
+                detections = {k: detections[k][detections["conf"] > conf] for k in detections}
                 detection_classes = detections["cls"].int().tolist()
                 for i, dc in enumerate(detection_classes):
                     self.matrix[dc, self.nc] += 1  # FP
@@ -417,7 +417,7 @@ class ConfusionMatrix(DataExportMixin):
                 self._append_matches("FN", batch, i)
             return
 
-        detections = {k: detections[k][detections["conf"] > conf] for k in detections.keys()}
+        detections = {k: detections[k][detections["conf"] > conf] for k in detections}
         gt_classes = gt_cls.int().tolist()
         detection_classes = detections["cls"].int().tolist()
         bboxes = detections["bboxes"]
@@ -459,7 +459,7 @@ class ConfusionMatrix(DataExportMixin):
         """Return the confusion matrix."""
         return self.matrix
 
-    def tp_fp(self) -> Tuple[np.ndarray, np.ndarray]:
+    def tp_fp(self) -> tuple[np.ndarray, np.ndarray]:
         """
         Return true positives and false positives.
 
@@ -497,7 +497,7 @@ class ConfusionMatrix(DataExportMixin):
                 labels[k] += mbatch[k]
 
         labels = {k: torch.stack(v, 0) if len(v) else v for k, v in labels.items()}
-        if not self.task == "obb" and len(labels["bboxes"]):
+        if self.task != "obb" and len(labels["bboxes"]):
             labels["bboxes"] = xyxy2xywh(labels["bboxes"])
         (save_dir / "visualizations").mkdir(parents=True, exist_ok=True)
         plot_images(
@@ -589,7 +589,7 @@ class ConfusionMatrix(DataExportMixin):
         for i in range(self.matrix.shape[0]):
             LOGGER.info(" ".join(map(str, self.matrix[i])))
 
-    def summary(self, normalize: bool = False, decimals: int = 5) -> List[Dict[str, float]]:
+    def summary(self, normalize: bool = False, decimals: int = 5) -> list[dict[str, float]]:
         """
         Generate a summarized representation of the confusion matrix as a list of dictionaries, with optional
         normalization. This is useful for exporting the matrix to various formats such as CSV, XML, HTML, JSON, or SQL.
@@ -640,7 +640,7 @@ def plot_pr_curve(
     py: np.ndarray,
     ap: np.ndarray,
     save_dir: Path = Path("pr_curve.png"),
-    names: Dict[int, str] = {},
+    names: dict[int, str] = {},
     on_plot=None,
 ):
     """
@@ -683,7 +683,7 @@ def plot_mc_curve(
     px: np.ndarray,
     py: np.ndarray,
     save_dir: Path = Path("mc_curve.png"),
-    names: Dict[int, str] = {},
+    names: dict[int, str] = {},
     xlabel: str = "Confidence",
     ylabel: str = "Metric",
     on_plot=None,
@@ -724,7 +724,7 @@ def plot_mc_curve(
         on_plot(save_dir)
 
 
-def compute_ap(recall: List[float], precision: List[float]) -> Tuple[float, np.ndarray, np.ndarray]:
+def compute_ap(recall: list[float], precision: list[float]) -> tuple[float, np.ndarray, np.ndarray]:
     """
     Compute the average precision (AP) given the recall and precision curves.
 
@@ -765,10 +765,10 @@ def ap_per_class(
     plot: bool = False,
     on_plot=None,
     save_dir: Path = Path(),
-    names: Dict[int, str] = {},
+    names: dict[int, str] = {},
     eps: float = 1e-16,
     prefix: str = "",
-) -> Tuple:
+) -> tuple:
     """
     Compute the average precision per class for object detection evaluation.
 
@@ -893,7 +893,7 @@ class Metric(SimpleClass):
         self.nc = 0
 
     @property
-    def ap50(self) -> Union[np.ndarray, List]:
+    def ap50(self) -> np.ndarray | list:
         """
         Return the Average Precision (AP) at an IoU threshold of 0.5 for all classes.
 
@@ -903,7 +903,7 @@ class Metric(SimpleClass):
         return self.all_ap[:, 0] if len(self.all_ap) else []
 
     @property
-    def ap(self) -> Union[np.ndarray, List]:
+    def ap(self) -> np.ndarray | list:
         """
         Return the Average Precision (AP) at an IoU threshold of 0.5-0.95 for all classes.
 
@@ -962,11 +962,11 @@ class Metric(SimpleClass):
         """
         return self.all_ap.mean() if len(self.all_ap) else 0.0
 
-    def mean_results(self) -> List[float]:
+    def mean_results(self) -> list[float]:
         """Return mean of results, mp, mr, map50, map."""
         return [self.mp, self.mr, self.map50, self.map]
 
-    def class_result(self, i: int) -> Tuple[float, float, float, float]:
+    def class_result(self, i: int) -> tuple[float, float, float, float]:
         """Return class-aware result, p[i], r[i], ap50[i], ap[i]."""
         return self.p[i], self.r[i], self.ap50[i], self.ap[i]
 
@@ -1014,12 +1014,12 @@ class Metric(SimpleClass):
         ) = results
 
     @property
-    def curves(self) -> List:
+    def curves(self) -> list:
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
     @property
-    def curves_results(self) -> List[List]:
+    def curves_results(self) -> list[list]:
         """Return a list of curves for accessing specific metrics curves."""
         return [
             [self.px, self.prec_values, "Recall", "Precision"],
@@ -1058,7 +1058,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
         summary: Generate a summarized representation of per-class detection metrics as a list of dictionaries.
     """
 
-    def __init__(self, names: Dict[int, str] = {}) -> None:
+    def __init__(self, names: dict[int, str] = {}) -> None:
         """
         Initialize a DetMetrics instance with a save directory, plot flag, and class names.
 
@@ -1073,7 +1073,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
         self.nt_per_class = None
         self.nt_per_image = None
 
-    def update_stats(self, stat: Dict[str, Any]) -> None:
+    def update_stats(self, stat: dict[str, Any]) -> None:
         """
         Update statistics by appending new values to existing stat collections.
 
@@ -1084,7 +1084,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
         for k in self.stats.keys():
             self.stats[k].append(stat[k])
 
-    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> Dict[str, np.ndarray]:
+    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
         """
         Process predicted results for object detection and update metrics.
 
@@ -1097,7 +1097,7 @@ class DetMetrics(SimpleClass, DataExportMixin):
             (Dict[str, np.ndarray]): Dictionary containing concatenated statistics arrays.
         """
         stats = {k: np.concatenate(v, 0) for k, v in self.stats.items()}  # to numpy
-        if len(stats) == 0:
+        if not stats:
             return stats
         results = ap_per_class(
             stats["tp"],
@@ -1122,15 +1122,15 @@ class DetMetrics(SimpleClass, DataExportMixin):
             v.clear()
 
     @property
-    def keys(self) -> List[str]:
+    def keys(self) -> list[str]:
         """Return a list of keys for accessing specific metrics."""
         return ["metrics/precision(B)", "metrics/recall(B)", "metrics/mAP50(B)", "metrics/mAP50-95(B)"]
 
-    def mean_results(self) -> List[float]:
+    def mean_results(self) -> list[float]:
         """Calculate mean of detected objects & return precision, recall, mAP50, and mAP50-95."""
         return self.box.mean_results()
 
-    def class_result(self, i: int) -> Tuple[float, float, float, float]:
+    def class_result(self, i: int) -> tuple[float, float, float, float]:
         """Return the result of evaluating the performance of an object detection model on a specific class."""
         return self.box.class_result(i)
 
@@ -1145,28 +1145,28 @@ class DetMetrics(SimpleClass, DataExportMixin):
         return self.box.fitness()
 
     @property
-    def ap_class_index(self) -> List:
+    def ap_class_index(self) -> list:
         """Return the average precision index per class."""
         return self.box.ap_class_index
 
     @property
-    def results_dict(self) -> Dict[str, float]:
+    def results_dict(self) -> dict[str, float]:
         """Return dictionary of computed performance metrics and statistics."""
         keys = self.keys + ["fitness"]
         values = ((float(x) if hasattr(x, "item") else x) for x in (self.mean_results() + [self.fitness]))
         return dict(zip(keys, values))
 
     @property
-    def curves(self) -> List[str]:
+    def curves(self) -> list[str]:
         """Return a list of curves for accessing specific metrics curves."""
         return ["Precision-Recall(B)", "F1-Confidence(B)", "Precision-Confidence(B)", "Recall-Confidence(B)"]
 
     @property
-    def curves_results(self) -> List[List]:
+    def curves_results(self) -> list[list]:
         """Return a list of computed performance metrics and statistics."""
         return self.box.curves_results
 
-    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Any]]:
+    def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
         """
         Generate a summarized representation of per-class detection metrics as a list of dictionaries. Includes shared
         scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
@@ -1227,7 +1227,7 @@ class SegmentMetrics(DetMetrics):
         summary: Generate a summarized representation of per-class segmentation metrics as a list of dictionaries.
     """
 
-    def __init__(self, names: Dict[int, str] = {}) -> None:
+    def __init__(self, names: dict[int, str] = {}) -> None:
         """
         Initialize a SegmentMetrics instance with a save directory, plot flag, and class names.
 
@@ -1239,7 +1239,7 @@ class SegmentMetrics(DetMetrics):
         self.task = "segment"
         self.stats["tp_m"] = []  # add additional stats for masks
 
-    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> Dict[str, np.ndarray]:
+    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
         """
         Process the detection and segmentation metrics over the given set of predictions.
 
@@ -1268,7 +1268,7 @@ class SegmentMetrics(DetMetrics):
         return stats
 
     @property
-    def keys(self) -> List[str]:
+    def keys(self) -> list[str]:
         """Return a list of keys for accessing metrics."""
         return DetMetrics.keys.fget(self) + [
             "metrics/precision(M)",
@@ -1277,11 +1277,11 @@ class SegmentMetrics(DetMetrics):
             "metrics/mAP50-95(M)",
         ]
 
-    def mean_results(self) -> List[float]:
+    def mean_results(self) -> list[float]:
         """Return the mean metrics for bounding box and segmentation results."""
         return DetMetrics.mean_results(self) + self.seg.mean_results()
 
-    def class_result(self, i: int) -> List[float]:
+    def class_result(self, i: int) -> list[float]:
         """Return classification results for a specified class index."""
         return DetMetrics.class_result(self, i) + self.seg.class_result(i)
 
@@ -1296,7 +1296,7 @@ class SegmentMetrics(DetMetrics):
         return self.seg.fitness() + DetMetrics.fitness.fget(self)
 
     @property
-    def curves(self) -> List[str]:
+    def curves(self) -> list[str]:
         """Return a list of curves for accessing specific metrics curves."""
         return DetMetrics.curves.fget(self) + [
             "Precision-Recall(M)",
@@ -1306,11 +1306,11 @@ class SegmentMetrics(DetMetrics):
         ]
 
     @property
-    def curves_results(self) -> List[List]:
+    def curves_results(self) -> list[list]:
         """Return a list of computed performance metrics and statistics."""
         return DetMetrics.curves_results.fget(self) + self.seg.curves_results
 
-    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Any]]:
+    def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
         """
         Generate a summarized representation of per-class segmentation metrics as a list of dictionaries. Includes both
         box and mask scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
@@ -1364,7 +1364,7 @@ class PoseMetrics(DetMetrics):
         summary: Generate a summarized representation of per-class pose metrics as a list of dictionaries.
     """
 
-    def __init__(self, names: Dict[int, str] = {}) -> None:
+    def __init__(self, names: dict[int, str] = {}) -> None:
         """
         Initialize the PoseMetrics class with directory path, class names, and plotting options.
 
@@ -1376,7 +1376,7 @@ class PoseMetrics(DetMetrics):
         self.task = "pose"
         self.stats["tp_p"] = []  # add additional stats for pose
 
-    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> Dict[str, np.ndarray]:
+    def process(self, save_dir: Path = Path("."), plot: bool = False, on_plot=None) -> dict[str, np.ndarray]:
         """
         Process the detection and pose metrics over the given set of predictions.
 
@@ -1405,7 +1405,7 @@ class PoseMetrics(DetMetrics):
         return stats
 
     @property
-    def keys(self) -> List[str]:
+    def keys(self) -> list[str]:
         """Return a list of evaluation metric keys."""
         return DetMetrics.keys.fget(self) + [
             "metrics/precision(P)",
@@ -1414,11 +1414,11 @@ class PoseMetrics(DetMetrics):
             "metrics/mAP50-95(P)",
         ]
 
-    def mean_results(self) -> List[float]:
+    def mean_results(self) -> list[float]:
         """Return the mean results of box and pose."""
         return DetMetrics.mean_results(self) + self.pose.mean_results()
 
-    def class_result(self, i: int) -> List[float]:
+    def class_result(self, i: int) -> list[float]:
         """Return the class-wise detection results for a specific class i."""
         return DetMetrics.class_result(self, i) + self.pose.class_result(i)
 
@@ -1433,7 +1433,7 @@ class PoseMetrics(DetMetrics):
         return self.pose.fitness() + DetMetrics.fitness.fget(self)
 
     @property
-    def curves(self) -> List[str]:
+    def curves(self) -> list[str]:
         """Return a list of curves for accessing specific metrics curves."""
         return DetMetrics.curves.fget(self) + [
             "Precision-Recall(B)",
@@ -1447,11 +1447,11 @@ class PoseMetrics(DetMetrics):
         ]
 
     @property
-    def curves_results(self) -> List[List]:
+    def curves_results(self) -> list[list]:
         """Return a list of computed performance metrics and statistics."""
         return DetMetrics.curves_results.fget(self) + self.pose.curves_results
 
-    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, Any]]:
+    def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, Any]]:
         """
         Generate a summarized representation of per-class pose metrics as a list of dictionaries. Includes both box and
         pose scalar metrics (mAP, mAP50, mAP75) alongside precision, recall, and F1-score for each class.
@@ -1525,26 +1525,26 @@ class ClassifyMetrics(SimpleClass, DataExportMixin):
         return (self.top1 + self.top5) / 2
 
     @property
-    def results_dict(self) -> Dict[str, float]:
+    def results_dict(self) -> dict[str, float]:
         """Return a dictionary with model's performance metrics and fitness score."""
         return dict(zip(self.keys + ["fitness"], [self.top1, self.top5, self.fitness]))
 
     @property
-    def keys(self) -> List[str]:
+    def keys(self) -> list[str]:
         """Return a list of keys for the results_dict property."""
         return ["metrics/accuracy_top1", "metrics/accuracy_top5"]
 
     @property
-    def curves(self) -> List:
+    def curves(self) -> list:
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
     @property
-    def curves_results(self) -> List:
+    def curves_results(self) -> list:
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
-    def summary(self, normalize: bool = True, decimals: int = 5) -> List[Dict[str, float]]:
+    def summary(self, normalize: bool = True, decimals: int = 5) -> list[dict[str, float]]:
         """
         Generate a single-row summary of classification metrics (Top-1 and Top-5 accuracy).
 
@@ -1580,7 +1580,7 @@ class OBBMetrics(DetMetrics):
         https://arxiv.org/pdf/2106.06072.pdf
     """
 
-    def __init__(self, names: Dict[int, str] = {}) -> None:
+    def __init__(self, names: dict[int, str] = {}) -> None:
         """
         Initialize an OBBMetrics instance with directory, plotting, and class names.
 

ultralytics/utils/ops.py

@@ -1,10 +1,11 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import contextlib
 import math
 import re
 import time
-from typing import Optional
 
 import cv2
 import numpy as np
@@ -38,7 +39,7 @@ class Profile(contextlib.ContextDecorator):
         ...     time.sleep(0.1)
     """
 
-    def __init__(self, t: float = 0.0, device: Optional[torch.device] = None):
+    def __init__(self, t: float = 0.0, device: torch.device | None = None):
         """
         Initialize the Profile class.
 

ultralytics/utils/patches.py

@@ -1,11 +1,13 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 """Monkey patches to update/extend functionality of existing functions."""
 
+from __future__ import annotations
+
 import time
 from contextlib import contextmanager
 from copy import copy
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import cv2
 import numpy as np
@@ -15,7 +17,7 @@ import torch
 _imshow = cv2.imshow  # copy to avoid recursion errors
 
 
-def imread(filename: str, flags: int = cv2.IMREAD_COLOR) -> Optional[np.ndarray]:
+def imread(filename: str, flags: int = cv2.IMREAD_COLOR) -> np.ndarray | None:
     """
     Read an image from a file with multilanguage filename support.
 
@@ -42,7 +44,7 @@ def imread(filename: str, flags: int = cv2.IMREAD_COLOR) -> Optional[np.ndarray]
         return im[..., None] if im is not None and im.ndim == 2 else im  # Always ensure 3 dimensions
 
 
-def imwrite(filename: str, img: np.ndarray, params: Optional[List[int]] = None) -> bool:
+def imwrite(filename: str, img: np.ndarray, params: list[int] | None = None) -> bool:
     """
     Write an image to a file with multilanguage filename support.
 
@@ -164,7 +166,7 @@ def arange_patch(args):
 
 
 @contextmanager
-def override_configs(args, overrides: Optional[Dict[str, Any]] = None):
+def override_configs(args, overrides: dict[str, Any] | None = None):
     """
     Context manager to temporarily override configurations in args.
 

ultralytics/utils/plotting.py

@@ -1,9 +1,11 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import math
 import warnings
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable
 
 import cv2
 import numpy as np
@@ -142,12 +144,12 @@ class Colors:
             dtype=np.uint8,
         )
 
-    def __call__(self, i: int, bgr: bool = False) -> tuple:
+    def __call__(self, i: int | torch.Tensor, bgr: bool = False) -> tuple:
         """
         Convert hex color codes to RGB values.
 
         Args:
-            i (int): Color index.
+            i (int | torch.Tensor): Color index.
             bgr (bool, optional): Whether to return BGR format instead of RGB.
 
         Returns:
@@ -190,8 +192,8 @@ class Annotator:
     def __init__(
         self,
         im,
-        line_width: Optional[int] = None,
-        font_size: Optional[int] = None,
+        line_width: int | None = None,
+        font_size: int | None = None,
         font: str = "Arial.ttf",
         pil: bool = False,
         example: str = "abc",
@@ -409,10 +411,10 @@ class Annotator:
         self,
         kpts,
         shape: tuple = (640, 640),
-        radius: Optional[int] = None,
+        radius: int | None = None,
         kpt_line: bool = True,
         conf_thres: float = 0.25,
-        kpt_color: Optional[tuple] = None,
+        kpt_color: tuple | None = None,
     ):
         """
         Plot keypoints on the image.
@@ -517,7 +519,7 @@ class Annotator:
         """Return annotated image as array."""
         return np.asarray(self.im)
 
-    def show(self, title: Optional[str] = None):
+    def show(self, title: str | None = None):
         """Show the annotated image."""
         im = Image.fromarray(np.asarray(self.im)[..., ::-1])  # Convert numpy array to PIL Image with RGB to BGR
         if IS_COLAB or IS_KAGGLE:  # can not use IS_JUPYTER as will run for all ipython environments
@@ -533,7 +535,7 @@ class Annotator:
         cv2.imwrite(filename, np.asarray(self.im))
 
     @staticmethod
-    def get_bbox_dimension(bbox: Optional[tuple] = None):
+    def get_bbox_dimension(bbox: tuple | None = None):
         """
         Calculate the dimensions and area of a bounding box.
 
@@ -678,17 +680,17 @@ def save_one_box(
 
 @threaded
 def plot_images(
-    labels: Dict[str, Any],
-    images: Union[torch.Tensor, np.ndarray] = np.zeros((0, 3, 640, 640), dtype=np.float32),
-    paths: Optional[List[str]] = None,
+    labels: dict[str, Any],
+    images: torch.Tensor | np.ndarray = np.zeros((0, 3, 640, 640), dtype=np.float32),
+    paths: list[str] | None = None,
     fname: str = "images.jpg",
-    names: Optional[Dict[int, str]] = None,
-    on_plot: Optional[Callable] = None,
+    names: dict[int, str] | None = None,
+    on_plot: Callable | None = None,
     max_size: int = 1920,
     max_subplots: int = 16,
     save: bool = True,
     conf_thres: float = 0.25,
-) -> Optional[np.ndarray]:
+) -> np.ndarray | None:
     """
     Plot image grid with labels, bounding boxes, masks, and keypoints.
 
@@ -851,7 +853,7 @@ def plot_results(
     segment: bool = False,
     pose: bool = False,
     classify: bool = False,
-    on_plot: Optional[Callable] = None,
+    on_plot: Callable | None = None,
 ):
     """
     Plot training results from a results CSV file. The function supports various types of data including segmentation,

ultralytics/utils/torch_utils.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import functools
 import gc
 import math
@@ -10,7 +12,7 @@ from contextlib import contextmanager
 from copy import deepcopy
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any
 
 import numpy as np
 import torch
@@ -708,7 +710,7 @@ class ModelEMA:
             copy_attr(self.ema, model, include, exclude)
 
 
-def strip_optimizer(f: Union[str, Path] = "best.pt", s: str = "", updates: Dict[str, Any] = None) -> Dict[str, Any]:
+def strip_optimizer(f: str | Path = "best.pt", s: str = "", updates: dict[str, Any] = None) -> dict[str, Any]:
     """
     Strip optimizer from 'f' to finalize training, optionally save as 's'.