Best Image Classification Models: How to Choose

There is no single best image classification model. The right one depends on how much labeled data you have, where the model has to run, and whether you can use its license. In 2026, accuracy-first work centers on large transformer and self-supervised backbones such as DINOv3 and EVA-02. For deployment on limited hardware, smaller, mostly convolutional models such as ConvNeXt V2, EfficientNetV2, MobileNetV4 and Ultralytics YOLO26-cls are often more practical, depending on checkpoint size, training setup and target hardware. Compare their accuracy and latency on your own workload. This guide explains the four model families, compares ten widely used models, and gives a decision path for choosing one.

If you're new to the task itself, start with what image classification is. This page is about choosing a model.

Fig 1. Image classification returns one label for the whole image, with a probability for each class: retail, logistics, healthcare and agriculture examples. Top-3 predictions from Ultralytics YOLO26x-cls, pretrained on the 1,000 ImageNet classes. The photos were generated for this article; the predictions are real model outputs.

What "best" means for an image classification model#

Leaderboards rank models by top-1 accuracy on the ImageNet validation set. That number is useful, but it's measured at a fixed resolution, on one dataset, often with very large pretraining behind it. Four other factors usually decide a real project:

• Data. How many labeled images you have per class, and how close they are to the pretraining data.
• Compute and latency. Whether inference runs on a data-center GPU, a CPU, or a phone or camera NPU.
• Deployment path. Whether the model exports cleanly to the runtime you need, such as ONNX, TensorRT, Core ML or TFLite.
• License. Whether the code and, separately, the pretrained weights allow your use.

A model a few points lower on ImageNet that fine-tunes well on your images and runs in real time on your hardware is usually the better choice.

The four families of image classification models#

Convolutional neural networks (CNNs)#

CNNs slide learned filters across the image, so they assume that nearby pixels are related. That built-in assumption (an inductive bias) lets them learn well from small and mid-sized datasets and run efficiently on modest hardware. ResNet and EfficientNet are the classic examples.

• Strengths: data-efficient, fast, easy to quantize and deploy.
• Trade-offs: less global context per layer; gains from scaling tend to flatten earlier than for transformers.

Vision transformers (ViTs)#

A vision transformer splits an image into patches and processes them as a sequence with self-attention, so every patch can relate to every other patch. ViTs do best when pretrained on large amounts of data and then transferred.

• Strengths: scales well with data and model size; strong transfer; the natural base for self-supervised and multimodal training.
• Trade-offs: needs large-scale pretraining or heavy regularization; usually slower and heavier at inference than a CNN of similar accuracy.

Hybrid CNN-transformer models#

Hybrids use convolutions in early stages for local detail and attention in later stages for global context. CoAtNet is the reference design: its authors found that stacking convolution and attention layers in a principled order improves generalization, capacity and efficiency.

• Strengths: a good balance on medium-sized datasets.
• Trade-offs: more complex to implement, tune and export than either pure design.

Self-supervised and vision-language backbones#

The newest family isn't defined by architecture but by how it's trained. Self-supervised models such as DINOv2 and DINOv3 learn from unlabeled images. Vision-language encoders such as SigLIP 2 learn from image-text pairs. Both produce general-purpose features you can classify with a small linear head, or, for vision-language models, with text prompts and no training at all (zero-shot learning). Meta trained DINOv3 at 7 billion parameters on 1.7 billion images, up from 1.1 billion parameters and 142 million images for DINOv2.

• Strengths: strong features with little labeled data; one backbone serves many tasks.
• Trade-offs: the largest checkpoints are far too heavy for edge devices; licenses vary and need checking.

Image classification models compared#

Models are listed alphabetically, not ranked. We haven't included accuracy figures: published ImageNet numbers vary with resolution, pretraining data and evaluation recipe, so they aren't comparable across these rows. Each model's paper or documentation, linked below, reports its own.

The models in more detail#

Listed alphabetically.

ConvNeXt V2#

ConvNeXt V2 pairs a fully convolutional masked autoencoder (FCMAE) with a Global Response Normalization layer. It comes in eight sizes, from Atto (3.7M parameters) to Huge (660M), so one family covers edge to server. It's a strong default when you want transformer-era accuracy with CNN deployment. Trade-off: the code is MIT-licensed, but the ImageNet pretrained and fine-tuned weights are CC-BY-NC, which rules out commercial use of those weights.

DINOv3#

DINOv3 is Meta's self-supervised vision backbone. It's released as ViT models from ViT-S/16 to ViT-7B/16, plus distilled ConvNeXt models for on-device use. Meta evaluates it with the backbone frozen, and the repository includes an ImageNet classification head for the 7B model. It's the model to try when you have few labels and want features that transfer. Trade-off: it's released under its own DINOv3 License rather than a standard open-source license, and the headline results come from the largest model.

EfficientNetV2#

EfficientNetV2 from Google uses progressive learning: it raises image size during training and adjusts regularization to match. That makes it train faster and use fewer parameters than earlier models. It remains a reliable choice for fine-tuning on small to mid-sized datasets. Trade-off: it predates the 2023–2025 backbones and no longer leads on accuracy. For background on the original design, see our EfficientNet overview.

EVA-02#

EVA-02 is a plain transformer pretrained with masked image modeling to reconstruct features from a large CLIP vision encoder. Four sizes range from 6M to 304M parameters. It's available in timm for fine-tuning. Trade-off: the large variants are expensive to fine-tune and serve, and they're overkill for simple domain classifiers.

MobileNetV4#

MobileNetV4 is Google's latest mobile family, designed to be efficient across mobile CPUs, DSPs, GPUs, the Apple Neural Engine and the Google Pixel EdgeTPU. It's the natural pick for a phone or low-power accelerator. Trade-off: it gives up peak accuracy for latency.

ResNet#

ResNet introduced residual connections and is still the standard baseline, supported by every framework. Trade-off: newer CNNs deliver more accuracy for the same compute. See what ResNet-50 is for the architecture.

SigLIP 2#

SigLIP 2 (see our SigLIP glossary entry) is Google's family of multilingual vision-language encoders. It can classify images against a list of text labels with no training (similar in approach to CLIP), and its NaFlex variant keeps the native aspect ratio of the input. It's the best fit when your label set changes often or you have no labeled data yet. Trade-off: zero-shot quality varies by domain, so validate it on your intended classes (for example, defect types) before relying on it. If it falls short, train a classification head or fine-tune.

Swin Transformer#

Swin Transformer computes attention inside shifted local windows, which keeps compute linear in image size and suits higher-resolution inputs. Trade-off: it's heavier than a CNN of similar accuracy; ConvNeXt was designed to compete with it using plain convolutions.

Ultralytics YOLO26-cls#

Ultralytics YOLO26-cls is the classification variant of Ultralytics YOLO26. It comes in five sizes (n, s, m, l, x), from 2.8M to 29.6M parameters (fused), takes 224-pixel inputs, and is pretrained on ImageNet. The docs report top-1 and top-5 accuracy on the ImageNet validation set and CPU and GPU latency for each size. The same Python API and CLI train, validate and export classification, detection, segmentation and pose models, and classifiers export to formats including ONNX, TensorRT, Core ML, OpenVINO and LiteRT. The earlier YOLO11-cls models use the same five sizes and input size. Trade-offs:

• Accuracy ceiling. Even the x model is small next to large pretrained transformers such as EVA-02 or DINOv3, so it isn't the choice for accuracy-first research.
• Square crops by default. Training uses a random resized crop and validation a center crop, which can cut off parts of images with extreme aspect ratios. The docs show how to swap in a plain resize.
• License. Ultralytics models are AGPL-3.0. Closed-source commercial use requires an Ultralytics Enterprise license.

Fig 2. Similar classes are where model size shows. On this photo of a station wagon, Ultralytics YOLO26n-cls ranks "minivan" first (80%), while YOLO26x-cls ranks station wagon first (100%, shown as ImageNet's "beach wagon, station wagon" class). Check fine-grained classes like these on your own validation set. The photo was generated for this article; the predictions are real model outputs.

ViT#

The original Vision Transformer from Google showed that a pure transformer on image patches can match or beat CNNs when pretrained on large amounts of data. Trade-off: without large-scale pretraining it underperforms CNNs on small datasets, and it needs more compute at inference.

How to choose an image classification model#

Work through these questions in order:

1. Do you have labeled data? With no labeled examples, start with a vision-language model such as SigLIP 2 for zero-shot classification. With a small labeled dataset, also evaluate a frozen DINOv3 backbone with a trained linear head.
2. Where will it run? On a phone or NPU, shortlist MobileNetV4 or a small CNN such as YOLO26n-cls or a small ConvNeXt V2. On an edge GPU or CPU in real time, look at YOLO26-cls, EfficientNetV2 or ConvNeXt V2. On a server with no tight latency budget, consider EVA-02, Swin or a DINOv3 ViT.
3. How much labeled data per class? With hundreds to low thousands of images, transfer learning from a pretrained CNN or a frozen self-supervised backbone is the safest path. With tens of thousands or more, fully fine-tuned transformers start to pay off.
4. Can you use the license? Check the weights, not just the code: ConvNeXt V2's ImageNet weights are non-commercial, DINOv3 has its own license, and Ultralytics models are AGPL-3.0 unless you hold an Enterprise license.
5. Does it export to your runtime? Confirm a supported path to ONNX, TensorRT, Core ML or TFLite before you commit.

Then fine-tune two or three shortlisted models and compare them on your own validation split.

When another model will serve you better than YOLO#

YOLO26-cls is built for fast, easily deployed custom classifiers. For some jobs a different model is the better choice:

• Accuracy-first research or benchmark work: use EVA-02, ConvNeXt V2 or a ViT through timm, where the recipes and weights exist to reproduce ImageNet-level results.
• Very few labels, or many downstream tasks from one backbone: use DINOv3 features with a linear head.
• Open or frequently changing label sets: use SigLIP 2 zero-shot.
• Phone NPUs such as the Apple Neural Engine or EdgeTPU: MobileNetV4 was designed and tested across exactly these targets.

If you also need to find where objects are, not just what the image shows, you need a detector. See our comparison of object detection models.

Fig 3. On a scene with many objects, a classifier still returns one label: Ultralytics YOLO26x-cls labels this distribution yard "trailer truck" at 99%. Ultralytics YOLO26x detection finds 7 objects, 4 people, 2 trucks and a car, each with its own box (confidence 0.5 or higher). The photo was generated for this article; the outputs are real.

Where to get pretrained models and train your own#

• timm (PyTorch Image Models) collects most of the backbones above, from ViT and ConvNeXt to MobileNetV4, EVA and DINOv3, with training and evaluation scripts. The code is Apache 2.0; weight licenses vary.
• Hugging Face hosts most transformer classifiers, including SigLIP 2 and DINOv3, with ready-made zero-shot and image-classification pipelines.
• The Ultralytics Python package trains YOLO26-cls on a folder of images sorted by class. See the classification dataset format and the classify task guide.
• Ultralytics Platform adds annotation and cloud training for the same models. It launched in 2026, so it's newer than established hosted training services. For serving models after training, see our comparison of computer vision inference platforms.