dgenerate-ultralytics-headless 8.3.191__tar.gz → 8.3.193__tar.gz

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.191
+Version: 8.3.193
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.191
+Version: 8.3.193
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.191"
+__version__ = "8.3.193"
 
 import os
 

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/cfg/__init__.py

@@ -15,6 +15,7 @@ from ultralytics.utils import (
     DEFAULT_CFG,
     DEFAULT_CFG_DICT,
     DEFAULT_CFG_PATH,
+    FLOAT_OR_INT,
     IS_VSCODE,
     LOGGER,
     RANK,
@@ -22,6 +23,7 @@ from ultralytics.utils import (
     RUNS_DIR,
     SETTINGS,
     SETTINGS_FILE,
+    STR_OR_PATH,
     TESTS_RUNNING,
     YAML,
     IterableSimpleNamespace,
@@ -267,7 +269,7 @@ def cfg2dict(cfg: str | Path | dict | SimpleNamespace) -> dict:
         - If cfg is a SimpleNamespace object, it's converted to a dictionary using vars().
         - If cfg is already a dictionary, it's returned unchanged.
     """
-    if isinstance(cfg, (str, Path)):
+    if isinstance(cfg, STR_OR_PATH):
         cfg = YAML.load(cfg)  # load dict
     elif isinstance(cfg, SimpleNamespace):
         cfg = vars(cfg)  # convert to dict
@@ -309,7 +311,7 @@ def get_cfg(cfg: str | Path | dict | SimpleNamespace = DEFAULT_CFG_DICT, overrid
 
     # Special handling for numeric project/name
     for k in "project", "name":
-        if k in cfg and isinstance(cfg[k], (int, float)):
+        if k in cfg and isinstance(cfg[k], FLOAT_OR_INT):
             cfg[k] = str(cfg[k])
     if cfg.get("name") == "model":  # assign model to 'name' arg
         cfg["name"] = str(cfg.get("model", "")).partition(".")[0]
@@ -352,7 +354,7 @@ def check_cfg(cfg: dict, hard: bool = True) -> None:
     """
     for k, v in cfg.items():
         if v is not None:  # None values may be from optional args
-            if k in CFG_FLOAT_KEYS and not isinstance(v, (int, float)):
+            if k in CFG_FLOAT_KEYS and not isinstance(v, FLOAT_OR_INT):
                 if hard:
                     raise TypeError(
                         f"'{k}={v}' is of invalid type {type(v).__name__}. "
@@ -360,7 +362,7 @@ def check_cfg(cfg: dict, hard: bool = True) -> None:
                     )
                 cfg[k] = float(v)
             elif k in CFG_FRACTION_KEYS:
-                if not isinstance(v, (int, float)):
+                if not isinstance(v, FLOAT_OR_INT):
                     if hard:
                         raise TypeError(
                             f"'{k}={v}' is of invalid type {type(v).__name__}. "
@@ -413,7 +415,7 @@ def get_save_dir(args: SimpleNamespace, name: str = None) -> Path:
         name = name or args.name or f"{args.mode}"
         save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True)
 
-    return Path(save_dir)
+    return Path(save_dir).resolve()  # resolve to display full path in console
 
 
 def _handle_deprecation(custom: dict) -> dict:

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/cfg/datasets/SKU-110K.yaml

@@ -45,7 +45,7 @@ download: |
   # Convert labels
   names = "image", "x1", "y1", "x2", "y2", "class", "image_width", "image_height"  # column names
   for d in "annotations_train.csv", "annotations_val.csv", "annotations_test.csv":
-      x = pl.read_csv(dir / "annotations" / d, names=names).to_numpy()  # annotations
+      x = pl.read_csv(dir / "annotations" / d, names=names, infer_schema_length=None).to_numpy()  # annotations
       images, unique_images = x[:, 0], np.unique(x[:, 0])
       with open((dir / d).with_suffix(".txt").__str__().replace("annotations_", ""), "w", encoding="utf-8") as f:
           f.writelines(f"./images/{s}\n" for s in unique_images)

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/cfg/datasets/xView.yaml

@@ -87,7 +87,7 @@ download: |
   from PIL import Image
 
   from ultralytics.utils import TQDM
-  from ultralytics.data.utils import autosplit
+  from ultralytics.data.split import autosplit
   from ultralytics.utils.ops import xyxy2xywhn
 
 

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/data/utils.py

@@ -216,7 +216,7 @@ def verify_image_label(args: tuple) -> list:
                     points = lb[:, 1:]
                 # Coordinate points check with 1% tolerance
                 assert points.max() <= 1.01, f"non-normalized or out of bounds coordinates {points[points > 1.01]}"
-                assert lb.min() >= -0.01, f"negative class labels {lb[lb < -0.01]}"
+                assert lb.min() >= -0.01, f"negative class labels or coordinate {lb[lb < -0.01]}"
 
                 # All labels
                 max_cls = 0 if single_cls else lb[:, 0].max()  # max label count

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/engine/exporter.py

@@ -90,6 +90,7 @@ from ultralytics.utils import (
     RKNN_CHIPS,
     ROOT,
     SETTINGS,
+    TORCH_VERSION,
     WINDOWS,
     YAML,
     callbacks,
@@ -567,7 +568,7 @@ class Exporter:
     @try_export
     def export_torchscript(self, prefix=colorstr("TorchScript:")):
         """Export YOLO model to TorchScript format."""
-        LOGGER.info(f"\n{prefix} starting export with torch {torch.__version__}...")
+        LOGGER.info(f"\n{prefix} starting export with torch {TORCH_VERSION}...")
         f = self.file.with_suffix(".torchscript")
 
         ts = torch.jit.trace(NMSModel(self.model, self.args) if self.args.nms else self.model, self.im, strict=False)
@@ -586,7 +587,7 @@ class Exporter:
         """Export YOLO model to ONNX format."""
         requirements = ["onnx>=1.12.0"]
         if self.args.simplify:
-            requirements += ["onnxslim>=0.1.65", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim==0.1.65", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 
@@ -648,7 +649,7 @@ class Exporter:
         import openvino as ov
 
         LOGGER.info(f"\n{prefix} starting export with openvino {ov.__version__}...")
-        assert TORCH_1_13, f"OpenVINO export requires torch>=1.13.0 but torch=={torch.__version__} is installed"
+        assert TORCH_1_13, f"OpenVINO export requires torch>=1.13.0 but torch=={TORCH_VERSION} is installed"
         ov_model = ov.convert_model(
             NMSModel(self.model, self.args) if self.args.nms else self.model,
             input=None if self.args.dynamic else [self.im.shape],
@@ -964,7 +965,7 @@ class Exporter:
                 "ai-edge-litert>=1.2.0,<1.4.0",  # required by 'onnx2tf' package
                 "onnx>=1.12.0",
                 "onnx2tf>=1.26.3",
-                "onnxslim>=0.1.65",
+                "onnxslim==0.1.65",
                 "onnxruntime-gpu" if cuda else "onnxruntime",
                 "protobuf>=5",
             ),

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/engine/model.py

@@ -12,7 +12,7 @@ from PIL import Image
 
 from ultralytics.cfg import TASK2DATA, get_cfg, get_save_dir
 from ultralytics.engine.results import Results
-from ultralytics.nn.tasks import attempt_load_one_weight, guess_model_task, yaml_model_load
+from ultralytics.nn.tasks import guess_model_task, load_checkpoint, yaml_model_load
 from ultralytics.utils import (
     ARGV,
     ASSETS,
@@ -294,7 +294,7 @@ class Model(torch.nn.Module):
         weights = checks.check_model_file_from_stem(weights)  # add suffix, i.e. yolo11n -> yolo11n.pt
 
         if str(weights).rpartition(".")[-1] == "pt":
-            self.model, self.ckpt = attempt_load_one_weight(weights)
+            self.model, self.ckpt = load_checkpoint(weights)
             self.task = self.model.task
             self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
             self.ckpt_path = self.model.pt_path
@@ -385,7 +385,7 @@ class Model(torch.nn.Module):
         self._check_is_pytorch_model()
         if isinstance(weights, (str, Path)):
             self.overrides["pretrained"] = weights  # remember the weights for DDP training
-            weights, self.ckpt = attempt_load_one_weight(weights)
+            weights, self.ckpt = load_checkpoint(weights)
         self.model.load(weights)
         return self
 
@@ -802,7 +802,7 @@ class Model(torch.nn.Module):
         # Update model and cfg after training
         if RANK in {-1, 0}:
             ckpt = self.trainer.best if self.trainer.best.exists() else self.trainer.last
-            self.model, self.ckpt = attempt_load_one_weight(ckpt)
+            self.model, self.ckpt = load_checkpoint(ckpt)
             self.overrides = self.model.args
             self.metrics = getattr(self.trainer.validator, "metrics", None)  # TODO: no metrics returned by DDP
         return self.metrics

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/engine/predictor.py

@@ -266,13 +266,17 @@ class BasePredictor:
             channels=getattr(self.model, "ch", 3),
         )
         self.source_type = self.dataset.source_type
-        if not getattr(self, "stream", True) and (
+        long_sequence = (
             self.source_type.stream
             or self.source_type.screenshot
             or len(self.dataset) > 1000  # many images
             or any(getattr(self.dataset, "video_flag", [False]))
-        ):  # videos
-            LOGGER.warning(STREAM_WARNING)
+        )
+        if long_sequence:
+            import torchvision  # noqa (import here triggers torchvision NMS use in nms.py)
+
+            if not getattr(self, "stream", True):  # videos
+                LOGGER.warning(STREAM_WARNING)
         self.vid_writer = {}
 
     @smart_inference_mode()

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/engine/trainer.py

@@ -24,7 +24,7 @@ from torch import nn, optim
 from ultralytics import __version__
 from ultralytics.cfg import get_cfg, get_save_dir
 from ultralytics.data.utils import check_cls_dataset, check_det_dataset
-from ultralytics.nn.tasks import attempt_load_one_weight, attempt_load_weights
+from ultralytics.nn.tasks import load_checkpoint
 from ultralytics.utils import (
     DEFAULT_CFG,
     GIT,
@@ -544,7 +544,7 @@ class BaseTrainer:
         """Read results.csv into a dictionary using polars."""
         import polars as pl  # scope for faster 'import ultralytics'
 
-        return pl.read_csv(self.csv).to_dict(as_series=False)
+        return pl.read_csv(self.csv, infer_schema_length=None).to_dict(as_series=False)
 
     def _model_train(self):
         """Set model in training mode."""
@@ -644,10 +644,10 @@ class BaseTrainer:
         cfg, weights = self.model, None
         ckpt = None
         if str(self.model).endswith(".pt"):
-            weights, ckpt = attempt_load_one_weight(self.model)
+            weights, ckpt = load_checkpoint(self.model)
             cfg = weights.yaml
         elif isinstance(self.args.pretrained, (str, Path)):
-            weights, _ = attempt_load_one_weight(self.args.pretrained)
+            weights, _ = load_checkpoint(self.args.pretrained)
         self.model = self.get_model(cfg=cfg, weights=weights, verbose=RANK == -1)  # calls Model(cfg, weights)
         return ckpt
 
@@ -768,7 +768,7 @@ class BaseTrainer:
                 last = Path(check_file(resume) if exists else get_latest_run())
 
                 # Check that resume data YAML exists, otherwise strip to force re-download of dataset
-                ckpt_args = attempt_load_weights(last).args
+                ckpt_args = load_checkpoint(last)[0].args
                 if not isinstance(ckpt_args["data"], dict) and not Path(ckpt_args["data"]).exists():
                     ckpt_args["data"] = self.args.data
 

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/engine/tuner.py

@@ -20,11 +20,13 @@ import random
 import shutil
 import subprocess
 import time
+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
 
@@ -34,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.
@@ -53,11 +58,26 @@ 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
-        ... )
-
-        Tune with custom search space.
-        >>> model.tune(space={key1: val1, key2: val2})  # custom search space dictionary
+        >>>     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={"lr0": (1e-5, 1e-1), "momentum": (0.6, 0.98)})
     """
 
     def __init__(self, args=DEFAULT_CFG, _callbacks: list | None = None):
@@ -66,7 +86,7 @@ class Tuner:
 
         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']),
@@ -95,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")
@@ -103,13 +127,151 @@ 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
+        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`.
@@ -121,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)
@@ -149,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
@@ -160,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)
@@ -205,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)
@@ -226,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 = (

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/models/yolo/classify/train.py

@@ -166,8 +166,8 @@ class ClassificationTrainer(BaseTrainer):
 
     def preprocess_batch(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
         """Preprocess a batch of images and classes."""
-        batch["img"] = batch["img"].to(self.device)
-        batch["cls"] = batch["cls"].to(self.device)
+        batch["img"] = batch["img"].to(self.device, non_blocking=True)
+        batch["cls"] = batch["cls"].to(self.device, non_blocking=True)
         return batch
 
     def progress_string(self) -> str:

{dgenerate_ultralytics_headless-8.3.191 → dgenerate_ultralytics_headless-8.3.193}/ultralytics/models/yolo/classify/val.py

@@ -91,7 +91,7 @@ class ClassificationValidator(BaseValidator):
         """Preprocess input batch by moving data to device and converting to appropriate dtype."""
         batch["img"] = batch["img"].to(self.device, non_blocking=True)
         batch["img"] = batch["img"].half() if self.args.half else batch["img"].float()
-        batch["cls"] = batch["cls"].to(self.device)
+        batch["cls"] = batch["cls"].to(self.device, non_blocking=True)
         return batch
 
     def update_metrics(self, preds: torch.Tensor, batch: dict[str, Any]) -> None: