Convert Figma logo to code with AI

huggingface logopytorch-image-models

The largest collection of PyTorch image encoders / backbones. Including train, eval, inference, export scripts, and pretrained weights -- ResNet, ResNeXT, EfficientNet, NFNet, Vision Transformer (ViT), MobileNetV4, MobileNet-V3 & V2, RegNet, DPN, CSPNet, Swin Transformer, MaxViT, CoAtNet, ConvNeXt, and more

36,193
5,104
36,193
74
View on GitHub

Top Related Projects

facebookresearch's avatar

detectron2

33,918

Detectron2 is a platform for object detection, segmentation and other visual recognition tasks.

tensorflow's avatar

models

77,668

Models and examples built with TensorFlow

pytorch's avatar

vision

17,293

Datasets, Transforms and Models specific to Computer Vision

keras-team's avatar

keras

63,691

Deep Learning for humans

huggingface's avatar

pytorch-image-models

36,187

The largest collection of PyTorch image encoders / backbones. Including train, eval, inference, export scripts, and pretrained weights -- ResNet, ResNeXT, EfficientNet, NFNet, Vision Transformer (ViT), MobileNetV4, MobileNet-V3 & V2, RegNet, DPN, CSPNet, Swin Transformer, MaxViT, CoAtNet, ConvNeXt, and more

microsoft's avatar

computervision-recipes

9,784

Best Practices, code samples, and documentation for Computer Vision.

Quick Overview

PyTorch Image Models (timm) is a collection of image models, layers, utilities, optimizers, schedulers, data-loaders, augmentations, and training/validation scripts for PyTorch. It aims to pull together a wide variety of SOTA models with ability to reproduce ImageNet training results.

Pros

  • Extensive collection of pre-trained models and implementations
  • Consistent interface for different models, making it easy to switch between them
  • Regular updates with new models and improvements
  • Includes training scripts and utilities for fine-tuning and evaluation

Cons

  • Large repository size due to the extensive collection of models
  • Can be overwhelming for beginners due to the wide range of options
  • Some models may have dependencies on specific PyTorch versions
  • Documentation could be more comprehensive for some advanced features

Code Examples

  1. Loading a pre-trained model:
import timm

model = timm.create_model('resnet50', pretrained=True)
model.eval()
  1. Performing inference on an image:
from PIL import Image
import torch
import timm.data

img = Image.open('path/to/image.jpg')
transform = timm.data.create_transform(
    input_size=224,
    is_training=False
)
img_tensor = transform(img).unsqueeze(0)

with torch.no_grad():
    output = model(img_tensor)
    probabilities = torch.nn.functional.softmax(output[0], dim=0)
    print(probabilities.topk(5))
  1. Fine-tuning a model on a custom dataset:
import timm

model = timm.create_model('efficientnet_b0', pretrained=True, num_classes=10)
model.train()

# Assuming you have your custom dataset and dataloader
for epoch in range(num_epochs):
    for batch in dataloader:
        images, labels = batch
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Getting Started

To get started with PyTorch Image Models:

  1. Install the library:
pip install timm
  1. Import and use in your Python script:
import timm

# List available models
print(timm.list_models())

# Create a model
model = timm.create_model('resnet50', pretrained=True)

# Use the model for inference or training
# ...

Competitor Comparisons

facebookresearch logo

detectron2

33,918

Detectron2 is a platform for object detection, segmentation and other visual recognition tasks.

Pros of Detectron2

  • Comprehensive suite of object detection and segmentation models
  • Extensive documentation and tutorials for various use cases
  • Built-in support for distributed training and deployment

Cons of Detectron2

  • Steeper learning curve for beginners
  • More focused on detection and segmentation tasks, less versatile for general image classification
  • Heavier framework with more dependencies

Code Comparison

Detectron2:

from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg

cfg = get_cfg()
cfg.merge_from_file("path/to/config.yaml")
predictor = DefaultPredictor(cfg)
outputs = predictor(image)

pytorch-image-models:

import timm

model = timm.create_model('resnet50', pretrained=True)
model.eval()
output = model(image)

pytorch-image-models offers a more straightforward API for quickly loading and using pre-trained models, while Detectron2 provides a more comprehensive configuration system for fine-tuning complex detection and segmentation models.

tensorflow logo

models

77,668

Models and examples built with TensorFlow

Pros of tensorflow/models

  • Broader scope, covering various ML domains beyond just image models
  • Official TensorFlow implementation, ensuring compatibility and optimization
  • Extensive documentation and tutorials for each model

Cons of tensorflow/models

  • Less focused on image models specifically, potentially lacking some specialized architectures
  • May have a steeper learning curve due to its broader scope
  • Updates might be less frequent for individual model categories

Code Comparison

tensorflow/models:

import tensorflow as tf
from official.vision.image_classification import resnet_model

model = resnet_model.resnet50(num_classes=1000)

pytorch-image-models:

import timm

model = timm.create_model('resnet50', pretrained=True, num_classes=1000)

Summary

tensorflow/models is a comprehensive repository for various machine learning tasks, while pytorch-image-models focuses specifically on image models. The TensorFlow repository offers a wider range of models and official implementations, but may be more complex to navigate. pytorch-image-models provides a more streamlined experience for image-related tasks, with a simpler API and frequent updates. The choice between the two depends on the specific project requirements and the preferred deep learning framework.

pytorch logo

vision

17,293

Datasets, Transforms and Models specific to Computer Vision

Pros of vision

  • Official PyTorch repository, ensuring long-term support and compatibility
  • Comprehensive set of computer vision tools beyond just models
  • Tightly integrated with other PyTorch libraries and ecosystem

Cons of vision

  • Fewer pre-trained models compared to pytorch-image-models
  • Less frequent updates and new model implementations
  • May have a steeper learning curve for beginners

Code Comparison

vision:

import torchvision.models as models
resnet18 = models.resnet18(pretrained=True)

pytorch-image-models:

import timm
model = timm.create_model('resnet18', pretrained=True)

Both repositories provide easy access to pre-trained models, but pytorch-image-models (timm) offers a wider variety of models and more flexibility in model creation. vision focuses on providing a comprehensive set of tools for computer vision tasks, including datasets, transforms, and utilities, while pytorch-image-models specializes in offering a large collection of image models with consistent API.

vision is ideal for users deeply integrated into the PyTorch ecosystem, while pytorch-image-models is excellent for those seeking a wide range of cutting-edge models with minimal setup. The choice between them depends on specific project requirements and personal preferences.

keras-team logo

keras

63,691

Deep Learning for humans

Pros of Keras

  • Higher-level API, making it easier for beginners to get started
  • Supports multiple backend engines (TensorFlow, Theano, CNTK)
  • Extensive documentation and community support

Cons of Keras

  • Less flexibility for advanced users compared to PyTorch
  • Slower development cycle for cutting-edge features
  • Limited support for dynamic computational graphs

Code Comparison

Keras:

from keras.models import Sequential
from keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])

pytorch-image-models:

import timm

model = timm.create_model('resnet18', pretrained=True, num_classes=10)

The Keras example shows its simplicity in creating a basic neural network, while the pytorch-image-models snippet demonstrates the ease of using pre-trained models with a single line of code.

pytorch-image-models focuses specifically on computer vision tasks and provides a wide range of state-of-the-art image models. It offers more flexibility and customization options for researchers and advanced practitioners. Keras, on the other hand, is a more general-purpose deep learning library that supports various types of neural networks and is known for its user-friendly interface.

huggingface logo

pytorch-image-models

36,187

The largest collection of PyTorch image encoders / backbones. Including train, eval, inference, export scripts, and pretrained weights -- ResNet, ResNeXT, EfficientNet, NFNet, Vision Transformer (ViT), MobileNetV4, MobileNet-V3 & V2, RegNet, DPN, CSPNet, Swin Transformer, MaxViT, CoAtNet, ConvNeXt, and more

Pros of pytorch-image-models

  • Extensive collection of pre-trained image models
  • Regular updates and active maintenance
  • Comprehensive documentation and examples

Cons of pytorch-image-models

  • Larger repository size due to extensive model collection
  • May have a steeper learning curve for beginners
  • Potentially higher computational requirements

Code Comparison

pytorch-image-models:

import timm
model = timm.create_model('resnet50', pretrained=True)
output = model(input_tensor)

pytorch-image-models:

import timm
model = timm.create_model('resnet50', pretrained=True)
output = model(input_tensor)

As both repositories are the same, there is no difference in the code comparison. The usage and implementation would be identical for both.

Summary

Since the comparison is between the same repository (huggingface/pytorch-image-models), there are no actual differences to highlight. The repository, known as pytorch-image-models or timm, is a popular collection of image models and utilities for PyTorch. It offers a wide range of pre-trained models, is actively maintained, and provides excellent documentation. However, its extensive collection may result in a larger repository size and potentially higher computational requirements compared to more focused libraries.

microsoft logo

computervision-recipes

9,784

Best Practices, code samples, and documentation for Computer Vision.

Pros of computervision-recipes

  • Comprehensive collection of computer vision recipes and notebooks
  • Covers a wide range of CV tasks, including object detection, image classification, and segmentation
  • Provides end-to-end examples and best practices for Azure integration

Cons of computervision-recipes

  • Less focused on state-of-the-art model implementations
  • May have a steeper learning curve for those not familiar with Azure ecosystem
  • Fewer pre-trained models available compared to pytorch-image-models

Code Comparison

pytorch-image-models:

import timm
model = timm.create_model('resnet50', pretrained=True)
output = model(input_tensor)

computervision-recipes:

from azureml.core import Workspace
from azureml.core.model import Model

model = Model(ws, 'my_model')
model.download(target_dir=os.getcwd(), exist_ok=True)

pytorch-image-models focuses on providing a wide range of pre-trained models with a simple API, while computervision-recipes emphasizes Azure integration and end-to-end workflows for various computer vision tasks. The choice between the two depends on specific project requirements and the desired level of Azure integration.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

PyTorch Image Models

What's New

Jan 5 & 6, 2025

  • Release 1.0.24
  • Add new benchmark result csv files for inference timing on all models w/ RTX Pro 6000, 5090, and 4090 cards w/ PyTorch 2.9.1
  • Fix moved module error in deprecated timm.models.layers import path that impacts legacy imports
  • Release 1.0.23

Dec 30, 2025

Dec 12, 2025

Dec 1, 2025

  • Add lightweight task abstraction, add logits and feature distillation support to train script via new tasks.
  • Remove old APEX AMP support

Nov 4, 2025

Oct 31, 2025 🎃

  • Update imagenet & OOD variant result csv files to include a few new models and verify correctness over several torch & timm versions
  • EfficientNet-X and EfficientNet-H B5 model weights added as part of a hparam search for AdamW vs Muon (still iterating on Muon runs)

Oct 16-20, 2025

  • Add an impl of the Muon optimizer (based on https://github.com/KellerJordan/Muon) with customizations
    • extra flexibility and improved handling for conv weights and fallbacks for weight shapes not suited for orthogonalization
    • small speedup for NS iterations by reducing allocs and using fused (b)add(b)mm ops
    • by default uses AdamW (or NAdamW if nesterov=True) updates if muon not suitable for parameter shape (or excluded via param group flag)
    • like torch impl, select from several LR scale adjustment fns via adjust_lr_fn
    • select from several NS coefficient presets or specify your own via ns_coefficients
  • First 2 steps of 'meta' device model initialization supported
    • Fix several ops that were breaking creation under 'meta' device context
    • Add device & dtype factory kwarg support to all models and modules (anything inherting from nn.Module) in timm
  • License fields added to pretrained cfgs in code
  • Release 1.0.21

Sept 21, 2025

  • Remap DINOv3 ViT weight tags from lvd_1689m -> lvd1689m to match (same for sat_493m -> sat493m)
  • Release 1.0.20

Sept 17, 2025

July 23, 2025

  • Add set_input_size() method to EVA models, used by OpenCLIP 3.0.0 to allow resizing for timm based encoder models.
  • Release 1.0.18, needed for PE-Core S & T models in OpenCLIP 3.0.0
  • Fix small typing issue that broke Python 3.9 compat. 1.0.19 patch release.

July 21, 2025

  • ROPE support added to NaFlexViT. All models covered by the EVA base (eva.py) including EVA, EVA02, Meta PE ViT, timm SBB ViT w/ ROPE, and Naver ROPE-ViT can be now loaded in NaFlexViT when use_naflex=True passed at model creation time
  • More Meta PE ViT encoders added, including small/tiny variants, lang variants w/ tiling, and more spatial variants.
  • PatchDropout fixed with NaFlexViT and also w/ EVA models (regression after adding Naver ROPE-ViT)
  • Fix XY order with grid_indexing='xy', impacted non-square image use in 'xy' mode (only ROPE-ViT and PE impacted).

July 7, 2025

  • MobileNet-v5 backbone tweaks for improved Google Gemma 3n behaviour (to pair with updated official weights)
    • Add stem bias (zero'd in updated weights, compat break with old weights)
    • GELU -> GELU (tanh approx). A minor change to be closer to JAX
  • Add two arguments to layer-decay support, a min scale clamp and 'no optimization' scale threshold
  • Add 'Fp32' LayerNorm, RMSNorm, SimpleNorm variants that can be enabled to force computation of norm in float32
  • Some typing, argument cleanup for norm, norm+act layers done with above
  • Support Naver ROPE-ViT (https://github.com/naver-ai/rope-vit) in eva.py, add RotaryEmbeddingMixed module for mixed mode, weights on HuggingFace Hub
modelimg_sizetop1top5param_count
vit_large_patch16_rope_mixed_ape_224.naver_in1k22484.8497.122304.4
vit_large_patch16_rope_mixed_224.naver_in1k22484.82897.116304.2
vit_large_patch16_rope_ape_224.naver_in1k22484.6597.154304.37
vit_large_patch16_rope_224.naver_in1k22484.64897.122304.17
vit_base_patch16_rope_mixed_ape_224.naver_in1k22483.89496.75486.59
vit_base_patch16_rope_mixed_224.naver_in1k22483.80496.71286.44
vit_base_patch16_rope_ape_224.naver_in1k22483.78296.6186.59
vit_base_patch16_rope_224.naver_in1k22483.71896.67286.43
vit_small_patch16_rope_224.naver_in1k22481.2395.02221.98
vit_small_patch16_rope_mixed_224.naver_in1k22481.21695.02221.99
vit_small_patch16_rope_ape_224.naver_in1k22481.00495.01622.06
vit_small_patch16_rope_mixed_ape_224.naver_in1k22480.98694.97622.06
  • Some cleanup of ROPE modules, helpers, and FX tracing leaf registration
  • Preparing version 1.0.17 release

June 26, 2025

  • MobileNetV5 backbone (w/ encoder only variant) for Gemma 3n image encoder
  • Version 1.0.16 released

June 23, 2025

  • Add F.grid_sample based 2D and factorized pos embed resize to NaFlexViT. Faster when lots of different sizes (based on example by https://github.com/stas-sl).
  • Further speed up patch embed resample by replacing vmap with matmul (based on snippet by https://github.com/stas-sl).
  • Add 3 initial native aspect NaFlexViT checkpoints created while testing, ImageNet-1k and 3 different pos embed configs w/ same hparams.
ModelTop-1 AccTop-5 AccParams (M)Eval Seq Len
naflexvit_base_patch16_par_gap.e300_s576_in1k83.6796.4586.63576
naflexvit_base_patch16_parfac_gap.e300_s576_in1k83.6396.4186.46576
naflexvit_base_patch16_gap.e300_s576_in1k83.5096.4686.63576
  • Support gradient checkpointing for forward_intermediates and fix some checkpointing bugs. Thanks https://github.com/brianhou0208
  • Add 'corrected weight decay' (https://arxiv.org/abs/2506.02285) as option to AdamW (legacy), Adopt, Kron, Adafactor (BV), Lamb, LaProp, Lion, NadamW, RmsPropTF, SGDW optimizers
  • Switch PE (perception encoder) ViT models to use native timm weights instead of remapping on the fly
  • Fix cuda stream bug in prefetch loader

June 5, 2025

  • Initial NaFlexVit model code. NaFlexVit is a Vision Transformer with:
    1. Encapsulated embedding and position encoding in a single module
    2. Support for nn.Linear patch embedding on pre-patchified (dictionary) inputs
    3. Support for NaFlex variable aspect, variable resolution (SigLip-2: https://arxiv.org/abs/2502.14786)
    4. Support for FlexiViT variable patch size (https://arxiv.org/abs/2212.08013)
    5. Support for NaViT fractional/factorized position embedding (https://arxiv.org/abs/2307.06304)
  • Existing vit models in vision_transformer.py can be loaded into the NaFlexVit model by adding the use_naflex=True flag to create_model
    • Some native weights coming soon
  • A full NaFlex data pipeline is available that allows training / fine-tuning / evaluating with variable aspect / size images
    • To enable in train.py and validate.py add the --naflex-loader arg, must be used with a NaFlexVit
  • To evaluate an existing (classic) ViT loaded in NaFlexVit model w/ NaFlex data pipe:
    • python validate.py /imagenet --amp -j 8 --model vit_base_patch16_224 --model-kwargs use_naflex=True --naflex-loader --naflex-max-seq-len 256
  • The training has some extra args features worth noting
    • The --naflex-train-seq-lens' argument specifies which sequence lengths to randomly pick from per batch during training
    • The --naflex-max-seq-len argument sets the target sequence length for validation
    • Adding --model-kwargs enable_patch_interpolator=True --naflex-patch-sizes 12 16 24 will enable random patch size selection per-batch w/ interpolation
    • The --naflex-loss-scale arg changes loss scaling mode per batch relative to the batch size, timm NaFlex loading changes the batch size for each seq len

May 28, 2025

Feb 21, 2025

  • SigLIP 2 ViT image encoders added (https://huggingface.co/collections/timm/siglip-2-67b8e72ba08b09dd97aecaf9)
    • Variable resolution / aspect NaFlex versions are a WIP
  • Add 'SO150M2' ViT weights trained with SBB recipes, great results, better for ImageNet than previous attempt w/ less training.
    • vit_so150m2_patch16_reg1_gap_448.sbb_e200_in12k_ft_in1k - 88.1% top-1
    • vit_so150m2_patch16_reg1_gap_384.sbb_e200_in12k_ft_in1k - 87.9% top-1
    • vit_so150m2_patch16_reg1_gap_256.sbb_e200_in12k_ft_in1k - 87.3% top-1
    • vit_so150m2_patch16_reg4_gap_256.sbb_e200_in12k
  • Updated InternViT-300M '2.5' weights
  • Release 1.0.15

Feb 1, 2025

  • FYI PyTorch 2.6 & Python 3.13 are tested and working w/ current main and released version of timm

Jan 27, 2025

Jan 19, 2025

  • Fix loading of LeViT safetensor weights, remove conversion code which should have been deactivated
  • Add 'SO150M' ViT weights trained with SBB recipes, decent results, but not optimal shape for ImageNet-12k/1k pretrain/ft
    • vit_so150m_patch16_reg4_gap_256.sbb_e250_in12k_ft_in1k - 86.7% top-1
    • vit_so150m_patch16_reg4_gap_384.sbb_e250_in12k_ft_in1k - 87.4% top-1
    • vit_so150m_patch16_reg4_gap_256.sbb_e250_in12k
  • Misc typing, typo, etc. cleanup
  • 1.0.14 release to get above LeViT fix out

Jan 9, 2025

  • Add support to train and validate in pure bfloat16 or float16
  • wandb project name arg added by https://github.com/caojiaolong, use arg.experiment for name
  • Fix old issue w/ checkpoint saving not working on filesystem w/o hard-link support (e.g. FUSE fs mounts)
  • 1.0.13 release

Jan 6, 2025

  • Add torch.utils.checkpoint.checkpoint() wrapper in timm.models that defaults use_reentrant=False, unless TIMM_REENTRANT_CKPT=1 is set in env.

Dec 31, 2024

Introduction

PyTorch Image Models (timm) is a collection of image models, layers, utilities, optimizers, schedulers, data-loaders / augmentations, and reference training / validation scripts that aim to pull together a wide variety of SOTA models with ability to reproduce ImageNet training results.

The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arxiv papers, etc in the README, documentation, and code docstrings. Please let me know if I missed anything.

Features

Models

All model architecture families include variants with pretrained weights. There are specific model variants without any weights, it is NOT a bug. Help training new or better weights is always appreciated.

Optimizers

To see full list of optimizers w/ descriptions: timm.optim.list_optimizers(with_description=True)

Included optimizers available via timm.optim.create_optimizer_v2 factory method:

Augmentations

Regularization

Other

Several (less common) features that I often utilize in my projects are included. Many of their additions are the reason why I maintain my own set of models, instead of using others' via PIP:

Results

Model validation results can be found in the results tables

Getting Started (Documentation)

The official documentation can be found at https://huggingface.co/docs/hub/timm. Documentation contributions are welcome.

Getting Started with PyTorch Image Models (timm): A Practitioner’s Guide by Chris Hughes is an extensive blog post covering many aspects of timm in detail.

timmdocs is an alternate set of documentation for timm. A big thanks to Aman Arora for his efforts creating timmdocs.

paperswithcode is a good resource for browsing the models within timm.

Train, Validation, Inference Scripts

The root folder of the repository contains reference train, validation, and inference scripts that work with the included models and other features of this repository. They are adaptable for other datasets and use cases with a little hacking. See documentation.

Awesome PyTorch Resources

One of the greatest assets of PyTorch is the community and their contributions. A few of my favourite resources that pair well with the models and components here are listed below.

Object Detection, Instance and Semantic Segmentation

Computer Vision / Image Augmentation

Knowledge Distillation

Metric Learning

Training / Frameworks

Licenses

Code

The code here is licensed Apache 2.0. I've taken care to make sure any third party code included or adapted has compatible (permissive) licenses such as MIT, BSD, etc. I've made an effort to avoid any GPL / LGPL conflicts. That said, it is your responsibility to ensure you comply with licenses here and conditions of any dependent licenses. Where applicable, I've linked the sources/references for various components in docstrings. If you think I've missed anything please create an issue.

Pretrained Weights

So far all of the pretrained weights available here are pretrained on ImageNet with a select few that have some additional pretraining (see extra note below). ImageNet was released for non-commercial research purposes only (https://image-net.org/download). It's not clear what the implications of that are for the use of pretrained weights from that dataset. Any models I have trained with ImageNet are done for research purposes and one should assume that the original dataset license applies to the weights. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.

Pretrained on more than ImageNet

Several weights included or references here were pretrained with proprietary datasets that I do not have access to. These include the Facebook WSL, SSL, SWSL ResNe(Xt) and the Google Noisy Student EfficientNet models. The Facebook models have an explicit non-commercial license (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images). The Google models do not appear to have any restriction beyond the Apache 2.0 license (and ImageNet concerns). In either case, you should contact Facebook or Google with any questions.

Citing

BibTeX

@misc{rw2019timm,
  author = {Ross Wightman},
  title = {PyTorch Image Models},
  year = {2019},
  publisher = {GitHub},
  journal = {GitHub repository},
  doi = {10.5281/zenodo.4414861},
  howpublished = {\url{https://github.com/rwightman/pytorch-image-models}}
}

Latest DOI

DOI