Page d'accueil>Lié à la programmation>Autre code source
Télécharger

Modèles d'images PyTorch

  • Quoi de neuf

  • Introduction

  • Modèles

  • Caractéristiques

  • Résultats

  • Premiers pas (documentation)

  • Scripts de formation, de validation et d'inférence

  • Ressources PyTorch impressionnantes

  • Licences

  • Citer

Quoi de neuf

19 octobre 2024

  • Utilisation de l'ampli de la torche de nettoyage pour éviter les appels spécifiques à cuda, fusion de la prise en charge des appareils Ascend (NPU) de MengqingCao qui devrait fonctionner maintenant dans PyTorch 2.5 avec une nouvelle fonctionnalité de chargement automatique d'extension de périphérique. J'ai également testé Intel Arc (XPU) dans Pytorch 2.5 et cela a (pour la plupart) fonctionné.

16 octobre 2024

  • Correction d'une erreur lors de l'importation à partir du chemin obsolète timm.models.registry , priorité accrue des avertissements de dépréciation existants pour être visibles

  • Poids des ports d'InternViT-300M (https://huggingface.co/OpenGVLab/InternViT-300M-448px) à timm comme vit_intern300m_patch14_448

14 octobre 2024

  • Version de pré-activation (ResNetV2) des définitions du modèle ResNet 18/18d/34/34d ajoutées sur demande (poids en attente)

  • Version 1.0.10

11 octobre 2024

  • Modèle et poids MambaOut (https://github.com/yuweihao/MambaOut) ajoutés. Une version effrontée des modèles de vision SSM sans SSM (essentiellement ConvNeXt avec gating). Un mélange de poids originaux + variations et poids personnalisés.

modèle img_size top1 top5 param_count
mambaout_base_plus_rw.sw_e150_r384_in12k_ft_in1k 384 87.506 98.428 101,66
mambaout_base_plus_rw.sw_e150_in12k_ft_in1k 288 86.912 98.236 101,66
mambaout_base_plus_rw.sw_e150_in12k_ft_in1k 224 86.632 98.156 101,66
mambaout_base_tall_rw.sw_e500_in1k 288 84.974 97.332 86.48
mambaout_base_wide_rw.sw_e500_in1k 288 84.962 97.208 94.45
mambaout_base_short_rw.sw_e500_in1k 288 84.832 97.27 88,83
mambaout_base.in1k 288 84,72 96.93 84,81
mambaout_small_rw.sw_e450_in1k 288 84.598 97.098 48,5
mambaout_small.in1k 288 84,5 96.974 48.49
mambaout_base_wide_rw.sw_e500_in1k 224 84.454 96.864 94.45
mambaout_base_tall_rw.sw_e500_in1k 224 84.434 96.958 86.48
mambaout_base_short_rw.sw_e500_in1k 224 84.362 96.952 88,83
mambaout_base.in1k 224 84.168 96,68 84,81
mambaout_small.in1k 224 84.086 96.63 48.49
mambaout_small_rw.sw_e450_in1k 224 84.024 96.752 48,5
mambaout_tiny.in1k 288 83.448 96.538 26h55
mambaout_tiny.in1k 224 82.736 96.1 26h55
mambaout_kobe.in1k 288 81.054 95.718 9.14
mambaout_kobe.in1k 224 79.986 94.986 9.14
mambaout_femto.in1k 288 79.848 95.14 7.3
mambaout_femto.in1k 224 78,87 94.408 7.3

  • SigLIP SO400M ViT s'améliore sur ImageNet-1k à 378x378, ajout de l'option 378x378 pour les modèles SigLIP 384x384 existants

    • vit_so400m_patch14_siglip_378.webli_ft_in1k - 89,42 top-1

    • vit_so400m_patch14_siglip_gap_378.webli_ft_in1k - 89.03

  • Encodeur SigLIP SO400M ViT de la récente variante multilingue (i18n), patch16 @ 256x256 (https://huggingface.co/timm/ViT-SO400M-16-SigLIP-i18n-256). Mise à jour OpenCLIP en attente.

  • Ajoutez deux modèles et poids ConvNeXt 'Zepto' (un avec tige superposée et un avec tige patch). Utilise RMSNorm, plus petit que le précédent « Atto », 2,2 millions de paramètres.

    • convnext_zepto_rms_ols.ra4_e3600_r224_in1k - 73,20 top-1 @ 224

    • convnext_zepto_rms.ra4_e3600_r224_in1k - 72,81 @ 224

septembre 2024

  • Ajoutez une suite de petits modèles de test pour des tests unitaires améliorés et des applications de niche à faibles ressources (https://huggingface.co/blog/rwightman/timm-tiny-test)

  • Ajoutez le modèle MobileNetV4-Conv-Small (0,5x) (https://huggingface.co/posts/rwightman/793053396198664)

    • mobilenetv4_conv_small_050.e3000_r224_in1k - 65,81 top-1 à 256, 64,76 à 224

  • Ajouter des variantes MobileNetV3-Large entraînées avec la recette MNV4 Small

    • mobilenetv3_large_150d.ra4_e3600_r256_in1k - 81,81 à 320, 80,94 à 256

    • mobilenetv3_large_100.ra4_e3600_r224_in1k - 77,16 à 256, 76,31 à 224

21 août 2024

  • Modèles ViT SBB mis à jour formés sur ImageNet-12k et affinés sur ImageNet-1k, défiant un certain nombre de modèles beaucoup plus grands et plus lents

modèle top1 top5 param_count img_size
vit_mediumd_patch16_reg4_gap_384.sbb2_e200_in12k_ft_in1k 87.438 98.256 64.11 384
vit_mediumd_patch16_reg4_gap_256.sbb2_e200_in12k_ft_in1k 86.608 97.934 64.11 256
vit_betwixt_patch16_reg4_gap_384.sbb2_e200_in12k_ft_in1k 86.594 98.02 60,4 384
vit_betwixt_patch16_reg4_gap_256.sbb2_e200_in12k_ft_in1k 85.734 97.61 60,4 256

  • Poids MobileNet-V1 1.25, EfficientNet-B1 et ResNet50-D avec recette de défi de base MNV4

modèle top1 top5 param_count img_size
resnet50d.ra4_e3600_r224_in1k 81.838 95.922 25.58 288
efficacenet_b1.ra4_e3600_r240_in1k 81.440 95.700 7,79 288
resnet50d.ra4_e3600_r224_in1k 80.952 95.384 25.58 224
efficacenet_b1.ra4_e3600_r240_in1k 80.406 95.152 7,79 240
mobilenetv1_125.ra4_e3600_r224_in1k 77.600 93.804 6.27 256
mobilenetv1_125.ra4_e3600_r224_in1k 76.924 93.234 6.27 224

  • Ajoutez la voûte dorsale SAM2 (HieraDet) et la prise en charge du chargement de poids

  • Ajouter des poids Hiera Small entraînés avec abswin pos intégrés sur in12k et affiné sur 1k

modèle top1 top5 param_count
hiera_small_abswin_256.sbb2_e200_in12k_ft_in1k 84.912 97.260 35.01
hiera_small_abswin_256.sbb2_pd_e200_in12k_ft_in1k 84.560 97.106 35.01

8 août 2024

  • Ajoutez RDNet (« DenseNets Reloaded », https://arxiv.org/abs/2403.19588), merci Donghyun Kim

28 juillet 2024

  • Ajoutez des poids mobilenet_edgetpu_v2_m avec une recette basée sur ra4 mnv4-small. 80,1 % top-1 à 224 et 80,7 à 256.

  • Version 1.0.8

26 juillet 2024

  • Plus de poids MobileNet-v4, pré-entraînement ImageNet-12k avec réglages fins et modèles ConvLarge anti-aliasés

modèle top1 top1_err top5 top5_err param_count img_size
mobilenetv4_conv_aa_large.e230_r448_in12k_ft_in1k 84,99 15.01 97.294 2.706 32.59 544
mobilenetv4_conv_aa_large.e230_r384_in12k_ft_in1k 84.772 15.228 97.344 2.656 32.59 480
mobilenetv4_conv_aa_large.e230_r448_in12k_ft_in1k 84,64 15h36 97.114 2.886 32.59 448
mobilenetv4_conv_aa_large.e230_r384_in12k_ft_in1k 84.314 15.686 97.102 2.898 32.59 384
mobilenetv4_conv_aa_large.e600_r384_in1k 83.824 16.176 96.734 3.266 32.59 480
mobilenetv4_conv_aa_large.e600_r384_in1k 83.244 16.756 96.392 3.608 32.59 384
mobilenetv4_hybrid_medium.e200_r256_in12k_ft_in1k 82,99 17.01 96,67 3.33 11.07 320
mobilenetv4_hybrid_medium.e200_r256_in12k_ft_in1k 82.364 17.636 96.256 3.744 11.07 256

  • Défis de base impressionnants avec MobileNet-V1 et EfficientNet-B0 (https://huggingface.co/blog/rwightman/mobilenet-baselines)

modèle top1 top1_err top5 top5_err param_count img_size
efficacenet_b0.ra4_e3600_r224_in1k 79.364 20.636 94.754 5.246 5.29 256
efficacenet_b0.ra4_e3600_r224_in1k 78.584 21.416 94.338 5.662 5.29 224
mobilenetv1_100h.ra4_e3600_r224_in1k 76.596 23.404 93.272 6.728 5.28 256
mobilenetv1_100.ra4_e3600_r224_in1k 76.094 23.906 93.004 6.996 4.23 256
mobilenetv1_100h.ra4_e3600_r224_in1k 75.662 24.338 92.504 7.496 5.28 224
mobilenetv1_100.ra4_e3600_r224_in1k 75.382 24.618 92.312 7.688 4.23 224

  • Prototype de set_input_size() ajouté aux modèles vit et swin v1/v2 pour permettre de modifier la taille de l'image, la taille du patch et la taille de la fenêtre après la création du modèle.

  • Prise en charge améliorée dans swin pour la gestion de différentes tailles, en plus des arguments set_input_size , always_partition et strict_img_size ont été ajoutés à __init__ pour permettre des contraintes de taille d'entrée plus flexibles.

  • Corrigez les informations sur les indices en panne pour le wrapper de fonctionnalité intermédiaire « Getter », extrayez ou rangez les indices pour ceux-ci.

  • Ajoutez plusieurs tiny modèles de paramètres < 0,5 M pour les tests qui sont réellement formés sur ImageNet-1k

modèle top1 top1_err top5 top5_err param_count img_size crop_pct
test_efficacenet.r160_in1k 47.156 52.844 71.726 28.274 0,36 192 1.0
test_byobnet.r160_in1k 46.698 53.302 71.674 28.326 0,46 192 1.0
test_efficacenet.r160_in1k 46.426 53.574 70.928 29.072 0,36 160 0,875
test_byobnet.r160_in1k 45.378 54.622 70.572 29.428 0,46 160 0,875
test_vit.r160_in1k 42,0 58,0 68.664 31.336 0,37 192 1.0
test_vit.r160_in1k 40.822 59.178 67.212 32.788 0,37 160 0,875

  • Correction de l'initialisation du jeton Vit reg, merci Promisery

  • Autres correctifs divers

24 juin 2024

  • 3 poids hybrides MobileNetV4 supplémentaires avec un schéma d'initialisation de poids MQA différent

modèle top1 top1_err top5 top5_err param_count img_size
mobilenetv4_hybrid_large.ix_e600_r384_in1k 84.356 15.644 96.892 3.108 37,76 448
mobilenetv4_hybrid_large.ix_e600_r384_in1k 83.990 16.010 96.702 3.298 37,76 384
mobilenetv4_hybrid_medium.ix_e550_r384_in1k 83.394 16.606 96.760 3.240 11.07 448
mobilenetv4_hybrid_medium.ix_e550_r384_in1k 82.968 17.032 96.474 3.526 11.07 384
mobilenetv4_hybrid_medium.ix_e550_r256_in1k 82.492 17.508 96.278 3.722 11.07 320
mobilenetv4_hybrid_medium.ix_e550_r256_in1k 81.446 18.554 95.704 4.296 11.07 256

  • Chargement du poids de Florence2 dans le modèle DaViT

12 juin 2024

  • Modèles MobileNetV4 et ensemble initial de poids entraînés timm ajoutés :

modèle top1 top1_err top5 top5_err param_count img_size
mobilenetv4_hybrid_large.e600_r384_in1k 84.266 15.734 96.936 3.064 37,76 448
mobilenetv4_hybrid_large.e600_r384_in1k 83.800 16.200 96.770 3.230 37,76 384
mobilenetv4_conv_large.e600_r384_in1k 83.392 16.608 96.622 3.378 32.59 448
mobilenetv4_conv_large.e600_r384_in1k 82.952 17.048 96.266 3.734 32.59 384
mobilenetv4_conv_large.e500_r256_in1k 82.674 17.326 96.31 3,69 32.59 320
mobilenetv4_conv_large.e500_r256_in1k 81.862 18.138 95,69 4.31 32.59 256
mobilenetv4_hybrid_medium.e500_r224_in1k 81.276 18.724 95.742 4.258 11.07 256
mobilenetv4_conv_medium.e500_r256_in1k 80.858 19.142 95.768 4.232 9.72 320
mobilenetv4_hybrid_medium.e500_r224_in1k 80.442 19.558 95.38 4,62 11.07 224
mobilenetv4_conv_blur_medium.e500_r224_in1k 80.142 19.858 95.298 4.702 9.72 256
mobilenetv4_conv_medium.e500_r256_in1k 79.928 20.072 95.184 4.816 9.72 256
mobilenetv4_conv_medium.e500_r224_in1k 79.808 20.192 95.186 4.814 9.72 256
mobilenetv4_conv_blur_medium.e500_r224_in1k 79.438 20.562 94.932 5.068 9.72 224
mobilenetv4_conv_medium.e500_r224_in1k 79.094 20.906 94,77 5.23 9.72 224
mobilenetv4_conv_small.e2400_r224_in1k 74.616 25.384 92.072 7.928 3,77 256
mobilenetv4_conv_small.e1200_r224_in1k 74.292 25.708 92.116 7.884 3,77 256
mobilenetv4_conv_small.e2400_r224_in1k 73.756 26.244 91.422 8.578 3,77 224
mobilenetv4_conv_small.e1200_r224_in1k 73.454 26.546 91.34 8,66 3,77 224

  • Prise en charge du modèle de tour d'image Apple MobileCLIP (https://arxiv.org/pdf/2311.17049, FastViT et ViT-B) et ajout de poids (fait partie de la prise en charge d'OpenCLIP).

  • ViTamin (https://arxiv.org/abs/2404.02132) Modèle de tour d'image CLIP et poids ajoutés (fait partie du support OpenCLIP).

  • Modélisation de la tour d'image ResNet modifiée par OpenAI CLIP et prise en charge du poids (via ByobNet). Refactorisez AttentionPool2d.

14 mai 2024

  • Prise en charge du chargement des poids PaliGemma jax dans les modèles SigLIP ViT avec pooling moyen.

  • Ajoutez des modèles Hiera à partir de Meta (https://github.com/facebookresearch/hiera).

  • Ajoutez un indicateur normalize= pour les transformations, renvoyez torch.Tensor non normalisé avec le dytpe d'origine (pour chug )

  • Version 1.0.3

11 mai 2024

  • Searching for Better ViT Baselines (For the GPU Poor) et de variantes de vit publiées. Explorer les formes de modèles entre Tiny et Base.

modèle top1 top5 param_count img_size
vit_mediumd_patch16_reg4_gap_256.sbb_in12k_ft_in1k 86.202 97.874 64.11 256
vit_betwixt_patch16_reg4_gap_256.sbb_in12k_ft_in1k 85.418 97.48 60,4 256
vit_mediumd_patch16_rope_reg1_gap_256.sbb_in1k 84.322 96.812 63,95 256
vit_betwixt_patch16_rope_reg4_gap_256.sbb_in1k 83.906 96.684 60.23 256
vit_base_patch16_rope_reg1_gap_256.sbb_in1k 83.866 96,67 86.43 256
vit_medium_patch16_rope_reg1_gap_256.sbb_in1k 83,81 96.824 38,74 256
vit_betwixt_patch16_reg4_gap_256.sbb_in1k 83.706 96.616 60,4 256
vit_betwixt_patch16_reg1_gap_256.sbb_in1k 83.628 96.544 60,4 256
vit_medium_patch16_reg4_gap_256.sbb_in1k 83.47 96.622 38,88 256
vit_medium_patch16_reg1_gap_256.sbb_in1k 83.462 96.548 38,88 256
vit_little_patch16_reg4_gap_256.sbb_in1k 82.514 96.262 22.52 256
vit_wee_patch16_reg1_gap_256.sbb_in1k 80.256 95.360 13h42 256
vit_pwee_patch16_reg1_gap_256.sbb_in1k 80.072 95.136 15h25 256
vit_mediumd_patch16_reg4_gap_256.sbb_in12k N / A N / A 64.11 256
vit_betwixt_patch16_reg4_gap_256.sbb_in12k N / A N / A 60,4 256

  • Assistant AttentionExtract ajouté pour extraire les cartes d'attention des modèles timm . Voir exemple dans #1232 (commentaire)

  • L'API forward_intermediates() a été affinée et ajoutée à davantage de modèles, y compris certains ConvNets dotés d'autres méthodes d'extraction.

  • 1 017 des 1 047 architectures de modèles prennent en charge features_only=True Feature Extraction. Les 34 architectures restantes peuvent être prises en charge, mais en fonction des demandes prioritaires.

  • Supprimez les fonctions annotées torch.jit.script, y compris les anciennes activations JIT. Conflit avec la dynamo et la dynamo fait un bien meilleur travail lorsqu'elle est utilisée.

11 avril 2024

  • En préparation d'une version 1.0 attendue depuis longtemps, les choses sont stables depuis un certain temps maintenant.

  • Fonctionnalité importante qui manquait depuis un certain temps, features_only=True support pour les modèles ViT avec des états cachés plats ou des dispositions de modules non standard (couvrant jusqu'à présent 'vit_*', 'twins_*', 'deit*', 'beit*', 'mvitv2*', 'eva*', 'samvit_*', 'flexivit*' )

  • Prise en charge des fonctionnalités ci-dessus obtenue grâce à une nouvelle API forward_intermediates() qui peut être utilisée avec un module d'encapsulation de fonctionnalités ou directement.

 model = timm.create_model('vit_base_patch16_224')final_feat, intermédiaires = model.forward_intermediates(input)
 sortie = model.forward_head(final_feat) # pooling + classificateur headprint(final_feat.shape)torch.Size([2, 197, 768])pour f dans les intermédiaires:print(f.shape)torch.Size([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torche .Taille([2, 768, 14, 14])torche.Taille([2, 768, 14, 14])torch.Size([2, 768, 14, 14])torch.Size([2, 768, 14, 14])torch.Size([2, 768, 14, 14])torch.Size ([2, 768, 14, 14])print(output.shape)torch.Size([2, 1000])
 model = timm.create_model('eva02_base_patch16_clip_224', pretrained=True, img_size=512,features_only=True, out_indices=(-3, -2,))output = model(torch.randn(2, 3, 512, 512)) pour o en sortie : print(o.shape)
   torche.Taille([2, 768, 32, 32])torche.Taille([2, 768, 32, 32])

  • Ajout des poids de la tour de vision TinyCLIP, merci Thien Tran

19 février 2024

  • Modèles Next-ViT ajoutés. Adapté de https://github.com/bytedance/Next-ViT

  • Modèles HGNet et PP-HGNetV2 ajoutés. Adapté de https://github.com/PaddlePaddle/PaddleClas par SeeFun

  • Suppression de setup.py, déplacement vers une version basée sur pyproject.toml prise en charge par PDM

  • Ajoutez un modèle EMA mis à jour en utilisant _for_each pour moins de frais généraux

  • Prise en charge des arguments de périphérique dans le script de train pour les périphériques non GPU

  • Autres correctifs divers et petits ajouts

  • La version minimale de Python prise en charge est passée à 3,8

  • Version 0.9.16

8 janvier 2024

Ensembles de données et refactorisation des transformations

  • Prise en charge des ensembles de données de streaming HuggingFace (itérables) ( --dataset hfids:org/dataset )

  • Ajustements du wrapper de l'ensemble de données Web pour une récupération améliorée des informations sur les fractionnements, peut récupérer automatiquement les fractionnements à partir de l'ensemble de données Web du hub HF pris en charge

  • datasets HF testés et streaming de wrapper d'ensembles de données Web à partir du hub HF avec les récents téléchargements timm ImageNet sur https://huggingface.co/timm

  • Rendre les clés de colonne/champ d'entrée et cibles cohérentes entre les ensembles de données et les transmettre via les arguments

  • Prise en charge monochrome complète lors de l'utilisation de e:g : --input-size 1 224 224 ou --in-chans 1 , définit la conversion d'image PIL de manière appropriée dans l'ensemble de données

  • Amélioration de plusieurs transformations alternatives de recadrage et de redimensionnement (ResizeKeepRatio, RandomCropOrPad, etc.) pour une utilisation dans le projet d'IA de document PixParse

  • Ajoutez un problème de gigue de couleur de style SimCLR ainsi que des options d'échelle de gris et de flou gaussien aux augmentations et aux arguments.

  • Autoriser le train sans ensemble de validation ( --val-split '' ) dans le script de train

  • Ajoutez les arguments --bce-sum (somme sur classe dim) et --bce-pos-weight (pondération positive) pour l'entraînement car ce sont des ajustements courants de perte de BCE. Je codais souvent en dur.

23 novembre 2023

  • Ajout des modèles EfficientViT-Large, merci SeeFun

  • Correction de la compatibilité Python 3.7, la prise en charge sera bientôt supprimée

  • Autres correctifs divers

  • Version 0.9.12

20 novembre 2023

  • Ajout d'une flexibilité significative pour les modèles timm basés sur Hugging Face Hub via l'entrée de configuration model_args . model_args sera transmis en tant que kwargs aux modèles lors de la création.

    • Voir l'exemple sur https://huggingface.co/gaunernst/vit_base_patch16_1024_128.audiomae_as2m_ft_as20k/blob/main/config.json

    • Utilisation : #2035

  • Fichiers CSV d'évaluation et de test Imagenet mis à jour avec les derniers modèles

  • Saisie de vision_transformer.py et nettoyage de la doc par Laureηt

  • version 0.9.11

3 novembre 2023

  • Ajout des poids DFN (Data Filtering Networks) et MetaCLIP ViT

  • Ajout des poids du modèle ViT « d'enregistrement » DINOv2 (https://huggingface.co/papers/2309.16588, https://huggingface.co/papers/2304.07193)

  • Ajouter des variantes quickgelu ViT pour les poids OpenAI, DFN, MetaCLIP qui l'utilisent (moins efficace)

  • Saisie améliorée ajoutée à ResNet, MobileNet-v3 grâce à Aryan

  • ImageNet-12k affiné (à partir du CLIP LAION-2B) convnext_xxlarge

  • version 0.9.9

20 octobre 2023

  • Poids des tours d'images SigLIP pris en charge dans vision_transformer.py .

    • Grand potentiel pour le réglage fin et l’utilisation des fonctionnalités en aval.

  • Prise en charge expérimentale des « registres » dans les modèles vit selon Vision Transformers Need Registers

  • RepViT mis à jour avec une nouvelle version de poids. Merci Wangao

  • Ajouter la prise en charge du redimensionnement des patchs (sur charge de poids pré-entraînée) aux modèles Swin

  • Version 0.9.8 en attente

1 septembre 2023

  • TinyViT ajouté par SeeFun

  • Correction d'EfficientViT (MIT) pour utiliser torch.autocast afin qu'il fonctionne à nouveau vers PT 1.10

  • version 0.9.7

Introduction

Py T orch Im age Models ( timm ) est une collection de modèles d'image, de couches, d'utilitaires, d'optimiseurs, de planificateurs, de chargeurs/augmentations de données et de scripts de formation/validation de référence qui visent à rassembler une grande variété de modèles SOTA avec capacité pour reproduire les résultats de la formation ImageNet.

Le travail de beaucoup d’autres est présent ici. J'ai essayé de m'assurer que tous les documents sources sont reconnus via des liens vers github, des articles arxiv, etc. dans les docstrings README, la documentation et le code. S'il vous plaît laissez-moi savoir si j'ai raté quelque chose.

Caractéristiques

Modèles

Toutes les familles d'architecture de modèle incluent des variantes avec des poids pré-entraînés. Il existe des variantes de modèles spécifiques sans aucun poids, ce n'est PAS un bug. L’aide à l’entraînement de poids nouveaux ou meilleurs est toujours appréciée.

  • Agrégation de transformateurs imbriqués - https://arxiv.org/abs/2105.12723

  • BEiT - https://arxiv.org/abs/2106.08254

  • Grand transfert ResNetV2 (BiT) - https://arxiv.org/abs/1912.11370

  • Transformateurs de goulot d'étranglement - https://arxiv.org/abs/2101.11605

  • CaiT (Attention de classe dans les transformateurs d'images) - https://arxiv.org/abs/2103.17239

  • CoaT (Transformateurs d'images Conv-Attentionnels Co-Scale) - https://arxiv.org/abs/2104.06399

  • CoAtNet (Convolution et Attention) - https://arxiv.org/abs/2106.04803

  • ConvNeXt - https://arxiv.org/abs/2201.03545

  • ConvNeXt-V2 - http://arxiv.org/abs/2301.00808

  • ConViT (Transformateurs de vision à biais inductifs convolutifs doux) - https://arxiv.org/abs/2103.10697

  • CspNet (réseaux partiels multi-étapes) - https://arxiv.org/abs/1911.11929

  • DeiT - https://arxiv.org/abs/2012.12877

  • DeiT-III - https://arxiv.org/pdf/2204.07118.pdf

  • DenseNet - https://arxiv.org/abs/1608.06993

  • DLA - https://arxiv.org/abs/1707.06484

  • DPN (réseau à double chemin) - https://arxiv.org/abs/1707.01629

  • EdgeNeXt - https://arxiv.org/abs/2206.10589

  • EfficaceFormer - https://arxiv.org/abs/2206.01191

  • EfficientNet (famille MBConvNet)

    • EfficientNet NoisyStudent (B0-B7, L2) - https://arxiv.org/abs/1911.04252

    • EfficientNet AdvProp (B0-B8) - https://arxiv.org/abs/1911.09665

    • EfficaceNet (B0-B7) - https://arxiv.org/abs/1905.11946

    • EfficientNet-EdgeTPU (S, M, L) - https://ai.googleblog.com/2019/08/efficientnet-edgetpu-creating.html

    • EfficientNet V2 - https://arxiv.org/abs/2104.00298

    • FBNet-C - https://arxiv.org/abs/1812.03443

    • MixNet - https://arxiv.org/abs/1907.09595

    • MNASNet B1, A1 (Squeeze-Excite) et Small - https://arxiv.org/abs/1807.11626

    • MobileNet-V2 - https://arxiv.org/abs/1801.04381

    • NAS à chemin unique - https://arxiv.org/abs/1904.02877

    • TinyNet - https://arxiv.org/abs/2010.14819

  • EfficientViT (MIT) - https://arxiv.org/abs/2205.14756

  • EfficientViT (MSRA) - https://arxiv.org/abs/2305.07027

  • EVA-https://arxiv.org/abs/2211.07636

  • EVA-02 - https://arxiv.org/abs/2303.11331

  • FastViT - https://arxiv.org/abs/2303.14189

  • FlexiViT - https://arxiv.org/abs/2212.08013

  • FocalNet (Réseaux de modulation focale) - https://arxiv.org/abs/2203.11926

  • GCViT (Transformateur de vision de contexte global) - https://arxiv.org/abs/2206.09959

  • GhostNet - https://arxiv.org/abs/1911.11907

  • GhostNet-V2 - https://arxiv.org/abs/2211.12905

  • gMLP - https://arxiv.org/abs/2105.08050

  • Réseaux efficaces pour le GPU - https://arxiv.org/abs/2006.14090

  • Filets Halo - https://arxiv.org/abs/2103.12731

  • HGNet / HGNet-V2 - À déterminer

  • HRNet - https://arxiv.org/abs/1908.07919

  • InceptionNeXt - https://arxiv.org/abs/2303.16900

  • Inception-V3 - https://arxiv.org/abs/1512.00567

  • Inception-ResNet-V2 et Inception-V4 - https://arxiv.org/abs/1602.07261

  • Réseaux Lambda - https://arxiv.org/abs/2102.08602

  • LeViT (Vision Transformer dans les vêtements de ConvNet) - https://arxiv.org/abs/2104.01136

  • MaxViT (Transformateur de vision multi-axes) - https://arxiv.org/abs/2204.01697

  • MetaFormer (PoolFormer-v2, ConvFormer, CAFormer) - https://arxiv.org/abs/2210.13452

  • MLP-Mixer - https://arxiv.org/abs/2105.01601

  • MobileCLIP - https://arxiv.org/abs/2311.17049

  • MobileNet-V3 (MBConvNet avec tête efficace) - https://arxiv.org/abs/1905.02244

    • FBNet-V3 - https://arxiv.org/abs/2006.02049

    • HardCoRe-NAS - https://arxiv.org/abs/2102.11646

    • LCNet - https://arxiv.org/abs/2109.15099

  • MobileNetV4 - https://arxiv.org/abs/2404.10518

  • MobileOne - https://arxiv.org/abs/2206.04040

  • MobileViT - https://arxiv.org/abs/2110.02178

  • MobileViT-V2 - https://arxiv.org/abs/2206.02680

  • MViT-V2 (Transformateur de vision multi-échelle amélioré) - https://arxiv.org/abs/2112.01526

  • NASNet-A - https://arxiv.org/abs/1707.07012

  • NeT - https://arxiv.org/abs/2105.12723

  • Suivant-ViT - https://arxiv.org/abs/2207.05501

  • NFNet-F - https://arxiv.org/abs/2102.06171

  • NF-RegNet / NF-ResNet - https://arxiv.org/abs/2101.08692

  • PNasNet - https://arxiv.org/abs/1712.00559

  • PoolFormer (MetaFormer) - https://arxiv.org/abs/2111.11418

  • Transformateur de vision basé sur la mise en commun (PiT) - https://arxiv.org/abs/2103.16302

  • PVT-V2 (Transformateur de vision pyramidale amélioré) - https://arxiv.org/abs/2106.13797

  • RDNet (DenseNets rechargés) - https://arxiv.org/abs/2403.19588

  • RegNet - https://arxiv.org/abs/2003.13678

  • RegNetZ - https://arxiv.org/abs/2103.06877

  • RepVGG - https://arxiv.org/abs/2101.03697

  • RepGhostNet - https://arxiv.org/abs/2211.06088

  • RepViT - https://arxiv.org/abs/2307.09283

  • ResMLP - https://arxiv.org/abs/2105.03404

  • ResNet/ResNeXt

    • ResNet (v1b/v1.5) - https://arxiv.org/abs/1512.03385

    • ResNeXt - https://arxiv.org/abs/1611.05431

    • 'Sac d'astuces' / Variations Gluon C, D, E, S - https://arxiv.org/abs/1812.01187

    • Instagram faiblement supervisé (WSL) pré-entraîné / ImageNet optimisé ResNeXt101 - https://arxiv.org/abs/1805.00932

    • Semi-supervisé (SSL) / Semi-faiblement supervisé (SWSL) ResNet/ResNeXts - https://arxiv.org/abs/1905.00546

    • ECA-Net (ECAREsNet) - https://arxiv.org/abs/1910.03151v4

    • Réseaux de compression et d'excitation (SEResNet) - https://arxiv.org/abs/1709.01507

    • ResNet-RS - https://arxiv.org/abs/2103.07579

  • Res2Net - https://arxiv.org/abs/1904.01169

  • ResNeSt - https://arxiv.org/abs/2004.08955

  • ReXNet - https://arxiv.org/abs/2007.00992

  • SelecSLS - https://arxiv.org/abs/1907.00837

  • Réseaux de noyau sélectifs - https://arxiv.org/abs/1903.06586

  • Séquenceur2D - https://arxiv.org/abs/2205.01972

  • Swin S3 (AutoFormerV2) - https://arxiv.org/abs/2111.14725

  • Transformateur Swin - https://arxiv.org/abs/2103.14030

  • Swin Transformateur V2 - https://arxiv.org/abs/2111.09883

  • Transformateur-iN-Transformer (TNT) - https://arxiv.org/abs/2103.00112

  • TResNet - https://arxiv.org/abs/2003.13630

  • Jumeaux (Attention spatiale dans les transformateurs de vision) - https://arxiv.org/pdf/2104.13840.pdf

  • Visformateur - https://arxiv.org/abs/2104.12533

  • Transformateur de vision - https://arxiv.org/abs/2010.11929

  • ViTamin - https://arxiv.org/abs/2404.02132

  • VOLO (Vision Outlooker) - https://arxiv.org/abs/2106.13112

  • VovNet V2 et V1 - https://arxiv.org/abs/1911.06667

  • Xception - https://arxiv.org/abs/1610.02357

  • Xception (aligné modifié, Gluon) - https://arxiv.org/abs/1802.02611

  • Xception (Modifié Aligné, TF) - https://arxiv.org/abs/1802.02611

  • XCiT (Transformateurs d'images à covariance croisée) - https://arxiv.org/abs/2106.09681

Optimiseurs

Optimiseurs inclus disponibles via les méthodes d'usine create_optimizer / create_optimizer_v2 :

  • adabelief une implémentation d'AdaBelief adaptée de https://github.com/juntang-zhuang/Adabelief-Optimizer - https://arxiv.org/abs/2010.07468

  • adafactor adapté de FAIRSeq impl - https://arxiv.org/abs/1804.04235

  • adahessian par David Samuel - https://arxiv.org/abs/2006.00719

  • adamp et sgdp par Naver ClovAI - https://arxiv.org/abs/2006.08217

  • adan une implémentation d'Adan adaptée de https://github.com/sail-sg/Adan - https://arxiv.org/abs/2208.06677

  • lamb une implémentation de Lamb et LambC (avec trust-clipping) nettoyée et modifiée pour prendre en charge l'utilisation avec XLA - https://arxiv.org/abs/1904.00962

  • lars une implémentation de LARS et LARC (avec trust-clipping) - https://arxiv.org/abs/1708.03888

  • lion et implémentation de Lion adapté de https://github.com/google/automl/tree/master/lion - https://arxiv.org/abs/2302.06675

  • lookahead adapté de impl par Liam - https://arxiv.org/abs/1907.08610

  • madgrad - et implémentation de MADGRAD adaptée de https://github.com/facebookresearch/madgrad - https://arxiv.org/abs/2101.11075

  • nadam une implémentation d'Adam avec l'élan Nesterov

  • nadamw une implémentation d'AdamW (Adam avec décroissance du poids découplée) avec élan de Nesterov. Un impl simplifié basé sur https://github.com/mlcommons/algorithmic-efficiency

  • novograd par Masashi Kimura - https://arxiv.org/abs/1905.11286

  • radam par Liyuan Liu - https://arxiv.org/abs/1908.03265

  • rmsprop_tf adapté de PyTorch RMSProp par moi-même. Reproduit le comportement Tensorflow RMSProp bien amélioré

  • sgdw et implémentation de SGD avec décroissance du poids découplée

  • optimiseurs fused<name> par nom avec NVIDIA Apex installé

  • optimiseurs bits<name> par nom avec BitsAndBytes installés

Augmentations

  • Effacement aléatoire de Zhun Zhong - https://arxiv.org/abs/1708.04896)

  • Mélange - https://arxiv.org/abs/1710.09412

  • CutMix - https://arxiv.org/abs/1905.04899

  • Configurations AutoAugment (https://arxiv.org/abs/1805.09501) et RandAugment (https://arxiv.org/abs/1909.13719) ImageNet modélisées d'après impl pour la formation EfficientNet (https://github.com/tensorflow/tpu/ blob/master/models/official/efficientnet/autoaugment.py)

  • AugMix avec perte JSD, JSD avec prise en charge du mixage clean + augmenté fonctionne également avec AutoAugment et RandAugment - https://arxiv.org/abs/1912.02781

  • SplitBachNorm - permet de diviser les couches de normes de lot entre les données propres et augmentées (norme de lot auxiliaire)

Régularisation

  • DropPath alias "Profondeur stochastique" - https://arxiv.org/abs/1603.09382

  • DropBlock - https://arxiv.org/abs/1810.12890

  • Regroupement de flou - https://arxiv.org/abs/1904.11486

Autre

Plusieurs fonctionnalités (moins courantes) que j'utilise souvent dans mes projets sont incluses. Beaucoup de leurs ajouts sont la raison pour laquelle je maintiens mon propre ensemble de modèles, au lieu d'utiliser ceux des autres via PIP :

  • Tous les modèles ont une interface de configuration par défaut commune et une API pour

    • accéder/modifier le classificateur - get_classifier et reset_classifier

    • faire une transmission directe uniquement sur les fonctionnalités - forward_features (voir la documentation)

    • cela facilite l'écriture de wrappers réseau cohérents qui fonctionnent avec n'importe lequel des modèles

  • Tous les modèles prennent en charge l'extraction de cartes de fonctionnalités multi-échelles (pyramides de fonctionnalités) via create_model (voir documentation)

    • create_model(name, features_only=True, out_indices=..., output_stride=...)

    • out_indices Creation arg spécifie les cartes de fonctionnalités à renvoyer, ces indices sont basés sur 0 et correspondent généralement au niveau de fonctionnalité C(i + 1) .

    • output_stride Creation arg contrôle la foulée de sortie du réseau en utilisant des convolutions dilatées. La plupart des réseaux utilisent le stride 32 par défaut. Tous les réseaux ne le prennent pas en charge.

    • Le nombre de canaux de la carte des fonctionnalités, le niveau de réduction (foulée) peuvent être interrogés APRÈS la création du modèle via le membre .feature_info

  • Tous les modèles disposent d'un chargeur de poids pré-entraîné cohérent qui adapte le dernier linéaire si nécessaire, et de 3 à 1 canal d'entrée si vous le souhaitez.

  • Scripts de formation de référence, de validation et d'inférence hautes performances qui fonctionnent dans plusieurs modes de processus/GPU :

    • NVIDIA DDP avec un seul GPU par processus, plusieurs processus avec APEX présent (AMP à précision mixte en option)

    • PyTorch DistributedDataParallel avec multi-gpu, processus unique (AMP désactivé car il plante lorsqu'il est activé)

    • PyTorch avec un seul processus GPU (AMP en option)

  • Une implémentation de pool global dynamique qui permet de sélectionner parmi le pooling moyen, le pooling maximum, moyenne + max ou concat([average, max]) lors de la création du modèle. Toutes les mises en commun globales sont une moyenne adaptative par défaut et compatibles avec les poids pré-entraînés.

  • Un wrapper « Test Time Pool » qui peut envelopper n'importe lequel des modèles inclus et offre généralement des performances améliorées lors de l'inférence avec des images d'entrée plus grandes que la taille d'entraînement. Idée adaptée de l'implémentation originale du DPN lors du portage (https://github.com/cypw/DPNs)

  • Planificateurs de taux d'apprentissage

    • Planificateurs AllenNLP

    • FAIRseq lr_scheduler

    • SGDR : descente de gradient stochastique avec redémarrages à chaud (https://arxiv.org/abs/1608.03983)

    • Idées adoptées de

    • Les planificateurs incluent step , cosine avec redémarrages, tanh avec redémarrages, plateau

  • Space-to-Depth par mrT23 (https://arxiv.org/abs/1801.04590) -- article original ?

  • Découpage de dégradé adaptatif (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)

  • Une vaste sélection de modules d’attention canalisée et/ou spatiale :

    • Transformateur de goulot d'étranglement - https://arxiv.org/abs/2101.11605

    • CBAM - https://arxiv.org/abs/1807.06521

    • Squeeze-Excitation efficace (ESE) - https://arxiv.org/abs/1911.06667

    • Attention de canal efficace (ECA) - https://arxiv.org/abs/1910.03151

    • Rassembler-Exciter (GE) - https://arxiv.org/abs/1810.12348

    • Contexte global (GC) - https://arxiv.org/abs/1904.11492

    • Halo - https://arxiv.org/abs/2103.12731

    • Involution - https://arxiv.org/abs/2103.06255

    • Couche Lambda - https://arxiv.org/abs/2102.08602

    • Non local (NL) - https://arxiv.org/abs/1711.07971

    • Compression et excitation (SE) - https://arxiv.org/abs/1709.01507

    • Noyau sélectif (SK) - (https://arxiv.org/abs/1903.06586

    • Divisé (SPLAT) - https://arxiv.org/abs/2004.08955

    • Fenêtre décalée (SWIN) - https://arxiv.org/abs/2103.14030

Résultats

Les résultats de la validation du modèle peuvent être trouvés dans les tableaux de résultats

Premiers pas (documentation)

La documentation officielle peut être trouvée sur https://huggingface.co/docs/hub/timm. Les contributions à la documentation sont les bienvenues.

Premiers pas avec les modèles d'image PyTorch (timm) : Guide du praticien par Chris Hughes est un article de blog détaillé couvrant de nombreux aspects de timm en détail.

timmdocs est un ensemble alternatif de documentation pour timm . Un grand merci à Aman Arora pour ses efforts de création de timmdocs.

paperswithcode est une bonne ressource pour parcourir les modèles dans timm .

Scripts de formation, de validation et d'inférence

Le dossier racine du référentiel contient des scripts de train de référence, de validation et d'inférence qui fonctionnent avec les modèles inclus et d'autres fonctionnalités de ce référentiel. Ils sont adaptables à d’autres ensembles de données et cas d’utilisation avec un peu de piratage. Voir la documentation.

Ressources PyTorch impressionnantes

L'un des plus grands atouts de PyTorch est la communauté et ses contributions. Quelques-unes de mes ressources préférées qui se marient bien avec les modèles et composants ici sont répertoriées ci-dessous.

Détection d'objets, instance et segmentation sémantique

  • Détectron2 - https://github.com/facebookresearch/detectron2

  • Modèles de segmentation (sémantique) - https://github.com/qubvel/segmentation_models.pytorch

  • EfficientDet (Obj Det, sémantique bientôt) - https://github.com/rwightman/efficientdet-pytorch

Vision par ordinateur / Augmentation d'image

  • Albumentations - https://github.com/albumentations-team/albumentations

  • Kornia - https://github.com/kornia/kornia

Distillation des connaissances

  • RepDistiller - https://github.com/HobbitLong/RepDistiller

  • torchdistill - https://github.com/yoshitomo-matsubara/torchdistill

Apprentissage métrique

  • Apprentissage métrique PyTorch - https://github.com/KevinMusgrave/pytorch-metric-learning

Formation / Cadres

  • fastai - https://github.com/fastai/fastai

Licences

Code

Le code ici est sous licence Apache 2.0. J'ai pris soin de m'assurer que tout code tiers inclus ou adapté dispose de licences compatibles (permissives) telles que MIT, BSD, etc. J'ai fait un effort pour éviter tout conflit GPL/LGPL. Cela dit, il est de votre responsabilité de vous assurer que vous respectez les licences ici et les conditions de toutes les licences dépendantes. Le cas échéant, j'ai lié les sources/références de divers composants dans des docstrings. Si vous pensez que j'ai raté quelque chose, veuillez créer un problème.

Poids pré-entraînés

Jusqu'à présent, tous les poids pré-entraînés disponibles ici sont pré-entraînés sur ImageNet, avec quelques-uns sélectionnés qui disposent d'un pré-entraînement supplémentaire (voir note supplémentaire ci-dessous). ImageNet a été publié uniquement à des fins de recherche non commerciales (https://image-net.org/download). On ne sait pas quelles en sont les implications pour l'utilisation de poids pré-entraînés à partir de cet ensemble de données. Tous les modèles que j'ai formés avec ImageNet sont réalisés à des fins de recherche et il faut supposer que la licence de l'ensemble de données d'origine s'applique aux poids. Il est préférable de demander un avis juridique si vous avez l'intention d'utiliser les poids pré-entraînés dans un produit commercial.

Pré-entraîné sur plus qu'ImageNet

Plusieurs poids inclus ou références ici ont été pré-entraînés avec des ensembles de données propriétaires auxquels je n'ai pas accès. Il s'agit notamment des modèles Facebook WSL, SSL, SWSL ResNe(Xt) et Google Noisy Student EfficientNet. Les modèles Facebook ont ​​une licence non commerciale explicite (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images) . Les modèles Google ne semblent pas avoir de restriction au-delà de la licence Apache 2.0 (et des préoccupations ImageNet). Dans les deux cas, vous devez contacter Facebook ou Google avec des questions.

Citant

BibTeX

 @Misc {rw2019TIMM, auteur = {Ross Wightman}, title = {Pytorch Image Models}, année = {2019}, éditeur = {github}, journal = {github Repository}, DOI = {10.5281 / zenodo.4414861}, howpubliqué = {url {https://github.com/rwightman/pytorch-image-models}}}
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout