开始使用

使用 Ultralytics YOLO 进行图像分类

Ultralytics YOLO image classification of leaves as healthy, rust, or powdery mildew

图像分类是受支持任务中最简单的一种,它会将整张图像分类为一组预定义类别中的一个。

图像分类器的输出是单个类别标签和置信度分数。如果你只需要知道图像属于哪个类别,而不需要知道该类别对象的位置或确切形状,那么图像分类就很有用。



观看: 探索 Ultralytics YOLO 任务:使用 Ultralytics Platform 进行图像分类
提示

YOLO26 Classify 模型使用后缀 -cls,例如 yolo26n-cls.pt,并使用 ImageNet 进行预训练。

模型#

下方展示了在 ImageNet 数据集上预训练的 YOLO26 Classify 模型。

首次使用时,模型会自动从 Ultralytics 最新版本下载。

模型尺寸
(像素)
acc
top1
acc
top5
速度
CPU ONNX
(毫秒)
速度
T4 TensorRT10
(ms)
参数
(M)
FLOPs
(B),输入尺寸为 224
YOLO26n-cls22471.490.15.0 ± 0.31.1 ± 0.02.80.4
YOLO26s-cls22476.092.97.9 ± 0.21.3 ± 0.06.71.5
YOLO26m-cls22478.194.217.2 ± 0.42.0 ± 0.011.64.8
YOLO26l-cls22479.094.623.2 ± 0.32.8 ± 0.014.16.0
YOLO26x-cls22479.995.041.4 ± 0.93.8 ± 0.029.613.5
  • acc 数值表示模型在 ImageNet 数据集验证集上的准确率。
    使用 yolo classify val data=path/to/ImageNet device=0 复现
  • 速度是在 CPU 上使用 ONNX、在 NVIDIA T4 GPU 上使用 TensorRT10,对 ImageNet 验证集图像进行测量并取平均所得。
    使用 yolo classify val data=path/to/ImageNet batch=1 device=0|cpu 复现
  • 参数量和 FLOPs 数值对应于经过 model.fuse() 融合后的模型,该操作会合并 Conv 和 BatchNorm 层。预训练检查点保留完整的训练架构,因此显示的计数可能更高。

请参阅尚未发布的 YOLO27 预览版,了解初步的分类速度和模型尺寸。

训练#

在 MNIST160 数据集上以 64 的图像尺寸训练一个 YOLO26n-cls 模型,训练 100 个周期。

示例
from ultralytics import YOLO

# 加载模型
model = YOLO("yolo26n-cls.yaml")  # 从 YAML 构建新模型
model = YOLO("yolo26n-cls.pt")  # 加载预训练模型(推荐用于训练)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # 从 YAML 构建模型并迁移权重

# 训练模型
results = model.train(data="mnist160", epochs=100, imgsz=64)

如需了解 train 模式的完整详情,请参阅训练页面。你也可以使用 Ultralytics Platform 云训练来训练分类模型。

数据集格式#

数据集指南详细介绍了 YOLO 分类数据集格式。你也可以使用 Ultralytics Platform 标注工具管理和标注分类数据集。

自定义变换#

Ultralytics YOLO 分类任务在训练时使用 torchvision.transforms.RandomResizedCrop,在验证和推理时使用 torchvision.transforms.CenterCrop。 这些基于裁剪的变换假设输入图像为正方形,因此处理纵横比极端的图像时可能会裁掉重要区域。为了在不拉伸图像的情况下保留整张图像,请将裁剪变换替换为现有的 ClassifyLetterBox 变换;它会缩放每张图像,使其适配 imgsz × imgsz,并在保持纵横比的同时填充剩余区域。通过自定义的 ClassificationDataset、ClassificationTrainer 和 ClassificationValidator,在基于 PIL 的 torchvision 流水线中使用该变换:

import numpy as np
import torch
import torchvision.transforms as T

from ultralytics import YOLO
from ultralytics.data.augment import ClassifyLetterBox
from ultralytics.data.dataset import ClassificationDataset
from ultralytics.models.yolo.classify import ClassificationTrainer, ClassificationValidator

class CustomizedDataset(ClassificationDataset):
    """A customized dataset class for image classification with enhanced data augmentation transforms."""

    def __init__(self, root: str, args, augment: bool = False, prefix: str = "", names=None):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix, names)
        letterbox = T.Compose([np.asarray, ClassifyLetterBox(args.imgsz), T.ToPILImage()])

        # 在此处添加自定义训练变换
        train_transforms = T.Compose(
            [
                letterbox,
                T.RandomHorizontalFlip(p=args.fliplr),
                T.RandomVerticalFlip(p=args.flipud),
                T.RandAugment(interpolation=T.InterpolationMode.BILINEAR),
                T.ColorJitter(brightness=args.hsv_v, contrast=args.hsv_v, saturation=args.hsv_s, hue=args.hsv_h),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
                T.RandomErasing(p=args.erasing, inplace=True),
            ]
        )

        # 在此处添加自定义验证变换
        val_transforms = T.Compose(
            [
                letterbox,
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
            ]
        )
        self.torch_transforms = train_transforms if augment else val_transforms

class CustomizedTrainer(ClassificationTrainer):
    """A customized trainer class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str, mode: str = "train", batch=None):
        """Build a customized dataset for classification training and the validation during training."""
        return CustomizedDataset(
            root=img_path,
            args=self.args,
            augment=mode == "train",
            prefix="train" if mode == "train" else self.args.split,
            names=self.data["names"],
        )

class CustomizedValidator(ClassificationValidator):
    """A customized validator class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str):
        """Build a customized dataset for classification standalone validation (no augmentation)."""
        return CustomizedDataset(root=img_path, args=self.args, augment=False, prefix=self.args.split, names=self.names)

model = YOLO("yolo26n-cls.pt")
model.train(data="imagenet", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet", validator=CustomizedValidator, imgsz=224, batch=64)

验证#

验证训练好的 YOLO26n-cls 模型的准确度。无需提供参数,因为 model 会将训练时的 data 和参数保留为模型属性:来自训练示例的 path/to/best.pt 会在 MNIST160 上进行验证。官方权重记录的训练数据集路径在你的计算机上不存在,因此会发出警告并回退到任务默认值 imagenet10。传入 data 可在其他数据集上验证。

示例
from ultralytics import YOLO

# 加载模型
model = YOLO("yolo26n-cls.pt")  # 加载官方模型
model = YOLO("path/to/best.pt")  # 加载自定义模型

# 验证模型
metrics = model.val()  # 无需参数,数据集和设置会自动记住
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy
提示

使用自定义变换训练的模型需要向 val() 传入匹配的 ClassificationValidator,否则验证时会裁剪图像,而训练时使用的是缩放。

预测#

使用训练好的 YOLO26n-cls 模型对图像运行预测。

示例
from ultralytics import YOLO

# 加载模型
model = YOLO("yolo26n-cls.pt")  # 加载官方模型
model = YOLO("path/to/best.pt")  # 加载自定义模型

# 使用模型进行预测
results = model("https://ultralytics.com/images/bus.jpg")  # 对图像进行预测

# 访问结果
for result in results:
    top1 = result.probs.top1  # 预测概率最高的类别 ID
    top1_conf = result.probs.top1conf  # 最高预测置信度
    top1_name = result.names[top1]  # 预测概率最高的类别名称

请参阅预测页面,了解完整的 predict 模式详情。

结果输出#

图像分类会为每张图像返回一个 Results 对象。主要预测字段是 result.probs,其中包含类别概率向量和用于获取最高预测结果的辅助方法。

属性类型形状说明
result.probsProbs(C,)类别概率。
result.probs.datatorch.float32(C,)每个类别的概率。
result.probs.top1int()得分最高的类别 ID。
result.probs.top1conftorch.float32()最高置信度。
result.probs.top5list[int](<=5)得分最高的 5 个类别 ID。

如需了解所有任务中特定于任务的 Results 字段,请参阅按任务查看预测结果部分。

导出#

将 YOLO26n-cls 模型导出为 ONNX、CoreML 等其他格式。

示例
from ultralytics import YOLO

# 加载模型
model = YOLO("yolo26n-cls.pt")  # 加载官方模型
model = YOLO("path/to/best.pt")  # 加载自定义模型

# 导出模型
model.export(format="onnx")

下表列出了可用的 YOLO26-cls 导出格式。你可以使用 format 参数导出为任意格式,例如 format='onnx' 或 format='engine'。你可以直接在导出的模型上进行预测或验证,例如 yolo predict model=yolo26n-cls.onnx。导出完成后,系统会显示适用于你的模型的用法示例。

格式format 参数模型元数据参数
PyTorch-yolo26n-cls.pt✅-
TorchScripttorchscriptyolo26n-cls.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-cls.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-cls_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-cls.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-cls.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n-cls.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n-cls_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-cls.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-cls_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n-cls.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n-cls_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n-cls.mnn✅imgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-cls_ncnn_model/✅imgsz, quantize, device
IMX500imxyolo11n_imx_model/✅imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-cls_rknn_model/✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-cls_executorch_model/✅imgsz, quantize, batch, data, fraction, device
Axeleraaxelerayolo26n-cls_axelera_model/✅imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-cls_deepx_model/✅imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-cls_qnn.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n-cls_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n-cls_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n-cls_xilinx_model/✅imgsz, name, quantize, data, fraction, opset, simplify, device
NXPnxpyolo26n-cls_nxp.tflite✅imgsz, quantize, data, fraction, device
ST Edge AIstedgeaiyolo26n-cls_stedgeai.onnx✅imgsz, quantize, data, fraction, opset, simplify, device

nms=None 默认输出原始结果,以便进行外部 NMS(YOLO26 在 Axelera 上保留其无 NMS 检测头)。设置 nms=False 以选择可用的无 NMS 检测头;不支持的格式会回退到其原生输出路径。上方的 nms 条目指出可通过 nms=True 嵌入 NMS 的格式。

请参阅 Export 页面,了解完整的 export 详情。

常见问题#

  • YOLO26 模型(例如 yolo26n-cls.pt)专为高效图像分类而设计。模型会为整张图像分配一个类别标签和置信度分数。如果知道图像所属类别就足够,而不需要了解其中对象的位置或形状,那么这项功能就很有用。

  • 你可以使用 Python 或 CLI 命令训练 YOLO26 模型。例如,要在 MNIST160 数据集上以 64 的图像尺寸训练 yolo26n-cls 模型,共训练 100 个轮次:

    示例
    from ultralytics import YOLO
    
    # 加载模型
    model = YOLO("yolo26n-cls.pt")  # 加载预训练模型(推荐用于训练)
    
    # 训练模型
    results = model.train(data="mnist160", epochs=100, imgsz=64)

    如需了解更多配置选项,请访问配置页面。

  • 你可以在 Ultralytics Platform 上浏览、测试和下载预训练的 YOLO26 分类模型。yolo26n-cls.pt、yolo26s-cls.pt 和 yolo26m-cls.pt 等模型使用 ImageNet 数据集进行预训练,并会在首次使用时自动下载。

  • 要在 MNIST160 之类的数据集上验证训练好的模型的准确率,你可以使用以下 Python 或 CLI 命令:

    示例
    from ultralytics import YOLO
    
    # 加载模型
    model = YOLO("path/to/best.pt")  # 加载训练好的模型
    
    # 验证模型
    metrics = model.val()  # 无需提供参数,使用训练时的数据集和设置
    metrics.top1  # top1 accuracy
    metrics.top5  # top5 accuracy

    如需了解更多信息,请访问 Validate 部分。

  • 你可以使用 Python 或 CLI 命令将训练好的 YOLO26 模型导出为多种格式。例如,要将模型导出为 ONNX 格式:

    示例
    from ultralytics import YOLO
    
    # 加载模型
    model = YOLO("yolo26n-cls.pt")  # 加载训练好的模型
    
    # 将模型导出为 ONNX
    model.export(format="onnx")

    如需了解详细的导出选项,请参阅 Export 页面。

评论207

提出问题、分享结果,或帮助其他人。

  1. hellotenetGitHub

    According to my observation, during the training of YOLO for classification tasks, it randomly selects a portion of data from the test set to evaluate the accuracy of this round. If I want to use all the data in the test set for testing in each epoch and provide top_acc1 and top_acc5, which parameter should I add in the yaml file?

    1
  2. eladoni1GitHub(已编辑)

    Hi there! Quick briefing - the images are of size Width = 1216, Height = 292.

    TL;DR - After debug into train.py & predict.py, realized the images are resized + cropped strangely from what I gathered in the docs/forums, even with specified imgsz and rect=True.

    Full explanation -

    Training was : model.train(data=..., imgsz=1216, rect=True)

    Expectations : Was expecting the dataset images to be resized BY THE LARGER side, so 1216 will remain 1216, and so is the smaller side.

    (Even when I tried to do imgsz as a tuple - (h,w) aka (292,1216), a warning showed up, telling me the imgsz will be automatically selected to 1216, as it should have been an integer.. not a tuple.)

    What actually happened : What happened is the smaller side (height, 292) resized to 1216, then the original, bigger side (width, 1216), was resized to 5063 (same scalar the smaller side was multiplied).

    Meaning, what previously was image of size 1216x292, turned into image of size 5063x1216 (This is due to Resize transformation of pytorch)

    And its not over - the data taken was only the INNER 1216x1216 - less than 1/4 of the actual data.. (This is due to CenterCrop transformation of pytorch)

    So, basically, I am asking - Is there a quote from the docs I have missed that said classify must be square sized? Or is there another way (except from padding to 1216x1216 - adding 924 black pixels to the height), to make classify work with rectangular images?

    Thank you so much, and sorry if I wasnt clear.. hopefully it was.

    1
    1. Glenn JocherUltralytics

      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! 🚀

  3. lixjohnGitHub

    If I can train Yolo-cls mode to identify the level of object moisture content? Such as coal? Thanks.

    1. Glenn JocherUltralytics

      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.

    2. lixjohnGitHub

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

    3. Glenn JocherUltralytics

      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.

    4. lixjohnGitHub

      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.

    5. lixjohnGitHub

      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...

    6. Glenn JocherUltralytics

      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.

  4. jiangshouyeGitHub

    如何指定分类标签的次序呢?训练完成后,如何获得模型里的标签顺序呢?

    1. Glenn JocherUltralytics

      分类任务里类别索引顺序是从你的数据集目录结构推断出来的(通常按 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', ...}
  5. serenamansurGitHub

    hello, hope all is well. @glenn-jocher i would like to ask you few questions

    1- in classification task , when finetuning YOLOv11m-cls, is it enough to set "autoaugment" for data augmentation or i can use it with other augmentation args such as scale, hsv_v, hsv_s ??


    2- i will give you an example on this one, lets say i am training with epoch = 50 with patience = 8 and close_mosaic i set to = 5 and early stopping occured at epoch 20/50.

    Is close_mosaic applied here or is it set from the start that it should be disabled at epoch 45? and if it was disabled before epoch 20, how does this affect the result and validation?

    Thank you in advance!!

    1. Glenn JocherUltralytics

      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.

    2. serenamansurGitHub

      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!

    3. Glenn JocherUltralytics

      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.

    4. maxexplorerGitHub

      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!

    5. Glenn JocherUltralytics

      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
  6. theoderickdayGitHub

    Hi I have a simple bit of code based on your example above and using a model I created myself. It works fine at identifying birds and I get output of the form:-

    0: 640x640 nut_hatch 0.30, house_sparrow 0.18, bluetit 0.17, cat 0.13, robin 0.12, 273.5ms Speed: 29.8ms preprocess, 273.5ms inference, 0.1ms postprocess per image at shape (1, 3, 640, 640) 2025-10-27.jpg

    I use the following lines to pass data from the Raspberry PI camera to the model:-

    frame = picam2.capture_array() results = model(frame)

    what I want to do is extract the probabilities from the results structure so I can save specific images when the prediction is over say 80%

    Any ideas?

  7. wdcs-fenilpatelGitHub

    @glenn-jocher

    I'm encountering a strange and seemingly unpredictable issue during inference with a YOLO classification model (using ultralytics package). The confidence score for every prediction is always exactly 0.5, regardless of the input image.

    All inference results return confidence = 0.5.

    The predicted class index might vary, but the confidence is always 0.5.

    This issue starts unpredictably—everything works fine for a while, then suddenly this behavior appears.

    Sometimes, simply rebooting the system resolves the issue temporarily, but it may reappear.

  8. Ranjith3436GitHub

    I am trying to train classification model. why you prefer you architecture. why don't you move transformer architecture? is it capable than ViT.

  9. wowosoGitHub

    What if we can't obtain metrics such as F1 score, mAP, recall, and precision in image classification tasks?