ultralytics 8.3.116__py3-none-any.whl → 8.3.118__py3-none-any.whl

tests/test_solutions.py

@@ -0,0 +1,176 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Tests Ultralytics Solutions: https://docs.ultralytics.com/solutions/,
+# including every solution excluding DistanceCalculation and Security Alarm System.
+
+import cv2
+import pytest
+
+from tests import MODEL, TMP
+from ultralytics import solutions
+from ultralytics.utils import ASSETS_URL, IS_RASPBERRYPI, LINUX, checks
+from ultralytics.utils.downloads import safe_download
+
+# Pre-defined arguments values
+SHOW = False
+DEMO_VIDEO = "solutions_ci_demo.mp4"  # for all the solutions, except workout, object cropping and parking management
+CROP_VIDEO = "decelera_landscape_min.mov"  # for object cropping solution
+POSE_VIDEO = "solution_ci_pose_demo.mp4"  # only for workouts monitoring solution
+PARKING_VIDEO = "solution_ci_parking_demo.mp4"  # only for parking management solution
+PARKING_AREAS_JSON = "solution_ci_parking_areas.json"  # only for parking management solution
+PARKING_MODEL = "solutions_ci_parking_model.pt"  # only for parking management solution
+REGION = [(10, 200), (540, 200), (540, 180), (10, 180)]  # for object counting, speed estimation and queue management
+
+# Test configs for each solution : (name, class, needs_frame_count, video, kwargs)
+SOLUTIONS = [
+    (
+        "ObjectCounter",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "Heatmap",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "model": MODEL, "show": SHOW, "region": None},
+    ),
+    (
+        "HeatmapWithRegion",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "SpeedEstimator",
+        solutions.SpeedEstimator,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "QueueManager",
+        solutions.QueueManager,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "LineAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "line", "model": MODEL, "show": SHOW},
+    ),
+    (
+        "PieAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "pie", "model": MODEL, "show": SHOW},
+    ),
+    (
+        "BarAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "bar", "model": MODEL, "show": SHOW},
+    ),
+    (
+        "AreaAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "area", "model": MODEL, "show": SHOW},
+    ),
+    ("TrackZone", solutions.TrackZone, False, DEMO_VIDEO, {"region": REGION, "model": MODEL, "show": SHOW}),
+    (
+        "ObjectCropper",
+        solutions.ObjectCropper,
+        False,
+        CROP_VIDEO,
+        {"crop_dir": str(TMP / "cropped-detections"), "model": MODEL, "show": SHOW},
+    ),
+    (
+        "ObjectBlurrer",
+        solutions.ObjectBlurrer,
+        False,
+        DEMO_VIDEO,
+        {"blur_ratio": 0.5, "model": MODEL, "show": SHOW},
+    ),
+    (
+        "InstanceSegmentation",
+        solutions.InstanceSegmentation,
+        False,
+        DEMO_VIDEO,
+        {"model": "yolo11n-seg.pt", "show": SHOW},
+    ),
+    ("VisionEye", solutions.VisionEye, False, DEMO_VIDEO, {"model": MODEL, "show": SHOW}),
+    (
+        "RegionCounter",
+        solutions.RegionCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL, "show": SHOW},
+    ),
+    ("AIGym", solutions.AIGym, False, POSE_VIDEO, {"kpts": [6, 8, 10], "show": SHOW}),
+    (
+        "ParkingManager",
+        solutions.ParkingManagement,
+        False,
+        PARKING_VIDEO,
+        {"model": str(TMP / PARKING_MODEL), "show": SHOW, "json_file": str(TMP / PARKING_AREAS_JSON)},
+    ),
+    (
+        "StreamlitInference",
+        solutions.Inference,
+        False,
+        None,  # streamlit application don't require video file
+        {},  # streamlit application don't accept arguments
+    ),
+]
+
+
+def process_video(solution, video_path, needs_frame_count=False):
+    """Process video with solution, feeding frames and optional frame count."""
+    cap = cv2.VideoCapture(video_path)
+    assert cap.isOpened(), f"Error reading video file {video_path}"
+
+    frame_count = 0
+    while cap.isOpened():
+        success, im0 = cap.read()
+        if not success:
+            break
+        frame_count += 1
+        im_copy = im0.copy()
+        args = [im_copy, frame_count] if needs_frame_count else [im_copy]
+        _ = solution(*args)
+
+    cap.release()
+
+
+@pytest.mark.skipif(
+    (LINUX and checks.IS_PYTHON_3_11) or IS_RASPBERRYPI,
+    reason="Disabled for testing due to --slow test errors after YOLOE PR.",
+)
+@pytest.mark.parametrize("name, solution_class, needs_frame_count, video, kwargs", SOLUTIONS)
+def test_solution(name, solution_class, needs_frame_count, video, kwargs):
+    """Test individual Ultralytics solution."""
+    if video:
+        safe_download(url=f"{ASSETS_URL}/{video}", dir=TMP)
+    if name == "ParkingManager":
+        safe_download(url=f"{ASSETS_URL}/{PARKING_AREAS_JSON}", dir=TMP)
+        safe_download(url=f"{ASSETS_URL}/{PARKING_MODEL}", dir=TMP)
+    elif name == "StreamlitInference":
+        if checks.check_imshow():  # do not merge with elif above
+            solution_class(**kwargs).inference()  # requires interactive GUI environment
+        return
+
+    process_video(
+        solution=solution_class(**kwargs),
+        video_path=str(TMP / video),
+        needs_frame_count=needs_frame_count,
+    )

ultralytics/__init__.py

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

ultralytics/cfg/__init__.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Union
 
 import cv2
 
+from ultralytics import __version__
 from ultralytics.utils import (
     ASSETS,
     DEFAULT_CFG,
@@ -24,7 +25,6 @@ from ultralytics.utils import (
     SETTINGS_FILE,
     TESTS_RUNNING,
     IterableSimpleNamespace,
-    __version__,
     checks,
     colorstr,
     deprecation_warn,

ultralytics/data/augment.py

@@ -1586,6 +1586,9 @@ class LetterBox:
 
         if shape[::-1] != new_unpad:  # resize
             img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+            if img.ndim == 2:
+                img = img[..., None]
+
         top, bottom = int(round(dh - 0.1)) if self.center else 0, int(round(dh + 0.1))
         left, right = int(round(dw - 0.1)) if self.center else 0, int(round(dw + 0.1))
         h, w, c = img.shape

ultralytics/data/base.py

@@ -15,7 +15,8 @@ import psutil
 from torch.utils.data import Dataset
 
 from ultralytics.data.utils import FORMATS_HELP_MSG, HELP_URL, IMG_FORMATS, check_file_speeds
-from ultralytics.utils import DEFAULT_CFG, LOCAL_RANK, LOGGER, NUM_THREADS, TQDM, imread
+from ultralytics.utils import DEFAULT_CFG, LOCAL_RANK, LOGGER, NUM_THREADS, TQDM
+from ultralytics.utils.patches import imread
 
 
 class BaseDataset(Dataset):
@@ -32,6 +33,7 @@ class BaseDataset(Dataset):
         single_cls (bool): Whether to treat all objects as a single class.
         prefix (str): Prefix to print in log messages.
         fraction (float): Fraction of dataset to utilize.
+        cv2_flag (int): OpenCV flag for reading images.
         im_files (List[str]): List of image file paths.
         labels (List[Dict]): List of label data dictionaries.
         ni (int): Number of images in the dataset.
@@ -78,6 +80,7 @@ class BaseDataset(Dataset):
         single_cls=False,
         classes=None,
         fraction=1.0,
+        channels=3,
     ):
         """
         Initialize BaseDataset with given configuration and options.
@@ -96,6 +99,7 @@ class BaseDataset(Dataset):
             single_cls (bool, optional): If True, single class training is used.
             classes (list, optional): List of included classes.
             fraction (float, optional): Fraction of dataset to utilize.
+            channels (int, optional): Number of channels in the images (1 for grayscale, 3 for RGB).
         """
         super().__init__()
         self.img_path = img_path
@@ -104,6 +108,8 @@ class BaseDataset(Dataset):
         self.single_cls = single_cls
         self.prefix = prefix
         self.fraction = fraction
+        self.channels = channels
+        self.cv2_flag = cv2.IMREAD_GRAYSCALE if channels == 1 else cv2.IMREAD_COLOR
         self.im_files = self.get_img_files(self.img_path)
         self.labels = self.get_labels()
         self.update_labels(include_class=classes)  # single_cls and include_class
@@ -223,9 +229,9 @@ class BaseDataset(Dataset):
                 except Exception as e:
                     LOGGER.warning(f"{self.prefix}Removing corrupt *.npy image file {fn} due to: {e}")
                     Path(fn).unlink(missing_ok=True)
-                    im = imread(f)  # BGR
+                    im = imread(f, flags=self.cv2_flag)  # BGR
             else:  # read image
-                im = imread(f)  # BGR
+                im = imread(f, flags=self.cv2_flag)  # BGR
             if im is None:
                 raise FileNotFoundError(f"Image Not Found {f}")
 
@@ -237,6 +243,8 @@ class BaseDataset(Dataset):
                     im = cv2.resize(im, (w, h), interpolation=cv2.INTER_LINEAR)
             elif not (h0 == w0 == self.imgsz):  # resize by stretching image to square imgsz
                 im = cv2.resize(im, (self.imgsz, self.imgsz), interpolation=cv2.INTER_LINEAR)
+            if im.ndim == 2:
+                im = im[..., None]
 
             # Add to buffer if training with augmentations
             if self.augment:

ultralytics/data/dataset.py

@@ -12,14 +12,14 @@ import torch
 from PIL import Image
 from torch.utils.data import ConcatDataset
 
-from ultralytics.utils import LOCAL_RANK, NUM_THREADS, TQDM, colorstr
+from ultralytics.utils import LOCAL_RANK, LOGGER, NUM_THREADS, TQDM, colorstr
+from ultralytics.utils.instance import Instances
 from ultralytics.utils.ops import resample_segments, segments2boxes
 from ultralytics.utils.torch_utils import TORCHVISION_0_18
 
 from .augment import (
     Compose,
     Format,
-    Instances,
     LetterBox,
     RandomLoadText,
     classify_augmentations,
@@ -30,7 +30,6 @@ from .base import BaseDataset
 from .converter import merge_multi_segment
 from .utils import (
     HELP_URL,
-    LOGGER,
     check_file_speeds,
     get_hash,
     img2label_paths,
@@ -85,7 +84,7 @@ class YOLODataset(BaseDataset):
         self.use_obb = task == "obb"
         self.data = data
         assert not (self.use_segments and self.use_keypoints), "Can not use both segments and keypoints."
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, channels=self.data["channels"], **kwargs)
 
     def cache_labels(self, path=Path("./labels.cache")):
         """

ultralytics/data/loaders.py

@@ -16,8 +16,9 @@ import torch
 from PIL import Image
 
 from ultralytics.data.utils import FORMATS_HELP_MSG, IMG_FORMATS, VID_FORMATS
-from ultralytics.utils import IS_COLAB, IS_KAGGLE, LOGGER, imread, ops
+from ultralytics.utils import IS_COLAB, IS_KAGGLE, LOGGER, ops
 from ultralytics.utils.checks import check_requirements
+from ultralytics.utils.patches import imread
 
 
 @dataclass

ultralytics/engine/exporter.py

@@ -70,6 +70,7 @@ from pathlib import Path
 import numpy as np
 import torch
 
+from ultralytics import __version__
 from ultralytics.cfg import TASK2DATA, get_cfg
 from ultralytics.data import build_dataloader
 from ultralytics.data.dataset import YOLODataset
@@ -81,7 +82,6 @@ from ultralytics.utils import (
     ARM64,
     DEFAULT_CFG,
     IS_COLAB,
-    IS_JETSON,
     LINUX,
     LOGGER,
     MACOS,
@@ -89,13 +89,13 @@ from ultralytics.utils import (
     RKNN_CHIPS,
     ROOT,
     WINDOWS,
-    __version__,
     callbacks,
     colorstr,
     get_default_args,
     yaml_save,
 )
 from ultralytics.utils.checks import (
+    IS_PYTHON_MINIMUM_3_12,
     check_imgsz,
     check_is_path_safe,
     check_requirements,
@@ -238,9 +238,6 @@ class Exporter:
             _callbacks (dict, optional): Dictionary of callback functions.
         """
         self.args = get_cfg(cfg, overrides)
-        if self.args.format.lower() in {"coreml", "mlmodel"}:  # fix attempt for protobuf<3.20.x errors
-            os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"  # must run before TensorBoard callback
-
         self.callbacks = _callbacks or callbacks.get_default_callbacks()
         callbacks.add_integration_callbacks(self)
 
@@ -384,7 +381,7 @@ class Exporter:
                 m.export = True
                 m.format = self.args.format
                 m.max_det = self.args.max_det
-                m.xyxy = self.args.nms
+                m.xyxy = self.args.nms and not coreml
             elif isinstance(m, C2f) and not is_tf_format:
                 # EdgeTPU does not support FlexSplitV while split provides cleaner ONNX graph
                 m.forward = m.forward_split
@@ -703,7 +700,7 @@ class Exporter:
 
     @try_export
     def export_mnn(self, prefix=colorstr("MNN:")):
-        """YOLOv8 MNN export using MNN https://github.com/alibaba/MNN."""
+        """YOLO MNN export using MNN https://github.com/alibaba/MNN."""
         f_onnx, _ = self.export_onnx()  # get onnx model first
 
         check_requirements("MNN>=2.9.6")
@@ -925,10 +922,8 @@ class Exporter:
                 "onnx>=1.12.0",
                 "onnx2tf>=1.26.3",
                 "onnxslim>=0.1.31",
-                "tflite_support<=0.4.3" if IS_JETSON else "tflite_support",  # fix ImportError 'GLIBCXX_3.4.29'
-                "flatbuffers>=23.5.26,<100",  # update old 'flatbuffers' included inside tensorflow package
                 "onnxruntime-gpu" if cuda else "onnxruntime",
-                "protobuf>=5",  # tflite_support pins <=4 but >=5 works
+                "protobuf>=5",
             ),
             cmds="--extra-index-url https://pypi.ngc.nvidia.com",  # onnx_graphsurgeon only on NVIDIA
         )
@@ -1279,8 +1274,20 @@ class Exporter:
 
         return f, None
 
-    def _add_tflite_metadata(self, file):
+    def _add_tflite_metadata(self, file, use_flatbuffers=False):
         """Add metadata to *.tflite models per https://ai.google.dev/edge/litert/models/metadata."""
+        if not use_flatbuffers:
+            import zipfile
+
+            with zipfile.ZipFile(file, "a", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("metadata.json", json.dumps(self.metadata, indent=2))
+            return
+
+        if IS_PYTHON_MINIMUM_3_12:
+            LOGGER.warning(f"TFLite Support package may not be compatible with Python>=3.12 environments for {file}")
+
+        # Update old 'flatbuffers' included inside tensorflow package
+        check_requirements(("tflite_support", "flatbuffers>=23.5.26,<100; platform_machine == 'aarch64'"))
         import flatbuffers
 
         try:

ultralytics/engine/trainer.py

@@ -21,6 +21,7 @@ import torch
 from torch import distributed as dist
 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
@@ -30,7 +31,6 @@ from ultralytics.utils import (
     LOGGER,
     RANK,
     TQDM,
-    __version__,
     callbacks,
     clean_url,
     colorstr,
@@ -268,7 +268,7 @@ class BaseTrainer:
             self.amp = torch.tensor(check_amp(self.model), device=self.device)
             callbacks.default_callbacks = callbacks_backup  # restore callbacks
         if RANK > -1 and world_size > 1:  # DDP
-            dist.broadcast(self.amp, src=0)  # broadcast the tensor from rank 0 to all other ranks (returns None)
+            dist.broadcast(self.amp.int(), src=0)  # broadcast from rank 0 to all other ranks; gloo errors with boolean
         self.amp = bool(self.amp)  # as boolean
         self.scaler = (
             torch.amp.GradScaler("cuda", enabled=self.amp) if TORCH_2_4 else torch.cuda.amp.GradScaler(enabled=self.amp)

ultralytics/hub/session.py

@@ -9,8 +9,9 @@ from urllib.parse import parse_qs, urlparse
 
 import requests
 
-from ultralytics.hub.utils import HELP_MSG, HUB_WEB_ROOT, PREFIX, TQDM
-from ultralytics.utils import IS_COLAB, LOGGER, SETTINGS, __version__, checks, emojis
+from ultralytics import __version__
+from ultralytics.hub.utils import HELP_MSG, HUB_WEB_ROOT, PREFIX
+from ultralytics.utils import IS_COLAB, LOGGER, SETTINGS, TQDM, checks, emojis
 from ultralytics.utils.errors import HUBModelError
 
 AGENT_NAME = f"python-{__version__}-colab" if IS_COLAB else f"python-{__version__}-local"

ultralytics/hub/utils.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 import requests
 
+from ultralytics import __version__
 from ultralytics.utils import (
     ARGV,
     ENVIRONMENT,
@@ -22,7 +23,6 @@ from ultralytics.utils import (
     TESTS_RUNNING,
     TQDM,
     TryExcept,
-    __version__,
     colorstr,
     get_git_origin_url,
 )

ultralytics/models/yolo/detect/predict.py

@@ -47,7 +47,7 @@ class DetectionPredictor(BasePredictor):
             (list): List of Results objects containing the post-processed predictions.
 
         Examples:
-            >>> predictor = DetectionPredictor(overrides=dict(model="yolov8n.pt"))
+            >>> predictor = DetectionPredictor(overrides=dict(model="yolo11n.pt"))
             >>> results = predictor.predict("path/to/image.jpg")
             >>> processed_results = predictor.postprocess(preds, img, orig_imgs)
         """
@@ -59,7 +59,7 @@ class DetectionPredictor(BasePredictor):
             self.args.classes,
             self.args.agnostic_nms,
             max_det=self.args.max_det,
-            nc=len(self.model.names),
+            nc=0 if self.args.task == "detect" else len(self.model.names),
             end2end=getattr(self.model, "end2end", False),
             rotated=self.args.task == "obb",
             return_idxs=save_feats,

ultralytics/models/yolo/detect/val.py

@@ -124,7 +124,7 @@ class DetectionValidator(BaseValidator):
             preds,
             self.args.conf,
             self.args.iou,
-            nc=self.nc,
+            nc=0 if self.args.task == "detect" else self.nc,
             multi_label=True,
             agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,

ultralytics/models/yolo/model.py

@@ -29,16 +29,15 @@ class YOLO(Model):
         (YOLOWorld or YOLOE) based on the model filename.
 
         Args:
-            model (str | Path): Model name or path to model file, i.e. 'yolo11n.pt', 'yolov8n.yaml'.
+            model (str | Path): Model name or path to model file, i.e. 'yolo11n.pt', 'yolo11n.yaml'.
             task (str | None): YOLO task specification, i.e. 'detect', 'segment', 'classify', 'pose', 'obb'.
                 Defaults to auto-detection based on model.
             verbose (bool): Display model info on load.
 
         Examples:
             >>> from ultralytics import YOLO
-            >>> model = YOLO("yolov8n.pt")  # load a pretrained YOLOv8n detection model
-            >>> model = YOLO("yolov8n-seg.pt")  # load a pretrained YOLOv8n segmentation model
             >>> model = YOLO("yolo11n.pt")  # load a pretrained YOLOv11n detection model
+            >>> model = YOLO("yolo11n-seg.pt")  # load a pretrained YOLO11n segmentation model
         """
         path = Path(model)
         if "-world" in path.stem and path.suffix in {".pt", ".yaml", ".yml"}:  # if YOLOWorld PyTorch model

ultralytics/models/yolo/obb/train.py

@@ -65,7 +65,7 @@ class OBBTrainer(yolo.detect.DetectionTrainer):
 
         Examples:
             >>> trainer = OBBTrainer()
-            >>> model = trainer.get_model(cfg="yolov8n-obb.yaml", weights="yolov8n-obb.pt")
+            >>> model = trainer.get_model(cfg="yolo11n-obb.yaml", weights="yolo11n-obb.pt")
         """
         model = OBBModel(cfg, nc=self.data["nc"], ch=self.data["channels"], verbose=verbose and RANK == -1)
         if weights:

ultralytics/models/yolo/pose/predict.py

@@ -41,7 +41,7 @@ class PosePredictor(DetectionPredictor):
         Examples:
             >>> from ultralytics.utils import ASSETS
             >>> from ultralytics.models.yolo.pose import PosePredictor
-            >>> args = dict(model="yolov8n-pose.pt", source=ASSETS)
+            >>> args = dict(model="yolo11n-pose.pt", source=ASSETS)
             >>> predictor = PosePredictor(overrides=args)
             >>> predictor.predict_cli()
         """

ultralytics/models/yolo/pose/train.py

@@ -53,7 +53,7 @@ class PoseTrainer(yolo.detect.DetectionTrainer):
 
         Examples:
             >>> from ultralytics.models.yolo.pose import PoseTrainer
-            >>> args = dict(model="yolov8n-pose.pt", data="coco8-pose.yaml", epochs=3)
+            >>> args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml", epochs=3)
             >>> trainer = PoseTrainer(overrides=args)
             >>> trainer.train()
         """

ultralytics/models/yolo/pose/val.py

@@ -62,7 +62,7 @@ class PoseValidator(DetectionValidator):
 
         Examples:
             >>> from ultralytics.models.yolo.pose import PoseValidator
-            >>> args = dict(model="yolov8n-pose.pt", data="coco8-pose.yaml")
+            >>> args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml")
             >>> validator = PoseValidator(args=args)
             >>> validator()
 

ultralytics/models/yolo/segment/train.py

@@ -39,7 +39,7 @@ class SegmentationTrainer(yolo.detect.DetectionTrainer):
 
         Examples:
             >>> from ultralytics.models.yolo.segment import SegmentationTrainer
-            >>> args = dict(model="yolov8n-seg.pt", data="coco8-seg.yaml", epochs=3)
+            >>> args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml", epochs=3)
             >>> trainer = SegmentationTrainer(overrides=args)
             >>> trainer.train()
         """
@@ -62,8 +62,8 @@ class SegmentationTrainer(yolo.detect.DetectionTrainer):
 
         Examples:
             >>> trainer = SegmentationTrainer()
-            >>> model = trainer.get_model(cfg="yolov8n-seg.yaml")
-            >>> model = trainer.get_model(weights="yolov8n-seg.pt", verbose=False)
+            >>> model = trainer.get_model(cfg="yolo11n-seg.yaml")
+            >>> model = trainer.get_model(weights="yolo11n-seg.pt", verbose=False)
         """
         model = SegmentationModel(cfg, nc=self.data["nc"], ch=self.data["channels"], verbose=verbose and RANK == -1)
         if weights:

ultralytics/models/yolo/yoloe/val.py

@@ -9,9 +9,9 @@ from ultralytics.data import YOLOConcatDataset, build_dataloader, build_yolo_dat
 from ultralytics.data.augment import LoadVisualPrompt
 from ultralytics.data.utils import check_det_dataset
 from ultralytics.models.yolo.detect import DetectionValidator
-from ultralytics.models.yolo.model import YOLOEModel
 from ultralytics.models.yolo.segment import SegmentationValidator
 from ultralytics.nn.modules.head import YOLOEDetect
+from ultralytics.nn.tasks import YOLOEModel
 from ultralytics.utils import LOGGER, TQDM
 from ultralytics.utils.torch_utils import select_device, smart_inference_mode
 

ultralytics/nn/autobackend.py

@@ -14,7 +14,7 @@ import torch
 import torch.nn as nn
 from PIL import Image
 
-from ultralytics.utils import ARM64, IS_JETSON, IS_RASPBERRYPI, LINUX, LOGGER, PYTHON_VERSION, ROOT, yaml_load
+from ultralytics.utils import ARM64, IS_JETSON, LINUX, LOGGER, PYTHON_VERSION, ROOT, yaml_load
 from ultralytics.utils.checks import check_requirements, check_suffix, check_version, check_yaml, is_rockchip
 from ultralytics.utils.downloads import attempt_download_asset, is_url
 
@@ -90,7 +90,7 @@ class AutoBackend(nn.Module):
         _model_type: Determine the model type from file path.
 
     Examples:
-        >>> model = AutoBackend(weights="yolov8n.pt", device="cuda")
+        >>> model = AutoBackend(weights="yolo11n.pt", device="cuda")
         >>> results = model(img)
     """
 
@@ -207,9 +207,6 @@ class AutoBackend(nn.Module):
         elif onnx or imx:
             LOGGER.info(f"Loading {w} for ONNX Runtime inference...")
             check_requirements(("onnx", "onnxruntime-gpu" if cuda else "onnxruntime"))
-            if IS_RASPBERRYPI or IS_JETSON:
-                # Fix 'numpy.linalg._umath_linalg' has no attribute '_ilp64' for TF SavedModel on RPi and Jetson
-                check_requirements("numpy==1.23.5")
             import onnxruntime
 
             providers = ["CPUExecutionProvider"]
@@ -432,10 +429,14 @@ class AutoBackend(nn.Module):
             output_details = interpreter.get_output_details()  # outputs
             # Load metadata
             try:
-                with zipfile.ZipFile(w, "r") as model:
-                    meta_file = model.namelist()[0]
-                    metadata = ast.literal_eval(model.read(meta_file).decode("utf-8"))
-            except zipfile.BadZipFile:
+                with zipfile.ZipFile(w, "r") as zf:
+                    name = zf.namelist()[0]
+                    contents = zf.read(name).decode("utf-8")
+                    if name == "metadata.json":  # Custom Ultralytics metadata dict for Python>=3.12
+                        metadata = json.loads(contents)
+                    else:
+                        metadata = ast.literal_eval(contents)  # Default tflite-support metadata for Python<=3.11
+            except (zipfile.BadZipFile, SyntaxError, ValueError, json.JSONDecodeError):
                 pass
 
         # TF.js