# Famílias de Modelos

`timm` possui 1371 arquiteturas em 98 famílias de modelos, com 1826 pesos pré-treinados. Cada página de família lista os artigos, as arquiteturas e os pesos pré-treinados de um módulo de modelo, e quais partes da [Model API](model_api) seus modelos suportam. Consulte o [Quickstart](quickstart) para carregar e usar os modelos, a [referência de modelos](reference/models) para `create_model` e as configurações pré-treinadas, e os [resultados](results) para os resultados de validação do ImageNet de todos os pesos.

## Redes convolucionais

* [Aligned Xception](models/xception-aligned) (5 arquiteturas, 6 pesos): Aligned Xception (41, 65, 71 camadas) conforme modificado no DeepLab, implementado do zero e compatível com os pesos do DeepLab do TensorFlow.
* [BYOBNet (GENet, RepVGG, MobileOne, ...)](models/byobnet) (53 arquiteturas, 57 pesos): Bring-Your-Own-Blocks Network, uma rede flexível construída a partir de configurações de dataclass que empilham blocos em estágios. Ela implementa GPU-Efficient Networks (`gernet_*`), RepVGG, MobileOne, RegNetZ, as torres de imagem ResNet do CLIP (`*_clip`) e uma série de variantes `timm` no estilo ResNet.
* [ConvMixer](models/convmixer) (3 arquiteturas, 3 pesos): o ConvMixer incorpora a imagem como patches e mantém essa resolução ao longo de todo o processo, alternando entre convoluções depthwise (mistura espacial) e convoluções pointwise (mistura de canais).
* [ConvNeXt](models/convnext) (31 arquiteturas, 101 pesos): ConvNeXt é uma rede puramente convolucional que adota escolhas de design de transformadores de visão, como kernels de profundidade grandes, gargalos invertidos e LayerNorm. ConvNeXt-V2 adiciona Normalização de Resposta Global (GRN) e é pré-treinado como um autoencoder mascarado totalmente convolucional (FCMAE).
* [CSPNet (CSPResNet, CSPDarkNet, DarkNet)](models/cspnet) (23 arquiteturas, 15 pesos): as Cross Stage Partial Networks dividem os recursos de cada estágio em duas partes, uma que passa pelos blocos do estágio e outra que é mesclada novamente no final do estágio. Este módulo contém CSPResNet, CSPResNeXt, CSPDarkNet, DarkNet e as variantes `timm` `cs3*`.
* [CSPNeXt](models/cspnext) (5 arquiteturas, 5 pesos): O backbone CSPNeXt do detector de objetos em tempo real RTMDet (blocos CSP com convoluções profundas 5x5), com pesos de classificação ImageNet-1k convertidos dos checkpoints do OpenMMLab.
* [DenseNet](models/densenet) (6 arquiteturas, 6 pesos): Redes convolucionais densamente conectadas, em que cada camada em um bloco denso recebe as saídas concatenadas de todas as camadas anteriores do bloco. Adaptado do torchvision, o `densenetblur` usa downsampling antialiasado com blur pool.
* [DLA](models/dla) (12 arquiteturas, 12 pesos): As redes Deep Layer Aggregation (DLA) mesclam recursos entre blocos e estágios com nós de agregação iterativos e hierárquicos. Inclui variantes de DLA construídas a partir de blocos Res2Net.
* [DPN](models/dpn) (7 arquiteturas, 7 pesos): Dual Path Networks combinam um caminho residual (reutilização de recursos) e um caminho densamente conectado (exploração de novos recursos) em cada bloco. Compatível com os pesos da implementação original em MXNet.
* [HRNet](models/hrnet) (11 arquiteturas, 14 pesos): As High-Resolution Networks mantêm um ramo de alta resolução por toda a rede e adicionam ramos de resolução mais baixa em paralelo, trocando informações entre eles repetidamente.
* [Inception-ResNet-v2](models/inception-resnet-v2) (1 arquitetura, 2 pesos): Inception-ResNet-v2 combina módulos Inception com conexões residuais. Portado da implementação e dos pesos do TensorFlow.
* [Inception-v3](models/inception-v3) (1 arquitetura, 4 pesos): Inception-v3, adaptado do modelo `Inception3` do torchvision.
* [Inception-v4](models/inception-v4) (1 arquitetura, 1 peso): Inception-v4, portado da implementação e dos pesos do TensorFlow.
* [InceptionNeXt](models/inception-next) (4 arquiteturas, 5 pesos): o InceptionNeXt decompõe a convolução depthwise de kernel grande do ConvNeXt em ramos paralelos, um kernel quadrado pequeno, dois kernels de banda ortogonais e um mapeamento de identidade, seguindo o Inception.
* [MambaOut](models/mambaout) (11 arquiteturas, 12 pesos): MambaOut empilha blocos Gated CNN e blocos Mamba sem o misturador de tokens do modelo de espaço de estado (SSM), para testar se os SSMs são necessários para classificação de imagens.
* [NASNet](models/nasnet) (1 arquitetura, 1 peso): NASNet-A Large, uma rede de células encontrada por busca de arquitetura neural, da portada dos modelos pré-treinados do Cadene.
* [NFNet](models/nfnet) (36 arquiteturas, 14 pesos): redes Normalization-Free, treinadas sem batch normalization usando scaled weight standardization: modelos NFNet (com adaptive gradient clipping), NF-RegNet e NF-ResNet com pré-ativação.
* [PNASNet](models/pnasnet) (1 arquitetura, 1 peso): PNASNet-5 Large, encontrado por busca progressiva de arquitetura neural, dos modelos pré-treinados portados de Cadene.
* [PP-HGNet](models/hgnet) (10 arquiteturas, 19 pesos): PP-HGNet e PP-HGNetV2 (High Performance GPU Net) do PaddleClas, construídos a partir de blocos HG que agregam as saídas de uma sequência de convoluções. Os pesos `ssld` são treinados com a destilação SSLD do PaddleClas.
* [RDNet](models/rdnet) (4 arquiteturas, 5 pesos): RDNet (DenseNets Reloaded) revisita redes convolucionais densamente conectadas com blocos e escolhas de design modernizados.
* [RegNet](models/regnet) (36 arquiteturas, 65 pesos): redes RegNetX e RegNetY dos espaços de design de redes regulares, RegNetZ de "Fast and Accurate Model Scaling", e adições do `timm`, como o RegNetV de pré-ativação. Inclui pesos do pycls, torchvision e VISSL (SEER).
* [Res2Net](models/res2net) (9 arquiteturas, 9 pesos): o Res2Net divide os canais do bloco bottleneck em grupos conectados hierarquicamente, proporcionando vários tamanhos de campo receptivo dentro de um único bloco. Inclui Res2NeXt.
* [ResNeSt](models/resnest) (8 arquiteturas, 8 pesos): o ResNeSt usa blocos de split-attention, atenção de canal entre grupos de splits de feature maps, em uma rede no estilo ResNet.
* [ResNet](models/resnet) (81 arquiteturas, 150 pesos): Redes residuais (ResNet) e as variantes construídas na mesma classe `ResNet`: convoluções agrupadas ResNeXt, atenção de canal Squeeze-and-Excitation (SE) e ECA, stems profundos / em camadas e downsampling por pooling médio (as variantes "c", "d", "s" e "t"), downsampling anti-aliasado e configurações Wide ResNet e ResNet-RS.
* [ResNetV2 (BiT)](models/resnetv2) (20 arquiteturas, 24 pesos): Pre-activation ResNet (v2) com Group Normalization e Weight Standardization, conforme utilizado por Big Transfer (BiT), com os pesos originais do BiT. Também suporta a variante não pre-activation utilizada como backbone do Vision Transformer híbrido.
* [SelecSLS](models/selecsls) (5 arquiteturas, 3 pesos): o SelecSLS usa conexões de salto seletivas de longo e curto alcance, propostas como a rede central do XNect, um sistema de estimativa de pose 3D de múltiplas pessoas em tempo real.
* [SENet (legado)](models/senet) (9 arquiteturas, 9 pesos): SENet, SE-ResNet e SE-ResNeXt dos modelos pré-treinados do Cadene (`legacy_*`). O módulo está obsoleto em favor das variantes SE da classe `ResNet`.
* [SKNet](models/sknet) (5 arquiteturas, 3 pesos): Selective Kernel Networks em uma base ResNet, onde as unidades SK fundem ramos com diferentes tamanhos de kernel usando atenção sobre os ramos.
* [TResNet](models/tresnet) (4 arquiteturas, 10 pesos): TResNet é um design baseado em ResNet para alto throughput de GPU, com um stem space-to-depth, downsampling anti-aliasado e camadas SE.
* [VGG](models/vgg) (8 arquiteturas, 8 pesos): redes VGG de convoluções 3x3 empilhadas, adaptadas do torchvision com a funcionalidade `timm` adicionada.
* [VoVNet](models/vovnet) (10 arquiteturas, 3 pesos): o VoVNet usa módulos de One-Shot Aggregation (OSA), que concatenam as saídas de todas as camadas de um bloco uma única vez ao final dele. O VoVNetV2 (do CenterMask) adiciona conexões residuais e atenção eSE (effective SE).
* [Xception (legado)](models/xception) (1 arquitetura, 1 peso): O Xception original, com convoluções separáveis por profundidade e conexões residuais, com pesos portados do Keras (`legacy_xception`).

## Transformers de Visão

* [BEiT](models/beit) (7 arquiteturas, 13 pesos): Vision Transformers BEiT e BEiT-v2, pré-treinados com modelagem de imagens mascaradas. O BEiT prevê os tokens visuais discretos dos patches mascarados, enquanto o BEiT-v2 utiliza um tokenizador visual quantizado por vetores para os alvos. Os pesos aqui são pesos de classificação ajustados finamente.
* [CaiT](models/cait) (10 arquiteturas, 10 pesos): Class-Attention in Image Transformers (CaiT), Vision Transformers profundos que usam LayerScale e terminam com camadas de class-attention, que atualizam apenas o token de classe a partir dos tokens de patch.
* [ConViT](models/convit) (3 arquiteturas, 3 pesos): o ConViT substitui a autoatenção dos primeiros blocos do Vision Transformer pela autoatenção posicional com gate (GPSA), que pode ser inicializada para se comportar como uma convolução, funcionando como um viés indutivo convolucional suave.
* [CrossViT](models/crossvit) (11 arquiteturas, 11 pesos): o CrossViT processa patches de imagem pequenos e grandes em dois ramos Transformer e os funde com atenção cruzada por meio dos tokens de classe. Os nomes dos modelos em `timm` indicam a resolução de entrada real (240 / 408 em vez da original 224 / 384).
* [DaViT](models/davit) (8 arquiteturas, 5 pesos): Dual Attention Vision Transformers (DaViT) combinam atenção de janela espacial e atenção de grupo de canais, ambas lineares em relação ao número de tokens, em um design hierárquico.
* [DeiT](models/deit) (16 arquiteturas, 24 pesos): Data-efficient Image Transformers (DeiT) são Vision Transformers treinados apenas no ImageNet-1k, opcionalmente com um token de destilação que aprende de um professor CNN. Os modelos DeiT III são treinados com uma receita aprimorada.
* [EVA](models/eva) (65 arquiteturas, 83 pesos): Vision Transformers EVA e EVA-02 e outras variantes de ViT que compartilham a classe `Eva`, com embeddings de posição rotativos (RoPE), MLPs SwiGLU e adições relacionadas. O módulo também contém os modelos Perception Encoder (PE), ROPE-ViT, DINOv3, LingBot-Vision e Sapiens2 e as configurações originais de ViT do `timm` com RoPE.
* [GCViT](models/gcvit) (5 arquiteturas, 5 pesos): os Global Context Vision Transformers (GCViT) alternam a atenção local de janela com a atenção de contexto global, cujas consultas são geradas a partir de todo o mapa de recursos por um módulo convolucional.
* [Hiera](models/hiera) (8 arquiteturas, 16 pesos): Hiera é um vision transformer hierárquico sem módulos especializados (convoluções, janelas deslocadas, vieses de posição relativos), dependendo do pré-treinamento com autoencoder mascarado (MAE) para aprender vieses espaciais.
* [HieraDet (SAM 2)](models/hieradet-sam2) (5 arquiteturas, 8 pesos): HieraDet, o codificador de imagem baseado em Hiera do Segment Anything 2 (SAM 2), com atenção em janelas e embeddings de posição em janelas.
* [MViTv2](models/mvitv2) (8 arquiteturas, 7 pesos): Multiscale Vision Transformers v2, um transformer hierárquico com pooling attention, embeddings de posição relativa decompostos e conexões residuais de pooling.
* [NaFlex ViT](models/naflexvit) (14 arquiteturas, 11 pesos): Um Vision Transformer com a incorporação de patches e a codificação de posição em um único módulo, suportando entradas pré-patchificadas com proporção de aspecto e resolução variáveis (NaFlex), tamanho de patch variável do FlexiViT e incorporações de posição fatorizadas do NaViT.
* [NesT](models/nest) (6 arquiteturas, 3 pesos): Nested Transformers (NesT) aplicam autoatenção localmente dentro de blocos de imagem não sobrepostos e agregam blocos vizinhos entre os estágios. Pesos convertidos da liberação oficial em JAX.
* [PiT](models/pit) (8 arquiteturas, 8 pesos): Vision Transformers baseados em pooling (PiT) reduzem o tamanho espacial e aumentam os canais dos tokens entre os estágios com uma camada de pooling de convolução depthwise, como em CNNs.
* [PVTv2](models/pvt-v2) (7 arquiteturas, 7 pesos): Pyramid Vision Transformer v2, um transformer hierárquico com atenção de redução espacial (linear na variante `_li`), incorporações de patches sobrepostas e camadas feed-forward convolucionais.
* [Segment Anything ViT](models/vision-transformer-sam) (4 arquiteturas, 3 pesos): O codificador de imagem ViT do Segment Anything Model (SAM), um backbone ViT simples com blocos de atenção janelada e global e incorporações de posição relativa, como no ViTDet.
* [Swin Transformer](models/swin-transformer) (9 arquiteturas, 19 pesos): O Swin Transformer é um vision transformer hierárquico que calcula a autoatenção dentro de janelas locais, deslocadas entre blocos consecutivos para conexões entre janelas. Inclui os pesos do S3 (AutoFormerV2).
* [Swin Transformer V2](models/swin-transformer-v2) (12 arquiteturas, 12 pesos): o Swin Transformer V2 escala o Swin com residual post-norm, atenção cosseno escalada e um viés de posição relativa contínua com espaçamento logarítmico que se transfere entre tamanhos de janela.
* [Swin Transformer V2 (CR)](models/swin-transformer-v2-cr) (16 arquiteturas, 3 pesos): uma implementação alternativa do Swin Transformer V2 adaptada do código de Christoph Reich, projetada para alterar o tamanho da imagem junto com o tamanho da janela, incluindo tamanhos não quadrados. A docstring do módulo a marca como experimental.
* [TNT](models/tnt) (3 arquiteturas, 3 pesos): Transformer in Transformer (TNT) modela a estrutura dentro de cada patch com um transformer interno sobre sub-patches, junto com o transformer externo sobre patches.
* [Gêmeos](models/twins) (6 arquiteturas, 6 pesos): Twins-PCPVT (Pyramid Vision Transformer com codificações de posição condicionais) e Twins-SVT (autoatenção espacialmente separável, atenção localmente agrupada alternando com atenção global subsampleada).
* [Vision Transformer (posição relativa)](models/vision-transformer-relpos) (14 arquiteturas, 9 pesos): Vision Transformers que utilizam vieses de posição relativa em vez de incorporações de posição absoluta. A docstring do módulo marca esses modelos como experimentais.
* [Vision Transformer (ViT)](models/vision-transformer) (163 arquiteturas, 309 pesos): O Vision Transformer (ViT) divide uma imagem em patches de tamanho fixo, os embute linearmente e processa a sequência de tokens resultante com um codificador Transformer padrão. Este módulo contém a classe `VisionTransformer` e os pesos para o ViT original, os modelos "How to train your ViT?" (AugReg) e FlexiViT, e muitas torres de imagem pré-treinadas com auto-supervisão e de imagem-texto (CLIP, SigLIP) que compartilham a arquitetura.
* [VOLO](models/volo) (11 arquiteturas, 11 pesos): Vision Outlooker (VOLO) adiciona outlook attention, que codifica recursos de nível fino a partir de vizinhanças locais, antes dos estágios de transformer que operam em tokens mais grosseiros.
* [XCiT](models/xcit) (28 arquiteturas, 42 pesos): Cross-Covariance Image Transformers (XCiT) substituem a autoatenção de tokens pela atenção de covariância cruzada entre canais de recursos, linear no número de tokens, e adicionam camadas de interação local de patches.

## Redes híbridas de convolução / atenção

* [BYOANet (BoTNet, HaloNet, LambdaNet)](models/byoanet) (15 arquiteturas, 13 pesos): Redes construídas com o sistema de configuração de blocos/estágios `ByobNet` que posicionam camadas de autoatenção (ou similares) em estágios no estilo ResNet: Bottleneck Transformers (BoTNet), HaloNets e Lambda ResNets. A docstring do módulo marca essas definições como experimentais.
* [CoaT](models/coat) (8 arquiteturas, 8 pesos): os Co-Scale Conv-Attentional Image Transformers (CoaT) utilizam atenção fatorizada com codificações de posição relativa baseadas em convolução e um mecanismo de co-escala que troca informações entre blocos paralelos em diferentes escalas.
* [CSATv2](models/csatv2) (2 arquiteturas, 3 pesos): o CSATv2 é um modelo de visão no domínio da frequência que opera sobre as transformadas DCT da imagem de entrada, com atenção espacial.
* [FocalNet](models/focalnet) (12 arquiteturas, 12 pesos): Focal Modulation Networks (FocalNet) substituem o self-attention por focal modulation, que agrega contexto em várias granularidades com convoluções depthwise e o direciona para cada token de consulta.
* [Hybrid Vision Transformer](models/vision-transformer-hybrid) (14 arquiteturas, 14 pesos): Vision Transformers cujos tokens de patch vêm de um backbone convolucional (ResNet / ResNetV2 stem ou stages) em vez de um embedding linear de patch, usando a classe `VisionTransformer`.
* [LeViT](models/levit) (20 arquiteturas, 10 pesos): LeViT é uma rede híbrida para inferência rápida, com um tronco convolucional seguido por estágios de atenção que reduzem a resolução por meio de downsampling baseado em atenção e utilizam vieses de atenção para posição.
* [MaxViT e CoAtNet](models/maxxvit) (58 arquiteturas, 52 pesos): Implementações do zero do MaxViT (blocos MBConv com atenção multi-eixo, atenção local e dilatada em grade bloqueada) e do CoAtNet (estágios de convolução seguidos por estágios de atenção relativa), além de variantes do `timm` (configurações `_rw`, MaxxViT).
* [MetaFormer (PoolFormer, ConvFormer, CAFormer)](models/metaformer) (18 arquiteturas, 50 pesos): os modelos MetaFormer compartilham uma estrutura geral de bloco transformer e variam o misturador de tokens: pooling no PoolFormer / PoolFormerV2, convoluções separáveis no ConvFormer e convoluções nas etapas iniciais com atenção nas etapas posteriores no CAFormer.
* [Next-ViT](models/nextvit) (3 arquiteturas, 12 pesos): Next-ViT é um híbrido de CNN / transformer para implantação eficiente, empilhando Next Convolution Blocks (NCB) e Next Transformer Blocks (NTB).
* [TinyViT](models/tiny-vit) (5 arquiteturas, 11 pesos): TinyViT é uma família de pequenos vision transformers hierárquicos (um estágio inicial convolucional, seguido de atenção em janelas locais), pré-treinados por destilação rápida a partir de modelos professores grandes.
* [Visformer](models/visformer) (2 arquiteturas, 2 pesos): Visformer (Vision-friendly Transformer) transiciona um transformer para um design convolucional, com blocos convolucionais no estágio inicial e autoatenção nos estágios posteriores.
* [ViTamin](models/vitamin) (13 arquiteturas, 15 pesos): ViTamin é um modelo de visão projetado para modelos de visão-linguagem, com estágios convolucionais (MBConv) seguidos por estágios de transformer. Os pesos são torres de imagem do CLIP.

## Redes eficientes e móveis

* [CPUBone](models/cpubone) (9 arquiteturas, 9 pesos): o CPUBone é um backbone de visão projetado para dispositivos com baixa capacidade de paralelização, como CPUs, construído a partir de blocos MBConv (fundidos) e blocos de atenção convolucional.
* [EdgeNeXt](models/edgenext) (5 arquiteturas, 6 pesos): EdgeNeXt é um híbrido CNN-Transformer para dispositivos móveis que combina codificadores de convolução depthwise com codificadores de atenção transposta depth-wise dividida (SDTA), que aplicam atenção entre canais.
* [EfficientFormer](models/efficientformer) (3 arquiteturas, 3 pesos): o EfficientFormer é um vision transformer projetado para latência em dispositivos móveis, com blocos baseados em pooling em mapas de recursos 4D nas etapas iniciais e blocos de autoatenção multi-cabeça na última etapa.
* [EfficientFormer-V2](models/efficientformer-v2) (4 arquiteturas, 4 pesos): o EfficientFormer-V2 revisita o design do EfficientFormer para reduzir tanto a contagem de parâmetros quanto a latência para dispositivos móveis, com estágios convolucionais e atenção nos estágios posteriores, de menor resolução.
* [EfficientNet](models/efficientnet) (115 arquiteturas, 119 pesos): EfficientNet e EfficientNetV2, e as arquiteturas móveis relacionadas construídas a partir dos mesmos blocos de separável em profundidade, residual invertido (MBConv) e MBConv fundido: MixNet, MnasNet, FBNet, Single-Path NAS, MobileNet-V1 / V2, EfficientNet-Lite, EdgeTPU e TinyNet.
* [EfficientViM](models/efficientvim) (8 arquiteturas, 12 pesos): o Efficient Vision Mamba (EfficientViM) é construído em torno da camada Hidden State Mixer based State Space Duality (HSM-SSD), implementada aqui em PyTorch puro. Os modelos `_dist` adicionam uma cabeça de destilação.
* [EfficientViT (MIT)](models/efficientvit-mit) (7 arquiteturas, 19 pesos): EfficientViT do MIT Han Lab, um backbone de visão para reconhecimento de alta resolução e baixa computação que usa atenção linear multiescala.
* [EfficientViT (MSRA)](models/efficientvit-msra) (6 arquiteturas, 6 pesos): EfficientViT da Microsoft Research, um vision transformer eficiente em memória com atenção em grupo em cascata, que fornece a cada cabeça de atenção uma divisão diferente dos recursos.
* [FasterNet](models/fasternet) (6 arquiteturas, 6 pesos): o FasterNet é construído em torno da convolução parcial (PConv), que convolve apenas uma parte dos canais de entrada para reduzir o cálculo redundante e o acesso à memória.
* [FastViT](models/fastvit) (12 arquiteturas, 21 pesos): FastViT é uma rede híbrida convolucional/transformer que usa reparametrização estrutural para remover conexões de salto na inferência. O módulo também inclui os codificadores de imagem MobileCLIP (`fastvit_mci*`).
* [GhostNet](models/ghostnet) (10 arquiteturas, 5 pesos): o GhostNet gera parte de seus mapas de características com operações de baixo custo (módulos Ghost). O GhostNetV2 adiciona atenção DFC para dependências de longo alcance, e o GhostNetV3 usa reparametrização e destilação de conhecimento no treinamento.
* [HardCoRe-NAS](models/hardcorenas) (6 arquiteturas, 6 pesos): Redes móveis encontradas pelo HardCoRe-NAS, uma busca de arquitetura neural diferenciável com restrições rígidas de latência, construída com base na classe `MobileNetV3`.
* [iFormer](models/iformer) (9 arquiteturas, 8 pesos): o iFormer integra uma rede convolucional rápida com atenção de modulação de cabeça única (SHMA) nos estágios finais, para aplicações móveis.
* [LowFormer](models/lowformer) (8 arquiteturas, 7 pesos): LowFormer é um backbone de transformer convolucional projetado para eficiência de hardware (medido por throughput e latência, em vez de MACs). As variantes de GPU de borda E1 / E2 / E3 são da extensão do periódico.
* [MobileNet-V3](models/mobilenetv3) (33 arquiteturas, 45 pesos): MobileNet-V3 e as redes relacionadas construídas na mesma classe `MobileNetV3`: MobileNet-V4, LCNet (PP-LCNet), FBNet-V3 e pesos do MobileNet-V3 portados do TensorFlow (`tf_*`).
* [MobileViT](models/mobilevit) (10 arquiteturas, 16 pesos): o MobileViT combina blocos de resíduo invertido do MobileNet-V2 com blocos MobileViT, que aplicam transformers a patches desdobrados para processamento global. O MobileViT-V2 usa autoatenção separável. Construído com base na classe `ByobNet`.
* [PP-LCNetV2](models/lcnetv2) (3 arquiteturas, 4 pesos): o PP-LCNetV2 do PaddleClas é uma rede voltada para CPU, construída sobre o PP-LCNet. As convoluções depthwise dos estágios finais são ramos multi-escala reparametrizáveis, e o SE e os atalhos são usados com moderação para evitar penalidades de latência na CPU.
* [RepGhost](models/repghost) (8 arquiteturas, 8 pesos): o RepGhostNet substitui a concatenação de recursos do módulo Ghost pela reutilização de recursos reparametrizada, incorporada em um único caminho de convolução na inferência.
* [RepViT](models/repvit) (8 arquiteturas, 13 pesos): RepViT é uma CNN para dispositivos móveis que incorpora escolhas de design de vision transformers leves em blocos no estilo MobileNet-V3, com reparametrização estrutural.
* [ReXNet](models/rexnet) (10 arquiteturas, 9 pesos): o ReXNet revisa a configuração de canais de redes residuais invertidas para reduzir gargalos de representação. As variantes `rexnetr_*` arredondam os canais para múltiplos de 8.
* [SHViT](models/shvit) (4 arquiteturas, 4 pesos): SHViT (Single-Head Vision Transformer) utiliza um design macro eficiente em memória e atenção de cabeça única aplicada a parte dos canais.
* [StarNet](models/starnet) (7 arquiteturas, 4 pesos): StarNet é uma rede de conceito demonstrativo deliberadamente simples, construída em torno da operação star, a multiplicação elemento a elemento de dois ramos.
* [SwiftFormer](models/swiftformer) (4 arquiteturas, 4 pesos): o SwiftFormer substitui as multiplicações de matriz quadráticas do autoatendimento por um atendimento aditivo eficiente, para aplicações de visão em tempo real em dispositivos móveis.

## MLP e outros misturadores de tokens

* [MLP-Mixer, ResMLP e gMLP](models/mlp-mixer) (15 arquiteturas, 19 pesos): Arquiteturas All-MLP que alternam a mistura de tokens entre patches com a mistura de canais: MLP-Mixer, ResMLP e gMLP (gateamento com uma projeção espacial). A docstring do módulo observa que a implementação do gMLP não é verificada.
* [Sequencer](models/sequencer) (3 arquiteturas, 3 pesos): Sequencer substitui a autoatenção por camadas BiLSTM que misturam tokens ao longo dos eixos vertical e horizontal, seguidas por MLPs de canal.

## Codificadores de visão de modelos multimodais

* [DeepSeek ViT](models/deepseek-vit) (3 arquiteturas, 6 pesos): O codificador de visão dos modelos multimodais DeepSeek-V4 / V4.1, um ViT com pre-norm, RMSNorm, um MLP SwiGLU e RoPE 2D axial como a única codificação de posição. As variantes de classificador adicionam pooling e uma cabeça linear, enquanto as variantes `_enc` mantêm o projetor nativo que mapeia os tokens para a largura do modelo de linguagem.
* [Gemma 4 ViT](models/gemma4-vit) (4 arquiteturas, 4 pesos): O codificador de visão dos modelos multimodais Gemma 4 da Google, um ViT com 2D RoPE, MLPs com gate, normalização QK e blocos de normalização em sanduíche.
* [MobileNet-V5](models/mobilenetv5) (3 arquiteturas, 1 peso): O codificador de visão MobileNet-V5 do Gemma 3n da Google, construído a partir de blocos MobileNet-V4 (Universal Inverted Residual, Mobile MQA) com um adaptador de fusão multiescala.
* [Qwen3 ViT](models/qwen3-vit) (9 arquiteturas, 39 pesos): O codificador de visão dos modelos multimodais Qwen3-VL / Qwen3.5 / Qwen3.8, um ViT com normalização prévia (pre-norm) que combina uma grade de posição absoluta aprendida com RoPE 2D axial. As variantes de classificador adicionam pooling e uma cabeça linear, enquanto as variantes `_enc` mantêm o projetor nativo que mapeia os tokens para a largura do modelo de linguagem.