Familles de modèles

timm dispose de 1371 architectures réparties en 98 familles de modèles, avec 1826 poids pré-entraînés. Chaque page de famille répertorie les articles, les architectures et les poids pré-entraînés d’un module de modèle, ainsi que les parties de l’API des modèles prises en charge par ses modèles. Consultez le Démarrage rapide pour charger et utiliser les modèles, la référence des modèles pour create_model et les configurations pré-entraînées, et les résultats pour les résultats de validation sur ImageNet de tous les poids.

Réseaux de convolution

• Aligned Xception (5 architectures, 6 poids) : Aligned Xception (41, 65, 71 couches) tel que modifié dans DeepLab, implémenté de zéro et compatible avec les poids TensorFlow de DeepLab.
• BYOBNet (GENet, RepVGG, MobileOne, …) (53 architectures, 57 poids) : Bring-Your-Own-Blocks Network, un réseau flexible construit à partir de configurations dataclass qui empilent des blocs en étapes. Il implémente les réseaux efficaces sur GPU (gernet_*), RepVGG, MobileOne, RegNetZ, les tours d’images ResNet de CLIP (*_clip) et un certain nombre de variantes timm de type ResNet.
• ConvMixer (3 architectures, 3 weights) : ConvMixer encode l’image sous forme de patches et conserve cette résolution tout au long du processus, en alternant des convolutions depthwise (mélange spatial) et des convolutions pointwise (mélange des canaux).
• ConvNeXt (31 architectures, 101 weights) : ConvNeXt est un réseau purement convolutif qui adopte des choix de conception issus des transformers de vision, tels que de grands noyaux en profondeur, des goulets d'étranglement inversés et LayerNorm. ConvNeXt-V2 ajoute la Global Response Normalization (GRN) et est pré-entraîné comme un auto-encodeur masqué entièrement convolutif (FCMAE).
• CSPNet (CSPResNet, CSPDarkNet, DarkNet) (23 architectures, 15 weights) : Cross Stage Partial Networks divise les caractéristiques de chaque étape en deux parties, l’une passant par les blocs de l’étape et l’autre fusionnée à la fin de l’étape. Ce module contient CSPResNet, CSPResNeXt, CSPDarkNet, DarkNet et les variantes timm cs3*.
• CSPNeXt (5 architectures, 5 poids) : le backbone CSPNeXt du détecteur d'objets en temps réel RTMDet (blocs CSP avec des convolutions depthwise 5x5), avec des poids de classification ImageNet-1k convertis à partir des checkpoints OpenMMLab.
• DenseNet (6 architectures, 6 poids) : réseaux de convolution à connexions denses, où chaque couche d'un bloc dense reçoit les sorties concaténées de toutes les couches précédentes du bloc. Adapté de torchvision, densenetblur utilise le blur pool pour un sous-échantillonnage anti-aliasé.
• DLA (12 architectures, 12 weights) : les réseaux Deep Layer Aggregation (DLA) fusionnent les caractéristiques à travers les blocs et les étapes au moyen de nœuds d’agrégation itératifs et hiérarchiques. Inclut des variantes de DLA construites à partir de blocs Res2Net.
• DPN (7 architectures, 7 poids) : les Dual Path Networks combinent un chemin résiduel (réutilisation des caractéristiques) et un chemin à connexions denses (exploration de nouvelles caractéristiques) dans chaque bloc. Compatible avec les poids de l'implémentation MXNet originale.
• HRNet (11 architectures, 14 weights) : les High-Resolution Networks conservent une branche haute résolution tout au long du réseau et ajoutent des branches basse résolution en parallèle, en échangeant de manière répétée des informations entre elles.
• Inception-ResNet-v2 (1 architecture, 2 weights) : Inception-ResNet-v2 combine les modules Inception avec des connexions résiduelles. Porté depuis l'implémentation et les poids TensorFlow.
• Inception-v3 (1 architecture, 4 poids) : Inception-v3, adapté du modèle Inception3 de torchvision.
• Inception-v4 (1 architecture, 1 poids) : Inception-v4, porté depuis l’implémentation et les poids TensorFlow.
• InceptionNeXt (4 architectures, 5 poids) : InceptionNeXt décompose la convolution en profondeur à noyau large de ConvNeXt en branches parallèles, un petit noyau carré, deux noyaux de bande orthogonaux et une identité, suivant Inception.
• MambaOut (11 architectures, 12 weights) : MambaOut empile des blocs Gated CNN et des blocs Mamba sans le mélangeur de jetons du modèle d'espace d'état (SSM), afin de tester si les SSM sont nécessaires pour la classification d'images.
• NASNet (1 architecture, 1 poids) : NASNet-A Large, un réseau de cellules découvert par recherche d’architecture neuronale, issu du port des modèles pré-entraînés de Cadene.
• NFNet (36 architectures, 14 poids) : réseaux sans normalisation, entraînés sans normalisation par lot en utilisant la standardisation pondérée mise à l'échelle : modèles NFNet (avec élagage adaptatif des gradients), NF-RegNet et NF-ResNet pré-activation.
• PNASNet (1 architecture, 1 weight) : PNASNet-5 Large, trouvée par recherche progressive d’architectures neuronales, issue du port des modèles pré-entraînés de Cadene.
• PP-HGNet (10 architectures, 19 weights) : PP-HGNet et PP-HGNetV2 (High Performance GPU Net) de PaddleClas, construits à partir de blocs HG qui agrègent les sorties d’une séquence de convolutions. Les poids ssld sont entraînés avec la distillation SSLD de PaddleClas.
• RDNet (4 architectures, 5 weights) : RDNet (DenseNets Reloaded) réexamine les réseaux de convolution à connexions denses avec des blocs et des choix de conception modernisés.
• RegNet (36 architectures, 65 poids) : réseaux RegNetX et RegNetY issus des espaces de conception de réseaux réguliers, RegNetZ issu de « Fast and Accurate Model Scaling », ainsi que des ajouts de timm tels que RegNetV pré-activation. Inclut des poids provenant de pycls, torchvision et VISSL (SEER).
• Res2Net (9 architectures, 9 poids) : Res2Net divise les canaux du bloc bottleneck en groupes connectés hiérarchiquement, offrant plusieurs tailles de champ récepteur au sein d'un même bloc. Inclut Res2NeXt.
• ResNeSt (8 architectures, 8 poids) : ResNeSt utilise des blocs split-attention, une attention par canal sur des groupes de splits de cartes de caractéristiques, dans un réseau de style ResNet.
• ResNet (81 architectures, 150 poids) : réseaux résiduels (ResNet) et les variantes construites sur la même classe ResNet : convolutions groupées ResNeXt, attention de canal Squeeze-and-Excitation (SE) et ECA, tiges profondes / hiérarchisées et downsampling par moyenne (les variantes « c », « d », « s » et « t »), downsampling anti-aliasé, configurations Wide ResNet et ResNet-RS.
• ResNetV2 (BiT) (20 architectures, 24 weights) : Pre-activation ResNet (v2) avec Group Normalization et Weight Standardization, tel que utilisé par Big Transfer (BiT), avec les poids originaux de BiT. Prend également en charge la variante non pre-activation utilisée comme backbone hybride Vision Transformer.
• SelecSLS (5 architectures, 3 poids) : SelecSLS utilise des connexions de saut sélectives à longue et courte portée, proposées comme réseau principal de XNect, un système d'estimation de pose 3D multi-personnes en temps réel.
• SENet (legacy) (9 architectures, 9 poids) : SENet, SE-ResNet et SE-ResNeXt issus des modèles préentraînés de Cadene (legacy_*). Le module est obsolète au profit des variantes SE de la classe ResNet.
• SKNet (5 architectures, 3 poids) : Selective Kernel Networks sur une base ResNet, où les unités SK fusionnent des branches de différentes tailles de noyaux à l'aide d'une attention sur les branches.
• TResNet (4 architectures, 10 poids) : TResNet est une conception basée sur ResNet destinée à un débit GPU élevé, avec un tronc space-to-depth, un sous-échantillonnage anti-aliasé et des couches SE.
• VGG (8 architectures, 8 poids) : réseaux VGG composés de convolutions 3x3 empilées, adaptés de torchvision avec l’ajout des fonctionnalités de timm.
• VoVNet (10 architectures, 3 weights) : VoVNet utilise des modules One-Shot Aggregation (OSA), qui concatènent les sorties de toutes les couches d'un bloc une seule fois à la fin de celui-ci. VoVNetV2 (de CenterMask) ajoute des connexions résiduelles et une attention effective SE (eSE).
• Xception (legacy) (1 architecture, 1 weight) : le Xception d’origine, convolutions séparables en profondeur avec connexions résiduelles, avec des poids portés depuis Keras (legacy_xception).

Transformers de vision

• BEiT (7 architectures, 13 poids) : Vision Transformers BEiT et BEiT-v2, pré-entraînés avec du masked image modeling. BEiT prédit les jetons visuels discrets des patches masqués, tandis que BEiT-v2 utilise un tokeniseur visuel vector-quantized pour les cibles. Les poids présentés ici sont des poids de classification affinés.
• CaiT (10 architectures, 10 weights) : Class-Attention in Image Transformers (CaiT), des Vision Transformers profonds qui utilisent LayerScale et se terminent par des couches d’attention de classe, qui ne mettent à jour que le jeton de classe à partir des jetons de patch.
• ConViT (3 architectures, 3 weights) : ConViT remplace l'auto-attention des premiers blocs Vision Transformer par une auto-attention positionnelle à porte (GPSA), qui peut être initialisée pour se comporter comme une convolution, en tant que biais inductif convolutif doux.
• CrossViT (11 architectures, 11 weights) : CrossViT traite les petits et grands patches d’image dans deux branches Transformer distinctes et les fusionne par attention croisée à travers les jetons de classe. Les noms de modèles dans timm indiquent la résolution d’entrée réelle (240 / 408 au lieu des 224 / 384 d’origine).
• DaViT (8 architectures, 5 poids) : les Dual Attention Vision Transformers (DaViT) combinent l'attention sur les fenêtres spatiales et l'attention sur les groupes de canaux, toutes deux linéaires en fonction du nombre de jetons, dans une conception hiérarchique.
• DeiT (16 architectures, 24 weights) : les Data-efficient Image Transformers (DeiT) sont des Vision Transformers entraînés uniquement sur ImageNet-1k, éventuellement avec un jeton de distillation qui apprend à partir d’un enseignant CNN. Les modèles DeiT III sont entraînés avec une recette améliorée.
• EVA (65 architectures, 83 poids) : les Vision Transformers EVA et EVA-02 ainsi que d'autres variantes de ViT partageant la classe Eva, avec des embeddings de position rotatifs (RoPE), des MLP SwiGLU et des ajouts connexes. Le module contient également les modèles Perception Encoder (PE), ROPE-ViT, DINOv3, LingBot-Vision et Sapiens2, ainsi que les configurations ViT originales de timm avec RoPE.
• GCViT (5 architectures, 5 poids) : les Global Context Vision Transformers (GCViT) alternent l'attention sur des fenêtres locales et l'attention sur le contexte global, dont les requêtes sont générées à partir de la carte de caractéristiques entière par un module convolutif.
• Hiera (8 architectures, 16 poids) : Hiera est un vision transformer hiérarchique sans modules spécialisés (convolutions, fenêtres décalées, biais de position relatifs), qui s’appuie sur un pré-entraînement par auto-encodeur masqué (MAE) pour apprendre les biais spatiaux.
• HieraDet (SAM 2) (5 architectures, 8 poids) : HieraDet, l'encodeur d'images basé sur Hiera de Segment Anything 2 (SAM 2), avec attention par fenêtres et embeddings de position par fenêtres.
• MViTv2 (8 architectures, 7 poids) : Multiscale Vision Transformers v2, un transformer hiérarchique avec attention par pooling, embeddings de position relative décomposés et connexions résiduelles de pooling.
• NaFlex ViT (14 architectures, 11 poids) : un Vision Transformer avec l’incorporation de patches et le codage de position regroupés dans un seul module, prenant en charge les entrées pré-fragmentées avec un rapport d’aspect et une résolution variables (NaFlex), la taille de patch variable de FlexiViT et les embeddings de position factorisés de NaViT.
• NesT (6 architectures, 3 poids) : les Nested Transformers (NesT) appliquent l'auto-attention localement au sein de blocs d'image non chevauchants et agrègent les blocs voisins entre les étapes. Poids convertis depuis la version officielle JAX.
• PiT (8 architectures, 8 weights) : les Vision Transformers basés sur le pooling (PiT) réduisent la taille spatiale et augmentent le nombre de canaux des jetons entre les étapes à l'aide d'une couche de pooling par convolution en profondeur, comme dans les CNN.
• PVTv2 (7 architectures, 7 poids) : Pyramid Vision Transformer v2, un transformer hiérarchique doté d’une attention à réduction spatiale (linéaire dans la variante _li), d’embeddings de patches chevauchants et de couches feed-forward convolutives.
• Segment Anything ViT (4 architectures, 3 poids) : l’encodeur d’images ViT du Segment Anything Model (SAM), un backbone ViT simple avec des blocs d’attention fenêtrée et globale et des embeddings de position relative, comme dans ViTDet.
• Swin Transformer (9 architectures, 19 poids) : Swin Transformer est un transformer hiérarchique pour la vision qui calcule l'auto-attention au sein de fenêtres locales, décalées entre les blocs consécutifs pour les connexions inter-fenêtres. Inclut les poids S3 (AutoFormerV2).
• Swin Transformer V2 (12 architectures, 12 weights) : Swin Transformer V2 étend Swin avec une normalisation post-résiduelle, une attention cosinus mise à l’échelle et un biais de position relative continue à espacement logarithmique qui se transfère entre différentes tailles de fenêtres.
• Swin Transformer V2 (CR) (16 architectures, 3 poids) : une implémentation alternative de Swin Transformer V2 adaptée à partir du code de Christoph Reich, conçue pour modifier la taille de l’image conjointement avec la taille de la fenêtre, y compris pour des tailles non carrées. La docstring du module le marque comme expérimental.
• TNT (3 architectures, 3 poids) : Transformer in Transformer (TNT) modélise la structure à l'intérieur de chaque patch à l'aide d'un transformeur interne sur des sous-patches, en parallèle du transformeur externe sur les patches.
• Twins (6 architectures, 6 poids) : Twins-PCPVT (Pyramid Vision Transformer avec encodages de position conditionnels) et Twins-SVT (auto-attention spatialement séparable, attention localement groupée alternant avec une attention globale sous-échantillonnée).
• Vision Transformer (position relative) (14 architectures, 9 poids) : Vision Transformers utilisant des biais de position relative au lieu d'embeddings de position absolus. La docstring du module marque ces modèles comme expérimentaux.
• Vision Transformer (ViT) (163 architectures, 309 weights) : Le Vision Transformer (ViT) découpe une image en patches de taille fixe, les encode linéairement et traite la séquence de jetons résultante avec un encodeur Transformer standard. Ce module contient la classe VisionTransformer ainsi que les poids des modèles ViT originaux, « How to train your ViT? » (AugReg) et FlexiViT, et de nombreuses tours d'images pré-entraînées par apprentissage auto-supervisé ou image-texte (CLIP, SigLIP) qui partagent cette architecture.
• VOLO (11 architectures, 11 weights) : Vision Outlooker (VOLO) ajoute l'attention outlook, qui encode les caractéristiques de niveau fin à partir des voisinages locaux, avant les étapes transformer qui opèrent sur des jetons plus grossiers.
• XCiT (28 architectures, 42 weights) : les Cross-Covariance Image Transformers (XCiT) remplacent l'auto-attention des jetons par une attention de covariance croisée entre les canaux de caractéristiques, linéaire en fonction du nombre de jetons, et ajoutent des couches d'interaction locale des patches.

Réseaux hybrides convolution / attention

• BYOANet (BoTNet, HaloNet, LambdaNet) (15 architectures, 13 poids) : réseaux construits avec le système de configuration de blocs / étages ByobNet qui place des couches d'auto-attention (ou similaires) dans des étages de type ResNet : Bottleneck Transformers (BoTNet), HaloNets et Lambda ResNets. La docstring du module marque ces définitions comme expérimentales.
• CoaT (8 architectures, 8 weights) : les Co-Scale Conv-Attentional Image Transformers (CoaT) utilisent une attention factorisée avec des encodages de position relative basés sur des convolutions, ainsi qu’un mécanisme co-scale qui échange des informations entre des blocs parallèles à différentes échelles.
• CSATv2 (2 architectures, 3 weights) : CSATv2 est un modèle de vision dans le domaine fréquentiel qui fonctionne sur les transformées DCT de l'image d'entrée, avec une attention spatiale.
• FocalNet (12 architectures, 12 weights) : les Focal Modulation Networks (FocalNet) remplacent l'auto-attention par la focal modulation, qui agrège le contexte à plusieurs granularités à l'aide de convolutions en profondeur et le module pour chaque jeton de requête.
• Hybrid Vision Transformer (14 architectures, 14 weights) : Vision Transformers dont les jetons de patch proviennent d'un tronc convolutif (tronc ou étapes de ResNet / ResNetV2) plutôt que d'un encodage de patch linéaire, en utilisant la classe VisionTransformer.
• LeViT (20 architectures, 10 poids) : LeViT est un réseau hybride pour une inférence rapide, composé d'un tronc convolutif suivi de stages d'attention qui réduisent la résolution par un downsampling basé sur l'attention et utilisent des biais d'attention pour la position.
• MaxViT et CoAtNet (58 architectures, 52 poids) : implémentations de MaxViT (blocs MBConv avec attention multi-axes, attention locale et dilatée sur grille bloquée) et de CoAtNet (étapes de convolution suivies d’étapes d’attention relative), ainsi que des variantes timm (configurations _rw, MaxxViT).
• MetaFormer (PoolFormer, ConvFormer, CAFormer) (18 architectures, 50 poids) : les modèles MetaFormer partagent une structure de bloc transformer générale et varient le mélangeur de jetons : pooling dans PoolFormer / PoolFormerV2, convolutions séparables dans ConvFormer, et convolutions aux étapes initiales avec attention aux étapes ultérieures dans CAFormer.
• Next-ViT (3 architectures, 12 weights) : Next-ViT est un hybride CNN / transformer pour un déploiement efficace, combinant des Next Convolution Blocks (NCB) et des Next Transformer Blocks (NTB).
• TinyViT (5 architectures, 11 poids) : TinyViT est une famille de petits transformeurs hiérarchiques pour la vision (une première étape convolutive, puis une attention sur des fenêtres locales), pré-entraînée par distillation rapide à partir de grands modèles enseignants.
• Visformer (2 architectures, 2 poids) : Visformer (Vision-friendly Transformer) fait évoluer un transformer vers une conception convolutionnelle, avec des blocs convolutionnels en début de réseau et de l'auto-attention en fin de réseau.
• ViTamin (13 architectures, 15 weights) : ViTamin est un modèle de vision conçu pour les modèles vision-langage, avec des étapes convolutives (MBConv) suivies d'étapes transformer. Les poids sont des tours d'image CLIP.

Réseaux efficaces et mobiles

• CPUBone (9 architectures, 9 poids) : CPUBone est un backbone de vision conçu pour les dispositifs aux capacités de parallélisation limitées, tels que les CPU, construit à partir de blocs MBConv (fusionnés) et de blocs d'attention convolutive.
• EdgeNeXt (5 architectures, 6 poids) : EdgeNeXt est un CNN-Transformer hybride pour appareils mobiles qui combine des encodeurs de convolution en profondeur avec des encodeurs d'attention transposée en profondeur séparée (SDTA), appliquant l'attention sur les canaux.
• EfficientFormer (3 architectures, 3 poids) : EfficientFormer est un vision transformer conçu pour la latence sur mobile, avec des blocs basés sur le pooling sur des cartes de caractéristiques 4D dans les premières étapes et des blocs d'auto-attention multi-têtes dans la dernière étape.
• EfficientFormer-V2 (4 architectures, 4 poids) : EfficientFormer-V2 réexamine la conception d'EfficientFormer afin de réduire à la fois le nombre de paramètres et la latence pour les appareils mobiles, en utilisant des étapes convolutives et de l'attention dans les étapes ultérieures, à plus basse résolution.
• EfficientNet (115 architectures, 119 weights) : EfficientNet et EfficientNetV2, ainsi que les architectures mobiles associées construites à partir des mêmes blocs de convolution séparables en profondeur, résidus inversés (MBConv) et MBConv fusionnés : MixNet, MnasNet, FBNet, Single-Path NAS, MobileNet-V1 / V2, EfficientNet-Lite, EdgeTPU et TinyNet.
• EfficientViM (8 architectures, 12 weights) : Efficient Vision Mamba (EfficientViM) est construit autour de la couche Hidden State Mixer based State Space Duality (HSM-SSD), implémentée ici en PyTorch pur. Les modèles _dist ajoutent une tête de distillation.
• EfficientViT (MIT) (7 architectures, 19 poids) : EfficientViT du MIT Han Lab, un backbone de vision pour la reconnaissance haute résolution et à faible coût de calcul, utilisant une attention linéaire multi-échelle.
• EfficientViT (MSRA) (6 architectures, 6 poids) : EfficientViT de Microsoft Research, un vision transformer efficace en mémoire avec une attention groupée en cascade, qui alimente chaque tête d'attention avec une partition différente des caractéristiques.
• FasterNet (6 architectures, 6 poids) : FasterNet est construit autour de la convolution partielle (PConv), qui ne convolue qu'une partie des canaux d'entrée afin de réduire les calculs redondants et l'accès à la mémoire.
• FastViT (12 architectures, 21 weights) : FastViT est un réseau hybride convolutif / transformer qui utilise la reparamétrisation structurelle pour supprimer les connexions de contournement lors de l'inférence. Le module inclut également les encodeurs d'images MobileCLIP (fastvit_mci*).
• GhostNet (10 architectures, 5 poids) : GhostNet génère une partie de ses cartes de caractéristiques à l'aide d'opérations peu coûteuses (modules Ghost). GhostNetV2 ajoute l'attention DFC pour les dépendances à longue portée, tandis que GhostNetV3 utilise la re-paramétrisation et la distillation de connaissances lors de l'entraînement.
• HardCoRe-NAS (6 architectures, 6 poids) : réseaux mobiles découverts par HardCoRe-NAS, une recherche d’architecture neuronale différentiable avec des contraintes de latence strictes, construite sur la classe MobileNetV3.
• iFormer (9 architectures, 8 poids) : iFormer intègre un réseau convolutif rapide avec une attention de modulation à tête unique (SHMA) dans les dernières étapes, pour les applications mobiles.
• LowFormer (8 architectures, 7 weights) : LowFormer est un backbone de type convolutional transformer conçu pour l’efficacité matérielle (mesurée en débit et latence plutôt qu’en MACs). Les variantes GPU edge E1 / E2 / E3 proviennent de l’extension du journal.
• MobileNet-V3 (33 architectures, 45 poids) : MobileNet-V3 et les réseaux associés construits sur la même classe MobileNetV3 : MobileNet-V4, LCNet (PP-LCNet), FBNet-V3 et les poids MobileNet-V3 portés depuis TensorFlow (tf_*).
• MobileViT (10 architectures, 16 weights) : MobileViT combine les blocs résiduels inversés de MobileNet-V2 avec des blocs MobileViT, qui appliquent des transformers à des patches dépliés pour un traitement global. MobileViT-V2 utilise une auto-attention séparable. Construit sur la classe ByobNet.
• PP-LCNetV2 (3 architectures, 4 weights) : PP-LCNetV2 de PaddleClas est un réseau orienté CPU construit sur PP-LCNet. Les convolutions en profondeur des derniers stades sont des branches multi-échelles reparamétrisables, et SE et les raccourcis sont utilisés avec parcimonie pour éviter les pénalités de latence sur CPU.
• RepGhost (8 architectures, 8 poids) : RepGhostNet remplace la concaténation de caractéristiques du module Ghost par une réutilisation de caractéristiques reparamétrée, intégrée dans un unique chemin de convolution à l'inférence.
• RepViT (8 architectures, 13 weights) : RepViT est un CNN mobile qui intègre les choix de conception des transformers de vision légers dans des blocs de type MobileNet-V3, avec reparamétrisation structurelle.
• ReXNet (10 architectures, 9 weights) : ReXNet réviser la configuration des canaux des réseaux résiduels inversés afin de réduire les goulets d’étranglement représentationnels. Les variantes rexnetr_* arrondissent les canaux à des multiples de 8.
• SHViT (4 architectures, 4 poids) : SHViT (Single-Head Vision Transformer) utilise une conception macro efficace en mémoire et une attention à tête unique appliquée à une partie des canaux.
• StarNet (7 architectures, 4 poids) : StarNet est un réseau de démonstration de concept délibérément simple, construit autour de l'opération star, qui consiste en la multiplication élément par élément de deux branches.
• SwiftFormer (4 architectures, 4 poids) : SwiftFormer remplace les multiplications matricielles quadratiques de l'auto-attention par une attention additive efficace, pour des applications de vision mobile en temps réel.

MLP et autres mélangeurs de jetons

• MLP-Mixer, ResMLP and gMLP (15 architectures, 19 weights) : architectures entièrement basées sur des MLP qui alternent le mélange des jetons entre les patches et le mélange des canaux : MLP-Mixer, ResMLP et gMLP (avec un gating par projection spatiale). La docstring du module précise que l’implémentation de gMLP n’est pas vérifiée.
• Sequencer (3 architectures, 3 poids) : Sequencer remplace l'auto-attention par des couches BiLSTM qui mélangent les jetons le long des axes vertical et horizontal, suivies de MLP de canaux.

Encodeurs visuels des modèles multimodaux

• DeepSeek ViT (3 architectures, 6 poids) : l’encodeur visuel des modèles multimodaux DeepSeek-V4 / V4.1, un ViT pre-norm avec RMSNorm, un MLP SwiGLU et un RoPE 2D axial comme seul encodage de position. Les variantes classifieurs ajoutent un pooling et une tête linéaire, tandis que les variantes _enc conservent le projecteur natif qui mappe les jetons vers la largeur du modèle de langage.
• Gemma 4 ViT (4 architectures, 4 poids) : l’encodeur visuel des modèles multimodaux Gemma 4 de Google, un ViT doté de RoPE 2D, de MLPs à porte, de normalisation QK et de blocs de normalisation en sandwich.
• MobileNet-V5 (3 architectures, 1 weight) : l’encodeur visuel MobileNet-V5 de Gemma 3n de Google, construit à partir de blocs MobileNet-V4 (Universal Inverted Residual, Mobile MQA) avec un adaptateur de fusion multi-échelle.
• Qwen3 ViT (9 architectures, 39 weights) : l’encodeur visuel des modèles multimodaux Qwen3-VL / Qwen3.5 / Qwen3.8, un ViT pre-norm combinant une grille de positions absolues apprises et un RoPE 2D axial. Les variantes classifieurs ajoutent un pooling et une tête linéaire, tandis que les variantes _enc conservent le projecteur natif qui mappe les jetons vers la largeur du modèle de langage.

Update on GitHub