Merge branch 'main' into rm-smoothing

.github/workflows/ci.yaml

@@ -325,6 +325,7 @@ jobs:
           yolo train model=yolo11n.pt data=coco8.yaml epochs=1 imgsz=32
           yolo val model=yolo11n.pt data=coco8.yaml imgsz=32
           yolo export model=yolo11n.pt format=torchscript imgsz=160
+          yolo solutions
       - name: Test Python
         # Note this step must use the updated default bash environment, not a python environment
         run: |

.github/workflows/docs.yml

@@ -39,7 +39,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: ${{ github.event.pull_request.head.repo.full_name || github.repository }}
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets._GITHUB_TOKEN }}
           ref: ${{ github.head_ref || github.ref }}
           fetch-depth: 0
       - name: Set up Python

docs/en/guides/analytics.md

@@ -33,9 +33,21 @@ This guide provides a comprehensive overview of three fundamental types of [data
 - Bar plots, on the other hand, are suitable for comparing quantities across different categories and showing relationships between a category and its numerical value.
 - Lastly, pie charts are effective for illustrating proportions among categories and showing parts of a whole.
 
-!!! analytics "Analytics Examples"
+!!! example "Analytics Examples"
 
-    === "Line Graph"
+    === "CLI"
+
+        ```bash
+         yolo solutions analytics show=True
+
+        # pass the source
+        yolo solutions analytics source="path/to/video/file.mp4"
+
+        # generate the pie chart
+        yolo solutions analytics analytics_type="pie" show=True
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/guides/heatmaps.md

@@ -36,7 +36,20 @@ A heatmap generated with [Ultralytics YOLO11](https://github.com/ultralytics/ult
 
 !!! example "Heatmaps using Ultralytics YOLO11 Example"
 
-    === "Heatmap"
+    === "CLI"
+
+        ```bash
+        # Run a heatmap example
+        yolo solutions heatmap show=True
+
+        # Pass a source video
+        yolo solutions heatmap source="path/to/video/file.mp4"
+
+        # Pass a custom colormap
+        yolo solutions heatmap colormap=cv2.COLORMAP_INFERNO
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/guides/kfold-cross-validation.md

@@ -263,6 +263,7 @@ fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")
 
     for k in range(ksplit):
         dataset_yaml = ds_yamls[k]
+        model = YOLO(weights_path, task="detect")
         model.train(data=dataset_yaml, epochs=epochs, batch=batch, project=project)  # include any train arguments
         results[k] = model.metrics  # save output metrics for further analysis
     ```

docs/en/guides/object-counting.md

@@ -48,7 +48,20 @@ Object counting with [Ultralytics YOLO11](https://github.com/ultralytics/ultraly
 
 !!! example "Object Counting using YOLO11 Example"
 
-    === "Count in Region"
+    === "CLI"
+
+        ```bash
+        # Run a counting example
+        yolo solutions count show=True
+
+        # Pass a source video
+        yolo solutions count source="path/to/video/file.mp4"
+
+        # Pass region coordinates
+        yolo solutions count region=[(20, 400), (1080, 404), (1080, 360), (20, 360)]
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/guides/queue-management.md

@@ -35,7 +35,20 @@ Queue management using [Ultralytics YOLO11](https://github.com/ultralytics/ultra
 
 !!! example "Queue Management using YOLO11 Example"
 
-    === "Queue Manager"
+    === "CLI"
+
+        ```bash
+        # Run a queue example
+        yolo solutions queue show=True
+
+        # Pass a source video
+        yolo solutions queue source="path/to/video/file.mp4"
+
+        # Pass queue coordinates
+        yolo solutions queue region=[(20, 400), (1080, 404), (1080, 360), (20, 360)]
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/guides/speed-estimation.md

@@ -40,7 +40,20 @@ keywords: Ultralytics YOLO11, speed estimation, object tracking, computer vision
 
 !!! example "Speed Estimation using YOLO11 Example"
 
-    === "Speed Estimation"
+    === "CLI"
+
+        ```bash
+        # Run a speed example
+        yolo solutions speed show=True
+
+        # Pass a source video
+        yolo solutions speed source="path/to/video/file.mp4"
+
+        # Pass region coordinates
+        yolo solutions speed region=[(20, 400), (1080, 404), (1080, 360), (20, 360)]
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/guides/workouts-monitoring.md

@@ -36,7 +36,20 @@ Monitoring workouts through pose estimation with [Ultralytics YOLO11](https://gi
 
 !!! example "Workouts Monitoring Example"
 
-    === "Workouts Monitoring"
+    === "CLI"
+
+        ```bash
+        # Run a workout example
+        yolo solutions workout show=True
+
+        # Pass a source video
+        yolo solutions workout source="path/to/video/file.mp4"
+
+        # Use keypoints for pushups
+        yolo solutions workout kpts=[6, 8, 10]
+        ```
+
+    === "Python"
 
         ```python
         import cv2

docs/en/integrations/albumentations.md

@@ -8,7 +8,7 @@ keywords: Albumentations, YOLO11, data augmentation, Ultralytics, computer visio
 
 When you are building [computer vision models](../models/index.md), the quality and variety of your [training data](../datasets/index.md) can play a big role in how well your model performs. Albumentations offers a fast, flexible, and efficient way to apply a wide range of image transformations that can improve your model's ability to adapt to real-world scenarios. It easily integrates with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) and can help you create robust datasets for [object detection](../tasks/detect.md), [segmentation](../tasks/segment.md), and [classification](../tasks/classify.md) tasks.
 
-By using Albumentations, you can boost your YOLO11 training data with techniques like geometric transformations and color adjustments. In this article, we’ll see how Albumentations can improve your [data augmentation](../guides/preprocessing_annotated_data.md) process and make your [YOLO11 projects](../solutions/index.md) even more impactful. Let’s get started!
+By using Albumentations, you can boost your YOLO11 training data with techniques like geometric transformations and color adjustments. In this article, we'll see how Albumentations can improve your [data augmentation](../guides/preprocessing_annotated_data.md) process and make your [YOLO11 projects](../solutions/index.md) even more impactful. Let's get started!
 
 ## Albumentations for Image Augmentation
 
@@ -40,7 +40,7 @@ Albumentations offers many useful features that simplify complex image augmentat
 
 With respect to image augmentation, Albumentations stands out as a reliable tool for computer vision tasks. Here are a few key reasons why you should consider using it for your Vision AI projects:
 
-- **Easy-to-Use API**: Albumentations provides a single, straightforward API for applying a wide range of augmentations to images, masks, bounding boxes, and keypoints. It’s designed to adapt easily to different datasets, making [data preparation](../guides/data-collection-and-annotation.md) simpler and more efficient.
+- **Easy-to-Use API**: Albumentations provides a single, straightforward API for applying a wide range of augmentations to images, masks, bounding boxes, and keypoints. It's designed to adapt easily to different datasets, making [data preparation](../guides/data-collection-and-annotation.md) simpler and more efficient.
 
 - **Rigorous Bug Testing**: Bugs in the augmentation pipeline can silently corrupt input data, often going unnoticed but ultimately degrading model performance. Albumentations addresses this with a thorough test suite that helps catch bugs early in development.
 
@@ -48,11 +48,11 @@ With respect to image augmentation, Albumentations stands out as a reliable tool
 
 ## How to Use Albumentations to Augment Data for YOLO11 Training
 
-Now that we’ve covered what Albumentations is and what it can do, let’s look at how to use it to augment your data for YOLO11 model training. It’s easy to set up because it integrates directly into [Ultralytics’ training mode](../modes/train.md) and applies automatically if you have the Albumentations package installed.
+Now that we've covered what Albumentations is and what it can do, let's look at how to use it to augment your data for YOLO11 model training. It's easy to set up because it integrates directly into [Ultralytics' training mode](../modes/train.md) and applies automatically if you have the Albumentations package installed.
 
 ### Installation
 
-To use Albumentations with YOLOv11, start by making sure you have the necessary packages installed. If Albumentations isn’t installed, the augmentations won’t be applied during training. Once set up, you’ll be ready to create an augmented dataset for training, with Albumentations integrated to enhance your model automatically.
+To use Albumentations with YOLOv11, start by making sure you have the necessary packages installed. If Albumentations isn't installed, the augmentations won't be applied during training. Once set up, you'll be ready to create an augmented dataset for training, with Albumentations integrated to enhance your model automatically.
 
 !!! tip "Installation"
 
@@ -67,7 +67,7 @@ For detailed instructions and best practices related to the installation process
 
 ### Usage
 
-After installing the necessary packages, you’re ready to start using Albumentations with YOLO11. When you train YOLOv11, a set of augmentations is automatically applied through its integration with Albumentations, making it easy to enhance your model’s performance.
+After installing the necessary packages, you're ready to start using Albumentations with YOLO11. When you train YOLOv11, a set of augmentations is automatically applied through its integration with Albumentations, making it easy to enhance your model's performance.
 
 !!! example "Usage"
 
@@ -83,17 +83,17 @@ After installing the necessary packages, you’re ready to start using Albumenta
         results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
         ```
 
-Next, let’s take look a closer look at the specific augmentations that are applied during training.
+Next, let's take look a closer look at the specific augmentations that are applied during training.
 
 ### Blur
 
-The Blur transformation in Albumentations applies a simple blur effect to the image by averaging pixel values within a small square area, or kernel. This is done using OpenCV’s `cv2.blur` function, which helps reduce noise in the image, though it also slightly reduces image details.
+The Blur transformation in Albumentations applies a simple blur effect to the image by averaging pixel values within a small square area, or kernel. This is done using OpenCV's `cv2.blur` function, which helps reduce noise in the image, though it also slightly reduces image details.
 
 Here are the parameters and values used in this integration:
 
 - **blur_limit**: This controls the size range of the blur effect. The default range is (3, 7), meaning the kernel size for the blur can vary between 3 and 7 pixels, with only odd numbers allowed to keep the blur centered.
 
-- **p**: The probability of applying the blur. In the integration, p=0.01, so there’s a 1% chance that this blur will be applied to each image. The low probability allows for occasional blur effects, introducing a bit of variation to help the model generalize without over-blurring the images.
+- **p**: The probability of applying the blur. In the integration, p=0.01, so there's a 1% chance that this blur will be applied to each image. The low probability allows for occasional blur effects, introducing a bit of variation to help the model generalize without over-blurring the images.
 
 <img width="776" alt="An Example of the Blur Augmentation" src="https://github.com/ultralytics/docs/releases/download/0/albumentations-blur.avif">
 
@@ -117,7 +117,7 @@ The ToGray transformation in Albumentations converts an image to grayscale, redu
 
 Here are the parameters and values used in this integration:
 
-- **num_output_channels**: Sets the number of channels in the output image. If this value is more than 1, the single grayscale channel will be replicated to create a multi-channel grayscale image. By default, it’s set to 3, giving a grayscale image with three identical channels.
+- **num_output_channels**: Sets the number of channels in the output image. If this value is more than 1, the single grayscale channel will be replicated to create a multi-channel grayscale image. By default, it's set to 3, giving a grayscale image with three identical channels.
 
 - **method**: Defines the grayscale conversion method. The default method, "weighted_average", applies a formula (0.299R + 0.587G + 0.114B) that closely aligns with human perception, providing a natural-looking grayscale effect. Other options, like "from_lab", "desaturation", "average", "max", and "pca", offer alternative ways to create grayscale images based on various needs for speed, brightness emphasis, or detail preservation.
 

docs/en/reference/cfg/__init__.md

@@ -47,6 +47,10 @@ keywords: Ultralytics, YOLO, configuration, cfg2dict, get_cfg, check_cfg, save_d
 
 <br><br><hr><br>
 
+## ::: ultralytics.cfg.handle_yolo_solutions
+
+<br><br><hr><br>
+
 ## ::: ultralytics.cfg.handle_streamlit_inference
 
 <br><br><hr><br>

docs/en/solutions/index.md

@@ -14,21 +14,39 @@ Ultralytics Solutions provide cutting-edge applications of YOLO models, offering
 
 Here's our curated list of Ultralytics solutions that can be used to create awesome [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) projects.
 
-- [Object Counting](../guides/object-counting.md) 🚀 NEW: Learn to perform real-time object counting with YOLO11. Gain the expertise to accurately count objects in live video streams.
-- [Object Cropping](../guides/object-cropping.md) 🚀 NEW: Master object cropping with YOLO11 for precise extraction of objects from images and videos.
-- [Object Blurring](../guides/object-blurring.md) 🚀 NEW: Apply object blurring using YOLO11 to protect privacy in image and video processing.
-- [Workouts Monitoring](../guides/workouts-monitoring.md) 🚀 NEW: Discover how to monitor workouts using YOLO11. Learn to track and analyze various fitness routines in real time.
-- [Objects Counting in Regions](../guides/region-counting.md) 🚀 NEW: Count objects in specific regions using YOLO11 for accurate detection in varied areas.
-- [Security Alarm System](../guides/security-alarm-system.md) 🚀 NEW: Create a security alarm system with YOLO11 that triggers alerts upon detecting new objects. Customize the system to fit your specific needs.
-- [Heatmaps](../guides/heatmaps.md) 🚀 NEW: Utilize detection heatmaps to visualize data intensity across a matrix, providing clear insights in computer vision tasks.
+- [Object Counting](../guides/object-counting.md) 🚀: Learn to perform real-time object counting with YOLO11. Gain the expertise to accurately count objects in live video streams.
+- [Object Cropping](../guides/object-cropping.md) 🚀: Master object cropping with YOLO11 for precise extraction of objects from images and videos.
+- [Object Blurring](../guides/object-blurring.md) 🚀: Apply object blurring using YOLO11 to protect privacy in image and video processing.
+- [Workouts Monitoring](../guides/workouts-monitoring.md) 🚀: Discover how to monitor workouts using YOLO11. Learn to track and analyze various fitness routines in real time.
+- [Objects Counting in Regions](../guides/region-counting.md) 🚀: Count objects in specific regions using YOLO11 for accurate detection in varied areas.
+- [Security Alarm System](../guides/security-alarm-system.md) 🚀: Create a security alarm system with YOLO11 that triggers alerts upon detecting new objects. Customize the system to fit your specific needs.
+- [Heatmaps](../guides/heatmaps.md) 🚀: Utilize detection heatmaps to visualize data intensity across a matrix, providing clear insights in computer vision tasks.
 - [Instance Segmentation with Object Tracking](../guides/instance-segmentation-and-tracking.md) 🚀 NEW: Implement [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) and object tracking with YOLO11 to achieve precise object boundaries and continuous monitoring.
-- [VisionEye View Objects Mapping](../guides/vision-eye.md) 🚀 NEW: Develop systems that mimic human eye focus on specific objects, enhancing the computer's ability to discern and prioritize details.
-- [Speed Estimation](../guides/speed-estimation.md) 🚀 NEW: Estimate object speed using YOLO11 and object tracking techniques, crucial for applications like autonomous vehicles and traffic monitoring.
-- [Distance Calculation](../guides/distance-calculation.md) 🚀 NEW: Calculate distances between objects using [bounding box](https://www.ultralytics.com/glossary/bounding-box) centroids in YOLO11, essential for spatial analysis.
-- [Queue Management](../guides/queue-management.md) 🚀 NEW: Implement efficient queue management systems to minimize wait times and improve productivity using YOLO11.
-- [Parking Management](../guides/parking-management.md) 🚀 NEW: Organize and direct vehicle flow in parking areas with YOLO11, optimizing space utilization and user experience.
+- [VisionEye View Objects Mapping](../guides/vision-eye.md) 🚀: Develop systems that mimic human eye focus on specific objects, enhancing the computer's ability to discern and prioritize details.
+- [Speed Estimation](../guides/speed-estimation.md) 🚀: Estimate object speed using YOLO11 and object tracking techniques, crucial for applications like autonomous vehicles and traffic monitoring.
+- [Distance Calculation](../guides/distance-calculation.md) 🚀: Calculate distances between objects using [bounding box](https://www.ultralytics.com/glossary/bounding-box) centroids in YOLO11, essential for spatial analysis.
+- [Queue Management](../guides/queue-management.md) 🚀: Implement efficient queue management systems to minimize wait times and improve productivity using YOLO11.
+- [Parking Management](../guides/parking-management.md) 🚀: Organize and direct vehicle flow in parking areas with YOLO11, optimizing space utilization and user experience.
 - [Analytics](../guides/analytics.md) 📊 NEW: Conduct comprehensive data analysis to discover patterns and make informed decisions, leveraging YOLO11 for descriptive, predictive, and prescriptive analytics.
-- [Live Inference with Streamlit](../guides/streamlit-live-inference.md) 🚀 NEW: Leverage the power of YOLO11 for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) directly through your web browser with a user-friendly Streamlit interface.
+- [Live Inference with Streamlit](../guides/streamlit-live-inference.md) 🚀: Leverage the power of YOLO11 for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) directly through your web browser with a user-friendly Streamlit interface.
+
+## Solutions Usage
+
+!!! tip "Command Info"
+
+    `yolo SOLUTIONS SOLUTION_NAME ARGS`
+
+    - **SOLUTIONS** is a required keyword.
+    - **SOLUTION_NAME** (optional) is one of: `['count', 'heatmap', 'queue', 'speed', 'workout', 'analytics']`.
+    - **ARGS** (optional) are custom `arg=value` pairs, such as `show_in=True`, to override default settings.
+
+    === "CLI"
+
+        ```bash
+        yolo solutions count show=True  # for object counting
+
+        yolo solutions source="path/to/video/file.mp4"  # specify video file path
+        ```
 
 ## Contribute to Our Solutions
 

docs/mkdocs_github_authors.yaml

@@ -25,6 +25,9 @@
 17316848+maianumerosky@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/17316848?v=4
   username: maianumerosky
+25704330+JairajJangle@users.noreply.github.com:
+  avatar: https://avatars.githubusercontent.com/u/25704330?v=4
+  username: JairajJangle
 32206511+Y-T-G@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/32206511?v=4
   username: Y-T-G
@@ -40,6 +43,9 @@
 40165666+berry-ding@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/40165666?v=4
   username: berry-ding
+44016758+M-Amrollahi@users.noreply.github.com:
+  avatar: https://avatars.githubusercontent.com/u/44016758?v=4
+  username: M-Amrollahi
 46103969+inisis@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/46103969?v=4
   username: inisis
@@ -76,6 +82,9 @@
 79740115+0xSynapse@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/79740115?v=4
   username: 0xSynapse
+8401806+wangzhaode@users.noreply.github.com:
+  avatar: https://avatars.githubusercontent.com/u/8401806?v=4
+  username: wangzhaode
 91465467+lalayants@users.noreply.github.com:
   avatar: https://avatars.githubusercontent.com/u/91465467?v=4
   username: lalayants
@@ -97,6 +106,9 @@ ayush.chaurarsia@gmail.com:
 chr043416@gmail.com:
   avatar: https://avatars.githubusercontent.com/u/62513924?v=4
   username: RizwanMunawar
+davis.justin@mssm.org:
+  avatar: https://avatars.githubusercontent.com/u/23462437?v=4
+  username: justincdavis
 glenn.jocher@ultralytics.com:
   avatar: https://avatars.githubusercontent.com/u/26833433?v=4
   username: glenn-jocher
@@ -157,9 +169,3 @@ xinwang614@gmail.com:
 zhaode.wzd@alibaba-inc.com:
   avatar: https://avatars.githubusercontent.com/u/8401806?v=4
   username: wangzhaode
-8401806+wangzhaode@users.noreply.github.com:
-  avatar: https://avatars.githubusercontent.com/u/8401806?v=4
-  username: wangzhaode
-davis.justin@mssm.org:
-  avatar: https://avatars.githubusercontent.com/u/23462437?v=4
-  username: justincdavis

ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-__version__ = "8.3.27"
+__version__ = "8.3.28"
 
 import os
 

ultralytics/cfg/__init__.py

@@ -7,11 +7,15 @@ from pathlib import Path
 from types import SimpleNamespace
 from typing import Dict, List, Union
 
+import cv2
+
 from ultralytics.utils import (
     ASSETS,
+    ASSETS_URL,
     DEFAULT_CFG,
     DEFAULT_CFG_DICT,
     DEFAULT_CFG_PATH,
+    DEFAULT_SOL_DICT,
     IS_VSCODE,
     LOGGER,
     RANK,
@@ -30,6 +34,17 @@ from ultralytics.utils import (
     yaml_print,
 )
 
+# Define valid solutions
+SOLUTION_MAP = {
+    "count": ("ObjectCounter", "count"),
+    "heatmap": ("Heatmap", "generate_heatmap"),
+    "queue": ("QueueManager", "process_queue"),
+    "speed": ("SpeedEstimator", "estimate_speed"),
+    "workout": ("AIGym", "monitor"),
+    "analytics": ("Analytics", "process_data"),
+    "help": None,
+}
+
 # Define valid tasks and modes
 MODES = {"train", "val", "predict", "export", "track", "benchmark"}
 TASKS = {"detect", "segment", "classify", "pose", "obb"}
@@ -57,6 +72,31 @@ TASK2METRIC = {
 MODELS = {TASK2MODEL[task] for task in TASKS}
 
 ARGV = sys.argv or ["", ""]  # sometimes sys.argv = []
+SOLUTIONS_HELP_MSG = f"""
+    Arguments received: {str(['yolo'] + ARGV[1:])}. Ultralytics 'yolo solutions' usage overview:
+
+        yolo SOLUTIONS SOLUTION ARGS
+
+        Where SOLUTIONS (required) is a keyword
+              SOLUTION (optional) is one of {list(SOLUTION_MAP.keys())}
+              ARGS (optional) are any number of custom 'arg=value' pairs like 'show_in=True' that override defaults.
+                See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
+
+    1. Call object counting solution
+        yolo solutions count source="path/to/video/file.mp4" region=[(20, 400), (1080, 404), (1080, 360), (20, 360)]
+
+    2. Call heatmaps solution
+        yolo solutions heatmap colormap=cv2.COLORMAP_PARAULA model=yolo11n.pt
+
+    3. Call queue management solution
+        yolo solutions queue region=[(20, 400), (1080, 404), (1080, 360), (20, 360)] model=yolo11n.pt
+
+    4. Call workouts monitoring solution for push-ups
+        yolo solutions workout model=yolo11n-pose.pt kpts=[6, 8, 10]
+
+    5. Generate analytical graphs
+        yolo solutions analytics analytics_type="pie"
+    """
 CLI_HELP_MSG = f"""
     Arguments received: {str(['yolo'] + ARGV[1:])}. Ultralytics 'yolo' commands use the following syntax:
 
@@ -78,19 +118,24 @@ CLI_HELP_MSG = f"""
 
     4. Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
         yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
-    
+
     5. Streamlit real-time webcam inference GUI
         yolo streamlit-predict
-        
-    6. Run special commands:
+
+    6. Ultralytics solutions usage
+        yolo solutions count or in {list(SOLUTION_MAP.keys())} source="path/to/video/file.mp4"
+
+    7. Run special commands:
         yolo help
         yolo checks
         yolo version
         yolo settings
         yolo copy-cfg
         yolo cfg
+        yolo solutions help
 
     Docs: https://docs.ultralytics.com
+    Solutions: https://docs.ultralytics.com/solutions/
     Community: https://community.ultralytics.com
     GitHub: https://github.com/ultralytics/ultralytics
     """
@@ -576,6 +621,100 @@ def handle_yolo_settings(args: List[str]) -> None:
         LOGGER.warning(f"WARNING ⚠️ settings error: '{e}'. Please see {url} for help.")
 
 
+def handle_yolo_solutions(args: List[str]) -> None:
+    """
+    Processes YOLO solutions arguments and runs the specified computer vision solutions pipeline.
+
+    Args:
+        args (List[str]): Command-line arguments for configuring and running the Ultralytics YOLO
+            solutions: https://docs.ultralytics.com/solutions/, It can include solution name, source,
+            and other configuration parameters.
+
+    Returns:
+        None: The function processes video frames and saves the output but doesn't return any value.
+
+    Examples:
+        Run people counting solution with default settings:
+        >>> handle_yolo_solutions(["count"])
+
+        Run analytics with custom configuration:
+        >>> handle_yolo_solutions(["analytics", "conf=0.25", "source=path/to/video/file.mp4"])
+
+    Notes:
+        - Default configurations are merged from DEFAULT_SOL_DICT and DEFAULT_CFG_DICT
+        - Arguments can be provided in the format 'key=value' or as boolean flags
+        - Available solutions are defined in SOLUTION_MAP with their respective classes and methods
+        - If an invalid solution is provided, defaults to 'count' solution
+        - Output videos are saved in 'runs/solution/{solution_name}' directory
+        - For 'analytics' solution, frame numbers are tracked for generating analytical graphs
+        - Video processing can be interrupted by pressing 'q'
+        - Processes video frames sequentially and saves output in .avi format
+        - If no source is specified, downloads and uses a default sample video
+    """
+    full_args_dict = {**DEFAULT_SOL_DICT, **DEFAULT_CFG_DICT}  # arguments dictionary
+    overrides = {}
+
+    # check dictionary alignment
+    for arg in merge_equals_args(args):
+        arg = arg.lstrip("-").rstrip(",")
+        if "=" in arg:
+            try:
+                k, v = parse_key_value_pair(arg)
+                overrides[k] = v
+            except (NameError, SyntaxError, ValueError, AssertionError) as e:
+                check_dict_alignment(full_args_dict, {arg: ""}, e)
+        elif arg in full_args_dict and isinstance(full_args_dict.get(arg), bool):
+            overrides[arg] = True
+    check_dict_alignment(full_args_dict, overrides)  # dict alignment
+
+    # Get solution name
+    if args and args[0] in SOLUTION_MAP:
+        if args[0] != "help":
+            s_n = args.pop(0)  # Extract the solution name directly
+        else:
+            LOGGER.info(SOLUTIONS_HELP_MSG)
+    else:
+        LOGGER.warning(
+            f"⚠️ No valid solution provided. Using default 'count'. Available: {', '.join(SOLUTION_MAP.keys())}"
+        )
+        s_n = "count"  # Default solution if none provided
+
+    cls, method = SOLUTION_MAP[s_n]  # solution class name, method name and default source
+
+    from ultralytics import solutions  # import ultralytics solutions
+
+    solution = getattr(solutions, cls)(IS_CLI=True, **overrides)  # get solution class i.e ObjectCounter
+    process = getattr(solution, method)  # get specific function of class for processing i.e, count from ObjectCounter
+
+    cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
+
+    # extract width, height and fps of the video file, create save directory and initialize video writer
+    import os  # for directory creation
+    from pathlib import Path
+
+    from ultralytics.utils.files import increment_path  # for output directory path update
+
+    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+    if s_n == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
+        w, h = 1920, 1080
+    save_dir = increment_path(Path("runs") / "solutions" / "exp", exist_ok=False)
+    save_dir.mkdir(parents=True, exist_ok=True)  # create the output directory
+    vw = cv2.VideoWriter(os.path.join(save_dir, "solution.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+
+    try:  # Process video frames
+        f_n = 0  # frame number, required for analytical graphs
+        while cap.isOpened():
+            success, frame = cap.read()
+            if not success:
+                break
+            frame = process(frame, f_n := f_n + 1) if s_n == "analytics" else process(frame)
+            vw.write(frame)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                break
+    finally:
+        cap.release()
+
+
 def handle_streamlit_inference():
     """
     Open the Ultralytics Live Inference Streamlit app for real-time object detection.
@@ -717,6 +856,7 @@ def entrypoint(debug=""):
         "logout": lambda: handle_yolo_hub(args),
         "copy-cfg": copy_default_cfg,
         "streamlit-predict": lambda: handle_streamlit_inference(),
+        "solutions": lambda: handle_yolo_solutions(args[1:]),
     }
     full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
 

ultralytics/engine/exporter.py

@@ -227,7 +227,7 @@ class Exporter:
             assert not ncnn, "optimize=True not compatible with format='ncnn', i.e. use optimize=False"
             assert self.device.type == "cpu", "optimize=True not compatible with cuda devices, i.e. use device='cpu'"
         if self.args.int8 and tflite:
-            assert not model.end2end, "TFLite INT8 export not supported for end2end models, please use half precision."
+            assert not getattr(model, "end2end", False), "TFLite INT8 export not supported for end2end models."
         if edgetpu:
             if not LINUX:
                 raise SystemError("Edge TPU export only supported on Linux. See https://coral.ai/docs/edgetpu/compiler")

ultralytics/solutions/ai_gym.py

@@ -19,7 +19,6 @@ class AIGym(BaseSolution):
         up_angle (float): Angle threshold for considering the 'up' position of an exercise.
         down_angle (float): Angle threshold for considering the 'down' position of an exercise.
         kpts (List[int]): Indices of keypoints used for angle calculation.
-        lw (int): Line width for drawing annotations.
         annotator (Annotator): Object for drawing annotations on the image.
 
     Methods:
@@ -51,7 +50,6 @@ class AIGym(BaseSolution):
         self.up_angle = float(self.CFG["up_angle"])  # Pose up predefined angle to consider up pose
         self.down_angle = float(self.CFG["down_angle"])  # Pose down predefined angle to consider down pose
         self.kpts = self.CFG["kpts"]  # User selected kpts of workouts storage for further usage
-        self.lw = self.CFG["line_width"]  # Store line_width for usage
 
     def monitor(self, im0):
         """
@@ -84,14 +82,14 @@ class AIGym(BaseSolution):
                 self.stage += ["-"] * new_human
 
             # Initialize annotator
-            self.annotator = Annotator(im0, line_width=self.lw)
+            self.annotator = Annotator(im0, line_width=self.line_width)
 
             # Enumerate over keypoints
             for ind, k in enumerate(reversed(tracks.keypoints.data)):
                 # Get keypoints and estimate the angle
                 kpts = [k[int(self.kpts[i])].cpu() for i in range(3)]
                 self.angle[ind] = self.annotator.estimate_pose_angle(*kpts)
-                im0 = self.annotator.draw_specific_points(k, self.kpts, radius=self.lw * 3)
+                im0 = self.annotator.draw_specific_points(k, self.kpts, radius=self.line_width * 3)
 
                 # Determine stage and count logic based on angle thresholds
                 if self.angle[ind] < self.down_angle:

ultralytics/solutions/solutions.py

@@ -5,7 +5,7 @@ from collections import defaultdict
 import cv2
 
 from ultralytics import YOLO
-from ultralytics.utils import DEFAULT_CFG_DICT, DEFAULT_SOL_DICT, LOGGER
+from ultralytics.utils import ASSETS_URL, DEFAULT_CFG_DICT, DEFAULT_SOL_DICT, LOGGER
 from ultralytics.utils.checks import check_imshow, check_requirements
 
 
@@ -42,8 +42,12 @@ class BaseSolution:
         >>> solution.display_output(image)
     """
 
-    def __init__(self, **kwargs):
-        """Initializes the BaseSolution class with configuration settings and YOLO model for Ultralytics solutions."""
+    def __init__(self, IS_CLI=False, **kwargs):
+        """
+        Initializes the `BaseSolution` class with configuration settings and the YOLO model for Ultralytics solutions.
+
+        IS_CLI (optional): Enables CLI mode if set.
+        """
         check_requirements("shapely>=2.0.0")
         from shapely.geometry import LineString, Point, Polygon
 
@@ -63,9 +67,20 @@ class BaseSolution:
         )  # Store line_width for usage
 
         # Load Model and store classes names
-        self.model = YOLO(self.CFG["model"] if self.CFG["model"] else "yolov8n.pt")
+        if self.CFG["model"] is None:
+            self.CFG["model"] = "yolo11n.pt"
+        self.model = YOLO(self.CFG["model"])
         self.names = self.model.names
 
+        if IS_CLI:  # for CLI, download the source and init video writer
+            if self.CFG["source"] is None:
+                d_s = "solutions_ci_demo.mp4" if "-pose" not in self.CFG["model"] else "solution_ci_pose_demo.mp4"
+                LOGGER.warning(f"⚠️ WARNING: source not provided. using default source {ASSETS_URL}/{d_s}")
+                from ultralytics.utils.downloads import safe_download
+
+                safe_download(f"{ASSETS_URL}/{d_s}")  # download source from ultralytics assets
+                self.CFG["source"] = d_s  # set default source
+
         # Initialize environment and region setup
         self.env_check = check_imshow(warn=True)
         self.track_history = defaultdict(list)

ultralytics/utils/__init__.py

@@ -37,6 +37,7 @@ ARGV = sys.argv or ["", ""]  # sometimes sys.argv = []
 FILE = Path(__file__).resolve()
 ROOT = FILE.parents[1]  # YOLO
 ASSETS = ROOT / "assets"  # default images
+ASSETS_URL = "https://github.com/ultralytics/assets/releases/download/v0.0.0"  # assets GitHub URL
 DEFAULT_CFG_PATH = ROOT / "cfg/default.yaml"
 DEFAULT_SOL_CFG_PATH = ROOT / "cfg/solutions/default.yaml"  # Ultralytics solutions yaml path
 NUM_THREADS = min(8, max(1, os.cpu_count() - 1))  # number of YOLO multiprocessing threads