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

ultralytics/engine/tuner.py

@@ -14,16 +14,19 @@ Examples:
     >>> model.tune(data="coco8.yaml", epochs=10, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)
 """
 
+from __future__ import annotations
+
 import random
 import shutil
 import subprocess
 import time
-from typing import Dict, List, Optional
+from datetime import datetime
 
 import numpy as np
 
 from ultralytics.cfg import get_cfg, get_save_dir
 from ultralytics.utils import DEFAULT_CFG, LOGGER, YAML, callbacks, colorstr, remove_colorstr
+from ultralytics.utils.checks import check_requirements
 from ultralytics.utils.patches import torch_load
 from ultralytics.utils.plotting import plot_tune_results
 
@@ -33,15 +36,18 @@ class Tuner:
     A class for hyperparameter tuning of YOLO models.
 
     The class evolves YOLO model hyperparameters over a given number of iterations by mutating them according to the
-    search space and retraining the model to evaluate their performance.
+    search space and retraining the model to evaluate their performance. Supports both local CSV storage and
+    distributed MongoDB Atlas coordination for multi-machine hyperparameter optimization.
 
     Attributes:
-        space (Dict[str, tuple]): Hyperparameter search space containing bounds and scaling factors for mutation.
+        space (dict[str, tuple]): Hyperparameter search space containing bounds and scaling factors for mutation.
         tune_dir (Path): Directory where evolution logs and results will be saved.
         tune_csv (Path): Path to the CSV file where evolution logs are saved.
         args (dict): Configuration arguments for the tuning process.
         callbacks (list): Callback functions to be executed during tuning.
         prefix (str): Prefix string for logging messages.
+        mongodb (MongoClient): Optional MongoDB client for distributed tuning.
+        collection (Collection): MongoDB collection for storing tuning results.
 
     Methods:
         _mutate: Mutate hyperparameters based on bounds and scaling factors.
@@ -52,20 +58,35 @@ class Tuner:
         >>> from ultralytics import YOLO
         >>> model = YOLO("yolo11n.pt")
         >>> model.tune(
-        ...     data="coco8.yaml", epochs=10, iterations=300, optimizer="AdamW", plots=False, save=False, val=False
-        ... )
+        >>>     data="coco8.yaml",
+        >>>     epochs=10,
+        >>>     iterations=300,
+        >>>     plots=False,
+        >>>     save=False,
+        >>>     val=False
+        >>> )
+
+        Tune with distributed MongoDB Atlas coordination across multiple machines:
+        >>> model.tune(
+        >>>     data="coco8.yaml",
+        >>>     epochs=10,
+        >>>     iterations=300,
+        >>>     mongodb_uri="mongodb+srv://user:pass@cluster.mongodb.net/",
+        >>>     mongodb_db="ultralytics",
+        >>>     mongodb_collection="tune_results"
+        >>> )
 
-        Tune with custom search space.
-        >>> model.tune(space={key1: val1, key2: val2})  # custom search space dictionary
+        Tune with custom search space:
+        >>> model.tune(space={"lr0": (1e-5, 1e-1), "momentum": (0.6, 0.98)})
     """
 
-    def __init__(self, args=DEFAULT_CFG, _callbacks: Optional[List] = None):
+    def __init__(self, args=DEFAULT_CFG, _callbacks: list | None = None):
         """
         Initialize the Tuner with configurations.
 
         Args:
             args (dict): Configuration for hyperparameter evolution.
-            _callbacks (List, optional): Callback functions to be executed during tuning.
+            _callbacks (list | None, optional): Callback functions to be executed during tuning.
         """
         self.space = args.pop("space", None) or {  # key: (min, max, gain(optional))
             # 'optimizer': tune.choice(['SGD', 'Adam', 'AdamW', 'NAdam', 'RAdam', 'RMSProp']),
@@ -94,6 +115,10 @@ class Tuner:
             "cutmix": (0.0, 1.0),  # image cutmix (probability)
             "copy_paste": (0.0, 1.0),  # segment copy-paste (probability)
         }
+        mongodb_uri = args.pop("mongodb_uri", None)
+        mongodb_db = args.pop("mongodb_db", "ultralytics")
+        mongodb_collection = args.pop("mongodb_collection", "tuner_results")
+
         self.args = get_cfg(overrides=args)
         self.args.exist_ok = self.args.resume  # resume w/ same tune_dir
         self.tune_dir = get_save_dir(self.args, name=self.args.name or "tune")
@@ -102,14 +127,152 @@ class Tuner:
         self.callbacks = _callbacks or callbacks.get_default_callbacks()
         self.prefix = colorstr("Tuner: ")
         callbacks.add_integration_callbacks(self)
+
+        # MongoDB Atlas support (optional)
+        self.mongodb = None
+        if mongodb_uri:
+            self._init_mongodb(mongodb_uri, mongodb_db, mongodb_collection)
+
         LOGGER.info(
             f"{self.prefix}Initialized Tuner instance with 'tune_dir={self.tune_dir}'\n"
             f"{self.prefix}💡 Learn about tuning at https://docs.ultralytics.com/guides/hyperparameter-tuning"
         )
 
+    def _connect(self, uri: str = "mongodb+srv://username:password@cluster.mongodb.net/", max_retries: int = 3):
+        """
+        Create MongoDB client with exponential backoff retry on connection failures.
+
+        Args:
+            uri (str): MongoDB connection string with credentials and cluster information.
+            max_retries (int): Maximum number of connection attempts before giving up.
+
+        Returns:
+            (MongoClient): Connected MongoDB client instance.
+        """
+        check_requirements("pymongo")
+
+        from pymongo import MongoClient
+        from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+        for attempt in range(max_retries):
+            try:
+                client = MongoClient(
+                    uri,
+                    serverSelectionTimeoutMS=30000,
+                    connectTimeoutMS=20000,
+                    socketTimeoutMS=40000,
+                    retryWrites=True,
+                    retryReads=True,
+                    maxPoolSize=30,
+                    minPoolSize=3,
+                    maxIdleTimeMS=60000,
+                )
+                client.admin.command("ping")  # Test connection
+                LOGGER.info(f"{self.prefix}Connected to MongoDB Atlas (attempt {attempt + 1})")
+                return client
+            except (ConnectionFailure, ServerSelectionTimeoutError):
+                if attempt == max_retries - 1:
+                    raise
+                wait_time = 2**attempt
+                LOGGER.warning(
+                    f"{self.prefix}MongoDB connection failed (attempt {attempt + 1}), retrying in {wait_time}s..."
+                )
+                time.sleep(wait_time)
+
+    def _init_mongodb(self, mongodb_uri="", mongodb_db="", mongodb_collection=""):
+        """
+        Initialize MongoDB connection for distributed tuning.
+
+        Connects to MongoDB Atlas for distributed hyperparameter optimization across multiple machines.
+        Each worker saves results to a shared collection and reads the latest best hyperparameters
+        from all workers for evolution.
+
+        Args:
+            mongodb_uri (str): MongoDB connection string, e.g. 'mongodb+srv://username:password@cluster.mongodb.net/'.
+            mongodb_db (str, optional): Database name.
+            mongodb_collection (str, optional): Collection name.
+
+        Notes:
+            - Creates a fitness index for fast queries of top results
+            - Falls back to CSV-only mode if connection fails
+            - Uses connection pooling and retry logic for production reliability
+        """
+        self.mongodb = self._connect(mongodb_uri)
+        self.collection = self.mongodb[mongodb_db][mongodb_collection]
+        self.collection.create_index([("fitness", -1)], background=True)
+        LOGGER.info(f"{self.prefix}Using MongoDB Atlas for distributed tuning")
+
+    def _get_mongodb_results(self, n: int = 5) -> list:
+        """
+        Get top N results from MongoDB sorted by fitness.
+
+        Args:
+            n (int): Number of top results to retrieve.
+
+        Returns:
+            (list[dict]): List of result documents with fitness scores and hyperparameters.
+        """
+        try:
+            return list(self.collection.find().sort("fitness", -1).limit(n))
+        except Exception:
+            return []
+
+    def _save_to_mongodb(self, fitness: float, hyperparameters: dict[str, float], metrics: dict, iteration: int):
+        """
+        Save results to MongoDB with proper type conversion.
+
+        Args:
+            fitness (float): Fitness score achieved with these hyperparameters.
+            hyperparameters (dict[str, float]): Dictionary of hyperparameter values.
+            metrics (dict): Complete training metrics dictionary (mAP, precision, recall, losses, etc.).
+            iteration (int): Current iteration number.
+        """
+        try:
+            self.collection.insert_one(
+                {
+                    "fitness": float(fitness),
+                    "hyperparameters": {k: (v.item() if hasattr(v, "item") else v) for k, v in hyperparameters.items()},
+                    "metrics": metrics,
+                    "timestamp": datetime.now(),
+                    "iteration": iteration,
+                }
+            )
+        except Exception as e:
+            LOGGER.warning(f"{self.prefix}MongoDB save failed: {e}")
+
+    def _sync_mongodb_to_csv(self):
+        """
+        Sync MongoDB results to CSV for plotting compatibility.
+
+        Downloads all results from MongoDB and writes them to the local CSV file in chronological order. This enables
+        the existing plotting functions to work seamlessly with distributed MongoDB data.
+        """
+        try:
+            # Get all results from MongoDB
+            all_results = list(self.collection.find().sort("iteration", 1))
+            if not all_results:
+                return
+
+            # Write to CSV
+            headers = ",".join(["fitness"] + list(self.space.keys())) + "\n"
+            with open(self.tune_csv, "w", encoding="utf-8") as f:
+                f.write(headers)
+                for result in all_results:
+                    fitness = result["fitness"]
+                    hyp_values = [result["hyperparameters"][k] for k in self.space.keys()]
+                    log_row = [round(fitness, 5)] + hyp_values
+                    f.write(",".join(map(str, log_row)) + "\n")
+
+        except Exception as e:
+            LOGGER.warning(f"{self.prefix}MongoDB to CSV sync failed: {e}")
+
     def _mutate(
-        self, parent: str = "single", n: int = 5, mutation: float = 0.8, sigma: float = 0.2
-    ) -> Dict[str, float]:
+        self,
+        parent: str = "single",
+        n: int = 5,
+        mutation: float = 0.8,
+        sigma: float = 0.2,
+    ) -> dict[str, float]:
         """
         Mutate hyperparameters based on bounds and scaling factors specified in `self.space`.
 
@@ -120,23 +283,36 @@ class Tuner:
             sigma (float): Standard deviation for Gaussian random number generator.
 
         Returns:
-            (Dict[str, float]): A dictionary containing mutated hyperparameters.
+            (dict[str, float]): A dictionary containing mutated hyperparameters.
         """
-        if self.tune_csv.exists():  # if CSV file exists: select best hyps and mutate
-            # Select parent(s)
-            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
-            fitness = x[:, 0]  # first column
-            n = min(n, len(x))  # number of previous results to consider
-            x = x[np.argsort(-fitness)][:n]  # top n mutations
+        x = None
+
+        # Try MongoDB first if available
+        if self.mongodb:
+            results = self._get_mongodb_results(n)
+            if results:
+                # MongoDB already sorted by fitness DESC, so results[0] is best
+                x = np.array([[r["fitness"]] + [r["hyperparameters"][k] for k in self.space.keys()] for r in results])
+                n = min(n, len(x))
+
+        # Fall back to CSV if MongoDB unavailable or empty
+        if x is None and self.tune_csv.exists():
+            csv_data = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
+            if len(csv_data) > 0:
+                fitness = csv_data[:, 0]  # first column
+                n = min(n, len(csv_data))
+                x = csv_data[np.argsort(-fitness)][:n]  # top n sorted by fitness DESC
+
+        # Mutate if we have data, otherwise use defaults
+        if x is not None:
             w = x[:, 0] - x[:, 0].min() + 1e-6  # weights (sum > 0)
-            if parent == "single" or len(x) == 1:
-                # x = x[random.randint(0, n - 1)]  # random selection
+            if parent == "single" or len(x) <= 1:
                 x = x[random.choices(range(n), weights=w)[0]]  # weighted selection
             elif parent == "weighted":
                 x = (x * w.reshape(n, 1)).sum(0) / w.sum()  # weighted combination
 
             # Mutate
-            r = np.random  # method
+            r = np.random
             r.seed(int(time.time()))
             g = np.array([v[2] if len(v) == 3 else 1.0 for v in self.space.values()])  # gains 0-1
             ng = len(self.space)
@@ -148,9 +324,9 @@ class Tuner:
             hyp = {k: getattr(self.args, k) for k in self.space.keys()}
 
         # Constrain to limits
-        for k, v in self.space.items():
-            hyp[k] = max(hyp[k], v[0])  # lower limit
-            hyp[k] = min(hyp[k], v[1])  # upper limit
+        for k, bounds in self.space.items():
+            hyp[k] = max(hyp[k], bounds[0])  # lower limit
+            hyp[k] = min(hyp[k], bounds[1])  # upper limit
             hyp[k] = round(hyp[k], 5)  # significant digits
 
         return hyp
@@ -159,25 +335,26 @@ class Tuner:
         """
         Execute the hyperparameter evolution process when the Tuner instance is called.
 
-        This method iterates through the number of iterations, performing the following steps in each iteration:
-
-        1. Load the existing hyperparameters or initialize new ones.
-        2. Mutate the hyperparameters using the `_mutate` method.
-        3. Train a YOLO model with the mutated hyperparameters.
-        4. Log the fitness score and mutated hyperparameters to a CSV file.
+        This method iterates through the specified number of iterations, performing the following steps:
+        1. Sync MongoDB results to CSV (if using distributed mode)
+        2. Mutate hyperparameters using the best previous results or defaults
+        3. Train a YOLO model with the mutated hyperparameters
+        4. Log fitness scores and hyperparameters to MongoDB and/or CSV
+        5. Track the best performing configuration across all iterations
 
         Args:
-            model (Model): A pre-initialized YOLO model to be used for training.
+            model (Model | None, optional): A pre-initialized YOLO model to be used for training.
             iterations (int): The number of generations to run the evolution for.
-            cleanup (bool): Whether to delete iteration weights to reduce storage space used during tuning.
-
-        Note:
-            The method utilizes the `self.tune_csv` Path object to read and log hyperparameters and fitness scores.
-            Ensure this path is set correctly in the Tuner instance.
+            cleanup (bool): Whether to delete iteration weights to reduce storage space during tuning.
         """
         t0 = time.time()
         best_save_dir, best_metrics = None, None
         (self.tune_dir / "weights").mkdir(parents=True, exist_ok=True)
+
+        # Sync MongoDB to CSV at startup for proper resume logic
+        if self.mongodb:
+            self._sync_mongodb_to_csv()
+
         start = 0
         if self.tune_csv.exists():
             x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
@@ -204,12 +381,23 @@ class Tuner:
             except Exception as e:
                 LOGGER.error(f"training failure for hyperparameter tuning iteration {i + 1}\n{e}")
 
-            # Save results and mutated_hyp to CSV
+            # Save results - MongoDB takes precedence
             fitness = metrics.get("fitness", 0.0)
-            log_row = [round(fitness, 5)] + [mutated_hyp[k] for k in self.space.keys()]
-            headers = "" if self.tune_csv.exists() else (",".join(["fitness"] + list(self.space.keys())) + "\n")
-            with open(self.tune_csv, "a", encoding="utf-8") as f:
-                f.write(headers + ",".join(map(str, log_row)) + "\n")
+            if self.mongodb:
+                self._save_to_mongodb(fitness, mutated_hyp, metrics, i + 1)
+                self._sync_mongodb_to_csv()
+                total_mongo_iterations = self.collection.count_documents({})
+                if total_mongo_iterations >= iterations:
+                    LOGGER.info(
+                        f"{self.prefix}Target iterations ({iterations}) reached in MongoDB ({total_mongo_iterations}). Stopping."
+                    )
+                    break
+            else:
+                # Save to CSV only if no MongoDB
+                log_row = [round(fitness, 5)] + [mutated_hyp[k] for k in self.space.keys()]
+                headers = "" if self.tune_csv.exists() else (",".join(["fitness"] + list(self.space.keys())) + "\n")
+                with open(self.tune_csv, "a", encoding="utf-8") as f:
+                    f.write(headers + ",".join(map(str, log_row)) + "\n")
 
             # Get best results
             x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
@@ -225,7 +413,7 @@ class Tuner:
                 shutil.rmtree(weights_dir, ignore_errors=True)  # remove iteration weights/ dir to reduce storage space
 
             # Plot tune results
-            plot_tune_results(self.tune_csv)
+            plot_tune_results(str(self.tune_csv))
 
             # Save and print tune results
             header = (

ultralytics/hub/google/__init__.py

@@ -1,9 +1,10 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import concurrent.futures
 import statistics
 import time
-from typing import List, Optional, Tuple
 
 
 class GCPRegions:
@@ -71,16 +72,16 @@ class GCPRegions:
             "us-west4": (2, "Las Vegas", "United States"),
         }
 
-    def tier1(self) -> List[str]:
+    def tier1(self) -> list[str]:
         """Return a list of GCP regions classified as tier 1 based on predefined criteria."""
         return [region for region, info in self.regions.items() if info[0] == 1]
 
-    def tier2(self) -> List[str]:
+    def tier2(self) -> list[str]:
         """Return a list of GCP regions classified as tier 2 based on predefined criteria."""
         return [region for region, info in self.regions.items() if info[0] == 2]
 
     @staticmethod
-    def _ping_region(region: str, attempts: int = 1) -> Tuple[str, float, float, float, float]:
+    def _ping_region(region: str, attempts: int = 1) -> tuple[str, float, float, float, float]:
         """
         Ping a specified GCP region and measure network latency statistics.
 
@@ -122,9 +123,9 @@ class GCPRegions:
         self,
         top: int = 1,
         verbose: bool = False,
-        tier: Optional[int] = None,
+        tier: int | None = None,
         attempts: int = 1,
-    ) -> List[Tuple[str, float, float, float, float]]:
+    ) -> list[tuple[str, float, float, float, float]]:
         """
         Determine the GCP regions with the lowest latency based on ping tests.
 

ultralytics/hub/session.py

@@ -1,11 +1,13 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import shutil
 import threading
 import time
 from http import HTTPStatus
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 from urllib.parse import parse_qs, urlparse
 
 from ultralytics import __version__
@@ -90,7 +92,7 @@ class HUBTrainingSession:
                 )
 
     @classmethod
-    def create_session(cls, identifier: str, args: Optional[Dict[str, Any]] = None):
+    def create_session(cls, identifier: str, args: dict[str, Any] | None = None):
         """
         Create an authenticated HUBTrainingSession or return None.
 
@@ -137,7 +139,7 @@ class HUBTrainingSession:
         self.model.start_heartbeat(self.rate_limits["heartbeat"])
         LOGGER.info(f"{PREFIX}View model at {self.model_url} 🚀")
 
-    def create_model(self, model_args: Dict[str, Any]):
+    def create_model(self, model_args: dict[str, Any]):
         """
         Initialize a HUB training session with the specified model arguments.
 
@@ -204,7 +206,7 @@ class HUBTrainingSession:
             HUBModelError: If the identifier format is not recognized.
         """
         api_key, model_id, filename = None, None, None
-        if str(identifier).endswith((".pt", ".yaml")):
+        if identifier.endswith((".pt", ".yaml")):
             filename = identifier
         elif identifier.startswith(f"{HUB_WEB_ROOT}/models/"):
             parsed_url = urlparse(identifier)
@@ -254,8 +256,8 @@ class HUBTrainingSession:
         timeout: int = 30,
         thread: bool = True,
         verbose: bool = True,
-        progress_total: Optional[int] = None,
-        stream_response: Optional[bool] = None,
+        progress_total: int | None = None,
+        stream_response: bool | None = None,
         *args,
         **kwargs,
     ):

ultralytics/hub/utils.py

@@ -11,8 +11,8 @@ from ultralytics import __version__
 from ultralytics.utils import (
     ARGV,
     ENVIRONMENT,
+    GIT,
     IS_COLAB,
-    IS_GIT_DIR,
     IS_PIP_PACKAGE,
     LOGGER,
     ONLINE,
@@ -23,7 +23,6 @@ from ultralytics.utils import (
     TQDM,
     TryExcept,
     colorstr,
-    get_git_origin_url,
 )
 from ultralytics.utils.downloads import GITHUB_ASSETS_NAMES
 from ultralytics.utils.torch_utils import get_cpu_info
@@ -205,7 +204,7 @@ class Events:
         self.t = 0.0  # rate limit timer (seconds)
         self.metadata = {
             "cli": Path(ARGV[0]).name == "yolo",
-            "install": "git" if IS_GIT_DIR else "pip" if IS_PIP_PACKAGE else "other",
+            "install": "git" if GIT.is_repo else "pip" if IS_PIP_PACKAGE else "other",
             "python": PYTHON_VERSION.rsplit(".", 1)[0],  # i.e. 3.13
             "CPU": get_cpu_info(),
             # "GPU": get_gpu_info(index=0) if cuda else None,
@@ -219,7 +218,7 @@ class Events:
             and RANK in {-1, 0}
             and not TESTS_RUNNING
             and ONLINE
-            and (IS_PIP_PACKAGE or get_git_origin_url() == "https://github.com/ultralytics/ultralytics.git")
+            and (IS_PIP_PACKAGE or GIT.origin == "https://github.com/ultralytics/ultralytics.git")
         )
 
     def __call__(self, cfg, device=None):

ultralytics/models/fastsam/model.py

@@ -1,7 +1,9 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from ultralytics.engine.model import Model
 
@@ -45,10 +47,10 @@ class FastSAM(Model):
         self,
         source,
         stream: bool = False,
-        bboxes: Optional[List] = None,
-        points: Optional[List] = None,
-        labels: Optional[List] = None,
-        texts: Optional[List] = None,
+        bboxes: list | None = None,
+        points: list | None = None,
+        labels: list | None = None,
+        texts: list | None = None,
         **kwargs: Any,
     ):
         """
@@ -74,6 +76,6 @@ class FastSAM(Model):
         return super().predict(source, stream, prompts=prompts, **kwargs)
 
     @property
-    def task_map(self) -> Dict[str, Dict[str, Any]]:
+    def task_map(self) -> dict[str, dict[str, Any]]:
         """Returns a dictionary mapping segment task to corresponding predictor and validator classes."""
         return {"segment": {"predictor": FastSAMPredictor, "validator": FastSAMValidator}}

ultralytics/models/nas/model.py

@@ -1,7 +1,9 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any
 
 import torch
 
@@ -80,7 +82,7 @@ class NAS(Model):
         self.model.args = {**DEFAULT_CFG_DICT, **self.overrides}  # for export()
         self.model.eval()
 
-    def info(self, detailed: bool = False, verbose: bool = True) -> Dict[str, Any]:
+    def info(self, detailed: bool = False, verbose: bool = True) -> dict[str, Any]:
         """
         Log model information.
 
@@ -94,6 +96,6 @@ class NAS(Model):
         return model_info(self.model, detailed=detailed, verbose=verbose, imgsz=640)
 
     @property
-    def task_map(self) -> Dict[str, Dict[str, Any]]:
+    def task_map(self) -> dict[str, dict[str, Any]]:
         """Return a dictionary mapping tasks to respective predictor and validator classes."""
         return {"detect": {"predictor": NASPredictor, "validator": NASValidator}}

ultralytics/models/rtdetr/train.py

@@ -1,7 +1,8 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from copy import copy
-from typing import Optional
 
 from ultralytics.models.yolo.detect import DetectionTrainer
 from ultralytics.nn.tasks import RTDETRDetectionModel
@@ -41,7 +42,7 @@ class RTDETRTrainer(DetectionTrainer):
         >>> trainer.train()
     """
 
-    def get_model(self, cfg: Optional[dict] = None, weights: Optional[str] = None, verbose: bool = True):
+    def get_model(self, cfg: dict | None = None, weights: str | None = None, verbose: bool = True):
         """
         Initialize and return an RT-DETR model for object detection tasks.
 
@@ -58,7 +59,7 @@ class RTDETRTrainer(DetectionTrainer):
             model.load(weights)
         return model
 
-    def build_dataset(self, img_path: str, mode: str = "val", batch: Optional[int] = None):
+    def build_dataset(self, img_path: str, mode: str = "val", batch: int | None = None):
         """
         Build and return an RT-DETR dataset for training or validation.
 

ultralytics/models/rtdetr/val.py

@@ -1,7 +1,9 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any
 
 import torch
 
@@ -155,8 +157,8 @@ class RTDETRValidator(DetectionValidator):
         )
 
     def postprocess(
-        self, preds: Union[torch.Tensor, List[torch.Tensor], Tuple[torch.Tensor]]
-    ) -> List[Dict[str, torch.Tensor]]:
+        self, preds: torch.Tensor | list[torch.Tensor] | tuple[torch.Tensor]
+    ) -> list[dict[str, torch.Tensor]]:
         """
         Apply Non-maximum suppression to prediction outputs.
 
@@ -187,7 +189,7 @@ class RTDETRValidator(DetectionValidator):
 
         return [{"bboxes": x[:, :4], "conf": x[:, 4], "cls": x[:, 5]} for x in outputs]
 
-    def pred_to_json(self, predn: Dict[str, torch.Tensor], pbatch: Dict[str, Any]) -> None:
+    def pred_to_json(self, predn: dict[str, torch.Tensor], pbatch: dict[str, Any]) -> None:
         """
         Serialize YOLO predictions to COCO json format.