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, arquiteturas e pesos pré-treinados de um módulo de modelo, e quais partes da Model API seus modelos suportam. Consulte o Quickstart para carregar e usar os modelos, a referência de modelos para create_model e as configurações pré-treinadas, e os resultados para os resultados de validação do ImageNet de todos os pesos.

Redes convolucionais

• Aligned Xception (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, …) (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 Redes Eficientes para GPU (gernet_*), RepVGG, MobileOne, RegNetZ, as torres de imagem ResNet do CLIP (*_clip) e uma série de variantes estilo ResNet do timm.
• 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 (31 arquiteturas, 101 pesos): ConvNeXt é uma rede puramente convolucional que adota escolhas de design de vision transformers, como kernels depthwise grandes, inverted bottlenecks e LayerNorm. ConvNeXt-V2 adiciona Global Response Normalization (GRN) e é pré-treinado como um autoencoder mascarado totalmente convolucional (FCMAE).
• CSPNet (CSPResNet, CSPDarkNet, DarkNet) (23 arquiteturas, 15 pesos): Cross Stage Partial Networks dividem os recursos de cada estágio em duas partes, uma passando pelos blocos do estágio e outra mesclada novamente no final do estágio. Este módulo contém CSPResNet, CSPResNeXt, CSPDarkNet, DarkNet e as variantes timm cs3*.
• 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 (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 anti-aliasado com blur pool.
• 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 (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 (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 repetidamente entre eles.
• 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 (1 arquitetura, 4 pesos): Inception-v3, adaptado do modelo Inception3 do torchvision.
• Inception-v4 (1 arquitetura, 1 peso): Inception-v4, portado da implementação e dos pesos do TensorFlow.
• InceptionNeXt (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 identidade, seguindo o Inception.
• 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 (1 arquitetura, 1 peso): NASNet-A Large, uma rede de células encontrada por busca de arquitetura neural, da portação dos modelos pré-treinados do Cadene.
• NFNet (36 arquiteturas, 14 pesos): redes Normalization-Free, treinadas sem normalização de lote usando padronização de pesos escalonada: modelos NFNet (com recorte adaptativo de gradiente), NF-RegNet e NF-ResNet pré-ativação.
• PNASNet (1 arquitetura, 1 peso): PNASNet-5 Large, encontrado por busca progressiva de arquitetura neural, dos modelos pré-treinados portados de Cadene.
• PP-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 (4 arquiteturas, 5 pesos): RDNet (DenseNets Reloaded) revisita redes convolucionais densamente conectadas com blocos e escolhas de design modernizados.
• 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 (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 (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 (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) (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 (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) (9 arquiteturas, 9 pesos): SENet, SE-ResNet e SE-ResNeXt dos modelos pré-treinados de Cadene (legacy_*). O módulo está obsoleto em favor das variantes SE da classe ResNet.
• 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 (4 arquiteturas, 10 pesos): TResNet é um design baseado em ResNet para alto throughput de GPU, com um tronco space-to-depth, downsampling anti-aliasado e camadas SE.
• VGG (8 arquiteturas, 8 pesos): redes VGG com convoluções 3x3 empilhadas, adaptadas do torchvision com a funcionalidade de timm adicionada.
• 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) (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 (7 arquiteturas, 13 pesos): Vision Transformers BEiT e BEiT-v2, pré-treinados com modelagem de imagem mascarada. 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 (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 (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 (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 do original 224 / 384).
• 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 (16 arquiteturas, 24 pesos): Data-efficient Image Transformers (DeiT) são Vision Transformers treinados apenas em 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 (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 (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 (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) (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 (8 arquiteturas, 7 pesos): Multiscale Vision Transformers v2, um transformer hierárquico com atenção com pooling, embeddings de posição relativa decompostos e conexões residuais de pooling.
• NaFlex ViT (14 arquiteturas, 11 pesos): Um Vision Transformer com o patch embedding 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 embeddings de posição fatorizados do NaViT.
• 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 (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 (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 (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 (9 arquiteturas, 19 pesos): O Swin Transformer é um transformer hierárquico de visão que calcula autoatenção dentro de janelas locais, deslocadas entre blocos consecutivos para conexões entre janelas. Inclui os pesos do S3 (AutoFormerV2).
• 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) (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 (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 (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) (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) (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 texto (CLIP, SigLIP) e auto-supervisionadas que compartilham a arquitetura.
• VOLO (11 arquiteturas, 11 pesos): Vision Outlooker (VOLO) adiciona outlook attention, que codifica recursos de nível fino de vizinhanças locais, antes dos estágios de transformer que operam em tokens mais grosseiros.
• 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) (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 (8 arquiteturas, 8 pesos): Co-Scale Conv-Attentional Image Transformers (CoaT) usam atenção fatorizada com codificações de posição relativa baseadas em convolução e um mecanismo de escala conjunta que troca informações entre blocos paralelos em diferentes escalas.
• 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 (12 arquiteturas, 12 pesos): Focal Modulation Networks (FocalNet) substituem a autoatenção pela focal modulation, que agrega contexto em várias granularidades com convoluções depthwise e o direciona para cada token de consulta.
• Hybrid Vision Transformer (14 arquiteturas, 14 pesos): Vision Transformers cujo tokens de patch vêm de um backbone convolucional (ResNet / ResNetV2 stem ou stages) em vez de uma embutida linear de patch, usando a classe VisionTransformer.
• 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 (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) (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 (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 (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 (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 (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 (9 arquiteturas, 9 pesos): 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 (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 (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 (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 (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 (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) (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) (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 (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 (12 arquiteturas, 21 pesos): FastViT é uma rede híbrida convolucional / transformer que usa reparametrização estrutural para remover conexões de atalho na inferência. O módulo também inclui os codificadores de imagem MobileCLIP (fastvit_mci*).
• 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 (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 (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 (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 (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 (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 (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 SE e atalhos são usados com moderação para evitar penalidades de latência na CPU.
• RepGhost (8 arquiteturas, 8 pesos): 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 (8 arquiteturas, 13 pesos): RepViT é uma CNN para dispositivos móveis que incorpora escolhas de design de transformers de visão leves em blocos no estilo MobileNet-V3, com reparametrização estrutural.
• 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 (4 arquiteturas, 4 pesos): SHViT (Single-Head Vision Transformer) usa um design macro eficiente em memória e atenção de cabeça única aplicada a parte dos canais.
• StarNet (7 arquiteturas, 4 pesos): o 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 (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 (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 (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 (3 arquiteturas, 6 pesos): O codificador de visão dos modelos multimodais DeepSeek-V4 / V4.1, um ViT com pré-normalização, 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 (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 (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 multi-escala.
• Qwen3 ViT (9 arquiteturas, 39 pesos): O codificador de visão dos modelos multimodais Qwen3-VL / Qwen3.5 / Qwen3.8, um ViT com pré-normalização 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.

Update on GitHub