Image Classification with Ultralytics YOLO

Hey there! 🙌 Thanks for the detailed message.

It seems like you've encountered an interesting scenario with image sizes and the rect=True parameter. In YOLOv8, when using rectangular training (rect=True), the model does expect square input sizes for simplicity and efficiency. The behavior you've noticed, where the smaller dimension gets resized to match the specified imgsz, and then the image is center-cropped, is by design for handling non-square inputs.

For your specific case with rectangular images (1216x292), instead of resizing or padding the images manually to make them square, a recommended approach is to work with the default behavior but ensure your imgsz is set to the dimension that avoids data loss. If further customization is necessary, it might involve custom modifications to the data preprocessing pipeline.

Unfortunately, there isn't a built-in switch for direct handling of non-square images without cropping or resizing as you described. This is an area for potential improvement in future updates!

For now, perhaps consider either adjusting your pipeline to accommodate this behavior or implementing a custom preprocessing step that ensures your images maintain their aspect ratio without significant data loss. Padding might be an unavoidable step for cases like these.

If there's anything else we can help with or if you have suggestions, feel free to reach out. Thanks for diving deep into this, and we're here to support your projects! 🚀

Yes, Ultralytics YOLO26 classification can work for coal moisture levels if you label them as discrete classes like dry, medium, and wet and train with the standard classification dataset format; if you need an exact moisture percentage rather than bins, that’s a regression problem, and if the visual differences are subtle you may need NIR/thermal imaging instead of RGB alone.

Thanks, I think classification is enough because we just need high level of coal moisture not exact percentage.

Yes, that should be a good fit for classify; use a few clear bins like low, medium, and high, keep lighting/camera distance as consistent as possible, and start from a pretrained yolo26n-cls.pt model—if you’d like, share a sample class layout or training command here and we can sanity-check it.

Thank you very much, that makes sense. I just start project and not go to training phase yet, but I am happy to share sample and training command once I have to get more help on this.

Sounds good—when you reach training, share your dataset folder structure and exact yolo classify train ... command here, and we’ll help sanity-check it against the classification guide.

Thank you! I got another question related to segment, hopefully I can get your suggestion as well, it is a little bit tricky :-). The coal is very small ( around 10mm one piece), but we have identify them in a truck (10m*3m) in order to ensure the truck carry right size of coal, one picture for one truck, it means there are huge member of small coal in one picture, I don't have image resolution yet, but I suppose it is clear enough to show details for each coal, my questions are

1. how to label data before training, I can use SAM to label each coal but I have to say it is impossible to label all coal in picture because the coal member is huge, if I can just label some of them in pictures? I think we can use around 300 pictures to start training, but not all coal labeled in one picture. Does it will impact accuracy of model?
2. Is it possible for Yolo26-segment to identify each coal in this situation from algorithm and performance point of view? In one picture, the truck is big but carry large member of similar small objects (10mm vs. 10m). Any solution we can take for this situation?

Apricate for any suggestions...

Yes, but you should not leave visible coals unlabeled in training images because the model will treat them as background and recall will drop; for this kind of dense small-object problem, the practical approach is to split each truck image into smaller overlapping tiles, fully annotate every visible coal inside the selected tiles, and train on those crops rather than the full frame. If each coal is still only a few pixels after tiling, segment will struggle and detect or even patch-level classify may be a better fit, and our data collection and annotation guide is a good reference—feel free to post one sample image here when you have it and we can suggest the best labeling strategy.

分类任务里类别索引顺序是从你的数据集目录结构推断出来的（通常按 train/ 下各类别子文件夹名称排序生成），如果你想“指定顺序”，最稳妥的方法是把类别文件夹命名成可排序的形式（例如 00_cat/、01_dog/）；训练完成后直接读取模型里的 model.names 就能看到标签到索引的对应关系，参考 图像分类文档。

from ultralytics import YOLO

model = YOLO("runs/classify/train/weights/best.pt")
print(model.names)  # {0: '00_cat', 1: '01_dog', ...}

For classify, auto_augment can be used together with other augmentation args like scale and hsv_h/hsv_s/hsv_v (they target different parts of the classification transform pipeline), but since policies like randaugment are already quite strong you’ll usually want to keep extra color jitter mild and tune one knob at a time; see the Image Classification docs and the classification transforms/augmentations reference.

Also note close_mosaic is a mosaic-specific setting for detection-style tasks and isn’t used for *-cls training, so it won’t affect YOLO classification; if you meant detection, close_mosaic=5 disables mosaic only for the last 5 scheduled epochs (i.e., starting at epochs - close_mosaic), so if early stopping ends at epoch 20/50 that “close mosaic” switch never occurs.

Hello @glenn-jocher, Thank you for your previous reply, it was very helpful. I have another question related to class imbalance in computer vision tasks. In many ML setups, when classes are imbalanced, we apply per-class loss weights so that rare classes contribute more to the overall training loss and are not ignored during optimization.

For example, if I have 3 detection classes with instance counts like:

class0 = 30 instances class1 = 500 instances class2 = 700 instances

By default, all classes contribute equally (weight = 1), but ideally I’d like to assign a higher weight to the rare class (class0).

My question: Is there a supported way in Ultralytics YOLO to apply per-class weights for the detection classification loss or bounding boxes loss (cls loss component)? If yes, where can I access and modify those weights?? Thank you in advance!

At the moment Ultralytics YOLO doesn’t have a supported “per-class loss weight” hook for detection via data.yaml/CLI (for cls_loss or box losses); the only built-in knobs are the overall loss term weights like cls, box, and dfl in the configuration settings. If you need true per-class weighting you’ll have to implement it in a custom trainer/loss (the core detection loss lives in the loss implementation and can be swapped via the advanced customization guide); otherwise the practical workaround is to rebalance the dataset by oversampling/adding/augmenting the rare-class examples.

Hi Ultralytics team, YOLO-classify always outputs class probabilities (probs) that sum to 1, even for completely unknown or out-of-distribution (OOD) inputs. As a result, unknown objects can be classified with high confidence (e.g., 0.8), and using a threshold does not always filter them. Are there any recommended strategies, best practices, or built-in options to reduce false high-confidence predictions on unknown data?
Would combining classify with detect help in such cases? Thanks!

You’re right: *-cls uses a softmax-style head, so the returned probs are normalized to sum to 1 by design, which means “unknown/OOD” will still get forced into a known class with some confidence; there isn’t a built-in OOD/reject option in Ultralytics YOLO classification today (beyond simple thresholding). A practical approach is to (a) add an explicit unknown (or “background”) class with diverse negative examples and train for rejection, and/or (b) run a detection model first and only classify detected crops—if nothing is detected you can safely treat the frame as unknown; see the Ultralytics YOLO image classification docs for the standard classify pipeline.

If you want a lightweight post-process, you can gate predictions using max-softmax and an uncertainty score like entropy (often works better than max-prob alone):

from ultralytics import YOLO
import torch

model = YOLO("yolo26n-cls.pt")
results = model("path/to/img.jpg")

r = results[0]
p = r.probs.data  # class probabilities (tensor)
max_p = float(p.max())
entropy = float(-(p * (p + 1e-12).log()).sum())

is_unknown = (max_p < 0.6) or (entropy > 2.5)  # tune on a held-out OOD set