Model Prediction with Ultralytics YOLO

@Tigores 您好！YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值（而非固定为训练尺寸），更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明，这是预期行为而非异常现象。

@LwpZoe to obtain only the RGB label image without the original image overlay, you can disable the overlay during visualization. Use the plot() method with boxes=False and masks=True to only display the segmentation masks. Alternatively, you can directly access result.masks.data for raw mask data and process it as needed. Refer to the Results section for more details.

Found plot () in yolo-segment-main/ultralytics/engine/results.py, modified content: Def plot ( Self, Conf = True, line_width = None, font_size = None, Font = "Arial.ttf", Pil = False, Img = None, im_gpu = None, kpt_radius = 5, kpt_line = False, Labels = False, Boxes = False, Masks = True, Probs = True, Show = True, Save = True, Filename = 'result', color_mode = "class", ): Make predictions using the command line: Yolo segment predict model = runs/segment/train/weights/best.pt source=yolo-seg-main/datasets/test The result is still the original image overlay mask and box, why? Does changing plot () require retraining to get best.pt in order to predict?

To display only the segmentation mask without overlays, modify the plot() function parameters by setting boxes=False, labels=False, and ensuring masks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.

@Stephen-Hao it sounds like you might be running into memory issues when processing a large number of images. To handle large datasets more efficiently, consider using the stream=True argument in your model.predict() call. This will create a memory-efficient generator of results, reducing the likelihood of your system getting stuck. Additionally, ensure you are using the latest version of the Ultralytics package to benefit from any recent optimizations and bug fixes. If the issue persists, please provide more details about your environment and any error messages you encounter.

Yes, Thank you a lot.

@Stephen-Hao you're welcome! If you're experiencing issues with the model getting stuck while predicting a large number of images, try using the stream=True argument in your model.predict() call. This will help manage memory more efficiently by processing images one at a time instead of loading all at once. Also, ensure you're using the latest version of the Ultralytics package. If the problem persists, please provide more details about your setup and any error messages you encounter.

For clarification my pipeline is currently train> valid with val parameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode

Hey there!

For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the Val mode rather than the Predict mode. The Val mode allows you to validate your model on a dataset and provides comprehensive metrics, including the ones you're interested in. Here's an example on how to do it:

from ultralytics import YOLO

# Assuming 'coco128.yaml' is your dataset configuration file that includes your test data path
# and that 'your_model.pt' is the trained model you want to evaluate
model = YOLO('path/to/your_model.pt')

# Validate the model, this will automatically calculate mAP, IOU, and other metrics
results = model.val(data='path/to/your_dataset_config.yaml')

Remember to adjust 'path/to/your_model.pt' and 'path/to/your_dataset_config.yaml' to the actual paths of your model and dataset configuration file.

In your YAML dataset configuration file, make sure to correctly specify the path to your test images and annotations. This way, YOLOv8 will know how to find your test data and corresponding ground truth for evaluation.

If you have any more questions, feel free to ask. Good luck with your model evaluation! 🚀

To disable printing inference results after running predictions, you can use the verbose=False argument in your predict() function. This will prevent the printout of inference times and detected objects. Here's a quick example on how to do it:

from ultralytics import YOLO

# Load your YOLOv8 model
model = YOLO('yolov8n.pt')  

# Run inference with verbose=False
results = model.predict('path/to/your/image.jpg', verbose=False)

This should keep your console output clean while still performing inference. 😊

Is it the same if I use:

results = model('path/to/your/image.jpg')

just as mentioned in the example in this tutorial.

@GUPABE10 hi there!

Yes, using results = model('path/to/your/image.jpg') is perfectly fine and aligns with the examples provided in the tutorial. This command will run inference on the specified image and return the results as a list of Results objects.

If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the verbose=False argument:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")

# Run inference on an image without printing detailed results
results = model.predict('path/to/your/image.jpg', verbose=False)

This will keep your console output clean while still performing the inference. If you have any more questions or need further assistance, feel free to ask! 😊

What is the difference between model.predict() and model()?

Hi there!

Great question! The difference between model.predict() and model() lies in their usage and flexibility:

1. model.predict():

   • This method is explicitly designed for running predictions and allows you to pass various arguments to customize the inference process.
   • You can specify parameters like save, imgsz, conf, device, and more to control the behavior of the prediction.
   • Example:

     from ultralytics import YOLO
     
     # Load a pretrained YOLOv8n model
     model = YOLO("yolov8n.pt")
     
     # Run inference with custom arguments
     results = model.predict("path/to/image.jpg", save=True, imgsz=320, conf=0.5)

2. model():

   • This is a shorthand method that calls the predict() function internally with default settings.
   • It is useful for quick predictions without needing to specify additional parameters.
   • Example:

     from ultralytics import YOLO
     
     # Load a pretrained YOLOv8n model
     model = YOLO("yolov8n.pt")
     
     # Run inference with default settings
     results = model("path/to/image.jpg")

Both methods will return a list of Results objects, which you can then process as needed. If you need more control over the prediction process, model.predict() is the way to go. For quick and straightforward predictions, model() is convenient.

Feel free to check out the Ultralytics documentation on prediction for more details and examples.

Happy coding! 😊

Yes—vid_stride (frame skipping) and imgsz (inference resize) are independent, so you can use them together on video sources; imgsz will be applied to the frames that are actually processed (see the Predict mode inference arguments).

yolo predict model=yolo26n.pt source=video.mp4 vid_stride=2 imgsz=640

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True):
    pass

Thank you for your help. I have another question: if I don’t define imgsz in predict, will it resize the image to 640 by default? I have multiple inputs with different resolutions, so I can’t specify a single value for imgsz in .predict or even during ONNX export, because sometimes the input resolution is larger than imgsz.

Yes—if you don’t pass imgsz to predict(), it uses the default imgsz=640 and will letterbox/resize each frame/image to that inference size (so larger inputs are downscaled, smaller are upscaled); for mixed-resolution sources you can either leave the default or set a larger imgsz for more detail (GPU memory permitting) as described in the predict settings defaults.

If you need an ONNX that can accept varying input shapes at runtime, export with dynamic shapes enabled (then your runtime can feed different H×W sizes):

yolo export model=yolo26n.pt format=onnx dynamic=True

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Feel free to drop the exact input resolutions (and whether this is video-only) here in the discussion and we can suggest a good imgsz strategy for your case.

Thank you so much ,but for tensorRT export , the model can't accept varying input shapes and i was obliged to put imgsz or my videos have different resolutions and i can't put one imgsz value that can fit all the resolutions. Is there any other solution?

Yes—TensorRT doesn’t have to be fixed-shape: export your .engine with dynamic=True so the runtime can accept varying input shapes (you can then choose imgsz per run/video), see the Export mode docs and the TensorRT integration guide.

yolo export model=yolo26n.pt format=engine dynamic=True

If you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common imgsz values and selecting the closest one at runtime.

SAHI’s built-in Ultralytics integration (model_type="ultralytics") currently expects PyTorch weights like *.pt, so a TensorRT *.engine file won’t load through SAHI as-is; the supported path is to use SAHI with *.pt per the SAHI tiled inference guide, or run the TensorRT engine directly with Ultralytics per the TensorRT export/inference guide. If you specifically need SAHI slicing + a *.engine, you’ll need a custom SAHI DetectionModel adapter around Ultralytics’ TensorRT predictor (best tracked upstream in the SAHI repository); please paste your Ultralytics/SAHI versions and a minimal repro here in the discussion so we can advise on the cleanest adapter approach.

# SAHI (supported): Ultralytics *.pt + slicing
from sahi import AutoDetectionModel
from sahi.predict import get_sliced_prediction

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model_path="best.pt",
    confidence_threshold=0.25,
    device="cuda:0",
)

result = get_sliced_prediction(
    "large.jpg",
    detection_model,
    slice_height=640,
    slice_width=640,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)

# TensorRT (supported): Ultralytics *.engine inference (no SAHI wrapper)
from ultralytics import YOLO

model = YOLO("best.engine")
results = model.predict("large.jpg", device=0, imgsz=640)

For workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing imgsz for better person discrimination), but the most reliable fix is fine-tuning on your own workshop data with “hard negative” images (frames with vehicles/hoists but no people) so the model learns your background; see the inference args in the predict mode docs.

yolo pose predict model=yolo11n-pose.pt source=path/to/video.mp4 conf=0.6 imgsz=960

If you paste your exact command, plus a couple representative frames (people + false positives) here in the discussion, we can suggest tighter settings or a training setup (and for new work, try a YOLO26 pose checkpoint as it’s generally stronger out of the box).