pytorch image models
1.0.11
O que há de novo
Introdução
Modelos
Características
Resultados
Primeiros passos (documentação)
Scripts de treinamento, validação e inferência
Recursos incríveis do PyTorch
Licenças
Citando
Limpe o uso do amplificador da tocha para evitar chamadas específicas de cuda, mescle o suporte para dispositivos Ascend (NPU) de MengqingCao que devem funcionar agora no PyTorch 2.5 com novo recurso de carregamento automático de extensão de dispositivo. Testei o Intel Arc (XPU) no Pytorch 2.5 também e funcionou (principalmente).
Corrigido erro ao importar do caminho obsoleto timm.models.registry , aumento da prioridade dos avisos de descontinuação existentes para ficarem visíveis
Pesos de porta do InternViT-300M (https://huggingface.co/OpenGVLab/InternViT-300M-448px) para timm como vit_intern300m_patch14_448
Versão de pré-ativação (ResNetV2) dos defs do modelo ResNet 18/18d/34/34d adicionados por solicitação (pesos pendentes)
Versão 1.0.10
Modelo MambaOut (https://github.com/yuweihao/MambaOut) e pesos adicionados. Uma abordagem atrevida dos modelos de visão SSM sem o SSM (essencialmente ConvNeXt com gating). Uma mistura de pesos originais + variações e pesos personalizados.
| modelo | tamanho_img | topo1 | cinco principais | 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 faz ajustes finos no ImageNet-1k @ 378x378, opção 378x378 adicionada para modelos SigLIP 384x384 existentes
vit_so400m_patch14_siglip_378.webli_ft_in1k - 89,42 top-1
vit_so400m_patch14_siglip_gap_378.webli_ft_in1k - 89.03
Codificador SigLIP SO400M ViT da variante multilíngue recente (i18n), patch16 @ 256x256 (https://huggingface.co/timm/ViT-SO400M-16-SigLIP-i18n-256). Atualização do OpenCLIP pendente.
Adicione dois modelos e pesos ConvNeXt 'Zepto' (um com haste sobreposta e outro com haste patch). Usa RMSNorm, menor que o 'Atto' anterior, parâmetros de 2,2 milhões.
convnext_zepto_rms_ols.ra4_e3600_r224_in1k - 73,20 primeiro-1 @ 224
convnext_zepto_rms.ra4_e3600_r224_in1k - 72,81 @ 224
Adicione um conjunto de pequenos modelos de teste para testes de unidade aprimorados e aplicativos de nicho com poucos recursos (https://huggingface.co/blog/rwightman/timm-tiny-test)
Adicionar modelo MobileNetV4-Conv-Small (0,5x) (https://huggingface.co/posts/rwightman/793053396198664)
mobilenetv4_conv_small_050.e3000_r224_in1k - 65,81 primeiro-1 @ 256, 64,76 @ 224
Adicionar variantes MobileNetV3-Large treinadas com receita 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
Modelos SBB ViT atualizados treinados em ImageNet-12k e ajustados em ImageNet-1k, desafiando vários modelos muito maiores e mais lentos
| modelo | topo1 | cinco principais | param_count | tamanho_img |
|---|---|---|---|---|
| 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 |
Pesos MobileNet-V1 1.25, EfficientNet-B1 e ResNet50-D com receita de desafio de linha de base MNV4
| modelo | topo1 | cinco principais | param_count | tamanho_img |
|---|---|---|---|---|
| resnet50d.ra4_e3600_r224_in1k | 81.838 | 95.922 | 25,58 | 288 |
| eficientenet_b1.ra4_e3600_r240_in1k | 81.440 | 95.700 | 7,79 | 288 |
| resnet50d.ra4_e3600_r224_in1k | 80.952 | 95.384 | 25,58 | 224 |
| eficientenet_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 |
Adicionar arco de backbone SAM2 (HieraDet) e suporte para carregamento de peso
Adicione Hiera Pequenos pesos treinados com abswin pos incorporados em in12k e ajustados em 1k
| modelo | topo1 | cinco principais | 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 |
Adicione RDNet ('DenseNets Reloaded', https://arxiv.org/abs/2403.19588), obrigado Donghyun Kim
Adicione pesos mobilenet_edgetpu_v2_m com receita baseada em ra4 mnv4-small. 80,1% primeiro-1 @ 224 e 80,7 @ 256.
Versão 1.0.8
Mais pesos MobileNet-v4, pré-treinamento ImageNet-12k com ajustes finos e modelos ConvLarge com suavização de serrilhado
| modelo | topo1 | top1_err | cinco principais | top5_err | param_count | tamanho_img |
|---|---|---|---|---|---|---|
| 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 |
Desafios de linha de base impressionantes do MobileNet-V1 e EfficientNet-B0 (https://huggingface.co/blog/rwightman/mobilenet-baselines)
| modelo | topo1 | top1_err | cinco principais | top5_err | param_count | tamanho_img |
|---|---|---|---|---|---|---|
| eficientenet_b0.ra4_e3600_r224_in1k | 79.364 | 20.636 | 94.754 | 5.246 | 5.29 | 256 |
| eficientenet_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 |
Protótipo de set_input_size() adicionado aos modelos vit e swin v1/v2 para permitir a alteração do tamanho da imagem, tamanho do patch e tamanho da janela após a criação do modelo.
Suporte aprimorado no swin para manipulação de tamanhos diferentes, além dos argumentos set_input_size , always_partition e strict_img_size foram adicionados ao __init__ para permitir restrições de tamanho de entrada mais flexíveis
Corrija informações de índices fora de ordem para wrapper de recurso 'Getter' intermediário, verifique ou alcance índices para o mesmo.
Adicione vários modelos de parâmetros tiny < 0,5M para testes que são realmente treinados no ImageNet-1k
| modelo | topo1 | top1_err | cinco principais | top5_err | param_count | tamanho_img | colheita_pct |
|---|---|---|---|---|---|---|---|
| test_eficientenet.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_eficientenet.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 |
Corrija o init do token vit reg, obrigado Promisery
Outras correções diversas
Mais 3 pesos híbridos MobileNetV4 com esquema de inicialização de peso MQA diferente
| modelo | topo1 | top1_err | cinco principais | top5_err | param_count | tamanho_img |
|---|---|---|---|---|---|---|
| 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 |
carregamento de peso florence2 no modelo DaViT
Modelos MobileNetV4 e conjunto inicial de pesos treinados timm adicionados:
| modelo | topo1 | top1_err | cinco principais | top5_err | param_count | tamanho_img |
|---|---|---|---|---|---|---|
| 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 |
Suporte ao modelo de torre de imagem Apple MobileCLIP (https://arxiv.org/pdf/2311.17049, FastViT e ViT-B) e pesos adicionados (parte do suporte OpenCLIP).
ViTamin (https://arxiv.org/abs/2404.02132) Modelo de torre de imagem CLIP e pesos adicionados (parte do suporte OpenCLIP).
Modelagem de torre de imagem ResNet modificada CLIP OpenAI e suporte de peso (via ByobNet). Refatore AtençãoPool2d.
Suporte ao carregamento de pesos PaliGemma jax em modelos SigLIP ViT com pooling médio.
Adicione modelos Hiera do Meta (https://github.com/facebookresearch/hiera).
Adicionar normalize= sinalizador para transorms, retornar torch.Tensor não normalizado com dytpe original (para chug )
Versão 1.0.3
Searching for Better ViT Baselines (For the GPU Poor) pesos e variantes de vit lançados. Explorando formas de modelo entre Tiny e Base.
| modelo | topo1 | cinco principais | param_count | tamanho_img |
|---|---|---|---|---|
| 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 | 13.42 | 256 |
| vit_pwee_patch16_reg1_gap_256.sbb_in1k | 80.072 | 95.136 | 15h25 | 256 |
| vit_mediumd_patch16_reg4_gap_256.sbb_in12k | N / D | N / D | 64.11 | 256 |
| vit_betwixt_patch16_reg4_gap_256.sbb_in12k | N / D | N / D | 60,4 | 256 |
Auxiliar AttentionExtract adicionado para extrair mapas de atenção de modelos timm . Veja o exemplo em #1232 (comentário)
API forward_intermediates() refinada e adicionada a mais modelos, incluindo alguns ConvNets que possuem outros métodos de extração.
1.017 de 1.047 arquiteturas de modelo suportam features_only=True extração de recursos. As 34 arquiteturas restantes podem ser suportadas, mas com base em solicitações prioritárias.
Remova funções anotadas torch.jit.script, incluindo ativações JIT antigas. Conflito com dínamo e dínamo faz um trabalho muito melhor quando usado.
Preparando-se para um lançamento 1.0 há muito esperado, as coisas estão estáveis há algum tempo.
Recurso significativo que está faltando há algum tempo, features_only=True suporte para modelos ViT com estados ocultos planos ou layouts de módulo não padrão (até agora cobrindo 'vit_*', 'twins_*', 'deit*', 'beit*', 'mvitv2*', 'eva*', 'samvit_*', 'flexivit*' )
Suporte ao recurso acima obtido por meio de uma nova API forward_intermediates() que pode ser usada com um módulo de agrupamento de recursos ou diretamente.
modelo = timm.create_model('vit_base_patch16_224')final_feat, intermediários = model.forward_intermediates(input)
saída = model.forward_head(final_feat) # pooling + classificador headprint(final_feat.shape)torch.Size([2, 197, 768])for f em intermediários:print(f.shape)torch.Size([2, 768, 14, 14])torch.Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])torch.Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])tocha .Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])torch.Size([2, 768, 14, 14])tocha.Size([2, 768, 14, 14])tocha .Tamanho([2, 768, 14, 14])imprimir(saída.forma)torch.Size([2, 1000]) modelo = timm.create_model('eva02_base_patch16_clip_224', pré-treinado=True, img_size=512, features_only=True, out_indices=(-3, -2,))output = model(torch.randn(2, 3, 512, 512)) para o na saída: print(o.shape)
tocha.Size([2, 768, 32, 32])torch.Size([2, 768, 32, 32])Pesos da torre de visão TinyCLIP adicionados, obrigado Thien Tran
Modelos Next-ViT adicionados. Adaptado de https://github.com/bytedance/Next-ViT
Modelos HGNet e PP-HGNetV2 adicionados. Adaptado de https://github.com/PaddlePaddle/PaddleClas por SeeFun
Setup.py removido, movido para compilação baseada em pyproject.toml suportada pelo PDM
Adicione o modelo EMA impl atualizado usando _for_each para menos sobrecarga
Suporte a argumentos de dispositivo no script de treinamento para dispositivos não GPU
Outras correções diversas e pequenas adições
Versão mínima do Python suportada aumentada para 3.8
Versão 0.9.16
Conjuntos de dados e refatoração de transformação
Suporte ao conjunto de dados de streaming HuggingFace (iterável) ( --dataset hfids:org/dataset )
Ajustes no wrapper do Webdataset para melhor busca de informações de divisão, pode buscar automaticamente divisões do webdataset do hub HF compatível
datasets HF testados e streaming de wrapper de webdataset do hub HF com uploads recentes timm ImageNet para https://huggingface.co/timm
Torne as chaves de coluna/campo de entrada e destino consistentes em todos os conjuntos de dados e passe por meio de argumentos
Suporte monocromático completo ao usar, por exemplo: --input-size 1 224 224 ou --in-chans 1 , define a conversão de imagem PIL apropriadamente no conjunto de dados
Várias transformações alternativas de corte e redimensionamento foram aprimoradas (ResizeKeepRatio, RandomCropOrPad, etc.) para uso no projeto de IA de documentos PixParse
Adicione o problema de jitter de cores no estilo SimCLR junto com opções de escala de cinza e desfoque gaussiano para aumentos e argumentos
Permitir trem sem conjunto de validação ( --val-split '' ) no script de trem
Adicione argumentos --bce-sum (soma sobre classe dim) e --bce-pos-weight (ponderação positiva) para treinamento, pois são ajustes comuns de perda de BCE.
Adicionados modelos EfficientViT-Large, obrigado SeeFun
Corrija a compatibilidade do Python 3.7, abandonaremos o suporte para ele em breve
Outras correções diversas
Versão 0.9.12
Adicionada flexibilidade significativa para modelos timm baseados no Hugging Face Hub por meio da entrada de configuração model_args . model_args será passado como kwargs para os modelos na criação.
Veja o exemplo em https://huggingface.co/gaunernst/vit_base_patch16_1024_128.audiomae_as2m_ft_as20k/blob/main/config.json
Uso: #2035
Arquivos csv de conjunto de testes e avaliação do imagenet atualizados com os modelos mais recentes
digitação vision_transformer.py e limpeza de documentos por Laureηt
Versão 0.9.11
Pesos DFN (Data Filtering Networks) e MetaCLIP ViT adicionados
Pesos do modelo ViT 'registrado' DINOv2 adicionados (https://huggingface.co/papers/2309.16588, https://huggingface.co/papers/2304.07193)
Adicionar variantes quickgelu ViT para pesos OpenAI, DFN, MetaCLIP que o utilizam (menos eficiente)
Digitação aprimorada adicionada ao ResNet, MobileNet-v3 graças a Aryan
ImageNet-12k ajustado (do LAION-2B CLIP) convnext_xxlarge
Versão 0.9.9
Pesos de torre de imagem SigLIP suportados em vision_transformer.py .
Grande potencial para ajuste fino e uso de recursos downstream.
Suporte experimental de 'registro' em modelos vit conforme Vision Transformers Need Registers
RepViT atualizado com nova versão de peso. Obrigado Wangao
Adicionar suporte para redimensionamento de patch (em carga de peso pré-treinada) aos modelos Swin
Versão 0.9.8 pendente
TinyViT adicionado por SeeFun
Corrija o EfficientViT (MIT) para usar torch.autocast para que funcione de volta ao PT 1.10
Versão 0.9.7
Py Torch Image Models ( timm ) é uma coleção de modelos de imagem, camadas, utilitários, otimizadores, agendadores, carregadores/aumentos de dados e scripts de treinamento/validação de referência que visam reunir uma ampla variedade de modelos SOTA com capacidade para reproduzir os resultados do treinamento ImageNet.
O trabalho de muitos outros está presente aqui. Tentei garantir que todo o material de origem fosse reconhecido por meio de links para github, documentos arxiv, etc. no README, documentação e documentos de código. Por favor, deixe-me saber se eu perdi alguma coisa.
Todas as famílias de arquitetura de modelo incluem variantes com pesos pré-treinados. Existem variantes de modelos específicos sem pesos, NÃO é um bug. Ajuda para treinar pesos novos ou melhores é sempre apreciada.
Agregando transformadores aninhados - https://arxiv.org/abs/2105.12723
BEiT - https://arxiv.org/abs/2106.08254
Grande transferência ResNetV2 (BiT) - https://arxiv.org/abs/1912.11370
Transformadores de gargalo - https://arxiv.org/abs/2101.11605
CaiT (atenção de classe em transformadores de imagem) - https://arxiv.org/abs/2103.17239
CoaT (transformadores de imagem conv-atencionais em co-escala) - https://arxiv.org/abs/2104.06399
CoAtNet (Convolução e Atenção) - https://arxiv.org/abs/2106.04803
ConvNeXt - https://arxiv.org/abs/2201.03545
ConvNeXt-V2 - http://arxiv.org/abs/2301.00808
ConViT (transformadores de visão de viés indutivo convolucional suave) - https://arxiv.org/abs/2103.10697
CspNet (redes parciais entre estágios) - 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 (rede de caminho duplo) - https://arxiv.org/abs/1707.01629
EdgeNeXt - https://arxiv.org/abs/2206.10589
EficienteFormer - https://arxiv.org/abs/2206.01191
EfficientNet (família MBConvNet)
EfficientNet NoisyStudent (B0-B7, L2) - https://arxiv.org/abs/1911.04252
EfficientNet AdvProp (B0-B8) - https://arxiv.org/abs/1911.09665
Rede Eficiente (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) e Pequeno - https://arxiv.org/abs/1807.11626
MobileNet-V2 - https://arxiv.org/abs/1801.04381
NAS de caminho único - https://arxiv.org/abs/1904.02877
TinyNet - https://arxiv.org/abs/2010.14819
EfficientViT (MIT) - https://arxiv.org/abs/2205.14756
EficienteViT (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 (Redes de Modulação Focal) - https://arxiv.org/abs/2203.11926
GCViT (Transformador de Visão de Contexto 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
Redes eficientes em GPU - https://arxiv.org/abs/2006.14090
Redes Halo - https://arxiv.org/abs/2103.12731
HGNet / HGNet-V2 - A ser determinado
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 e Inception-V4 - https://arxiv.org/abs/1602.07261
Redes Lambda - https://arxiv.org/abs/2102.08602
LeViT (Transformador de visão em roupas da ConvNet) - https://arxiv.org/abs/2104.01136
MaxViT (transformador de visão multieixo) - https://arxiv.org/abs/2204.01697
MetaFormer (PoolFormer-v2, ConvFormer, CAFormer) - https://arxiv.org/abs/2210.13452
Misturador MLP - https://arxiv.org/abs/2105.01601
MobileCLIP - https://arxiv.org/abs/2311.17049
MobileNet-V3 (MBConvNet com cabeça eficiente) - 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 (transformador de visão multiescala aprimorado) - https://arxiv.org/abs/2112.01526
NASNet-A - https://arxiv.org/abs/1707.07012
NesT - https://arxiv.org/abs/2105.12723
Next-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
Transformador de visão baseado em pooling (PiT) - https://arxiv.org/abs/2103.16302
PVT-V2 (transformador de visão em pirâmide aprimorado) - https://arxiv.org/abs/2106.13797
RDNet (DenseNets recarregado) - 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
'Bag of Tricks' / variações Gluon C, D, E, S - https://arxiv.org/abs/1812.01187
Instagram pré-treinado com supervisão fraca (WSL) / ImageNet ajustado ResNeXt101 - https://arxiv.org/abs/1805.00932
Semi-supervisionado (SSL) / Semi-fracamente supervisionado (SWSL) ResNet/ResNeXts - https://arxiv.org/abs/1905.00546
Rede ECA (ECAResNet) - https://arxiv.org/abs/1910.03151v4
Redes de compressão e excitação (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
Redes Kernel Seletivas - https://arxiv.org/abs/1903.06586
Sequenciador2D - https://arxiv.org/abs/2205.01972
Swin S3 (AutoFormerV2) - https://arxiv.org/abs/2111.14725
Transformador Swin - https://arxiv.org/abs/2103.14030
Transformador Swin V2 - https://arxiv.org/abs/2111.09883
Transformador-iN-Transformador (TNT) - https://arxiv.org/abs/2103.00112
TResNet - https://arxiv.org/abs/2003.13630
Gêmeos (atenção espacial em transformadores de visão) - https://arxiv.org/pdf/2104.13840.pdf
Visformer - https://arxiv.org/abs/2104.12533
Transformador de visão - https://arxiv.org/abs/2010.11929
ViTamin - https://arxiv.org/abs/2404.02132
VOLO (Vision Outlooker) - https://arxiv.org/abs/2106.13112
VovNet V2 e V1 - https://arxiv.org/abs/1911.06667
Xcepção - https://arxiv.org/abs/1610.02357
Xception (alinhado modificado, glúon) - https://arxiv.org/abs/1802.02611
Xception (alinhado modificado, TF) - https://arxiv.org/abs/1802.02611
XCiT (transformadores de imagem de covariância cruzada) - https://arxiv.org/abs/2106.09681
Otimizadores incluídos disponíveis através dos métodos de fábrica create_optimizer / create_optimizer_v2 :
adabelief uma implementação de AdaBelief adaptada de https://github.com/juntang-zhuang/Adabelief-Optimizer - https://arxiv.org/abs/2010.07468
adafactor adaptado de FAIRSeq impl - https://arxiv.org/abs/1804.04235
adahessian por David Samuel - https://arxiv.org/abs/2006.00719
adamp e sgdp por Naver ClovAI - https://arxiv.org/abs/2006.08217
adan uma implementação de Adan adaptada de https://github.com/sail-sg/Adan - https://arxiv.org/abs/2208.06677
lamb uma implementação de Lamb e LambC (com recorte de confiança) limpa e modificada para suportar o uso com XLA - https://arxiv.org/abs/1904.00962
lars uma implementação de LARS e LARC (com recorte de confiança) - https://arxiv.org/abs/1708.03888
lion e implementação do Lion adaptado de https://github.com/google/automl/tree/master/lion - https://arxiv.org/abs/2302.06675
lookahead adaptado de impl por Liam - https://arxiv.org/abs/1907.08610
madgrad - e implementação de MADGRAD adaptado de https://github.com/facebookresearch/madgrad - https://arxiv.org/abs/2101.11075
nadam uma implementação de Adam com impulso Nesterov
nadamw uma impementação de AdamW (Adam com decaimento de peso dissociado) com impulso de Nesterov. Um impl simplificado baseado em https://github.com/mlcommons/algorithmic-efficiency
novograd por Masashi Kimura - https://arxiv.org/abs/1905.11286
radam por Liyuan Liu - https://arxiv.org/abs/1908.03265
rmsprop_tf adaptado do PyTorch RMSProp por mim mesmo. Reproduz comportamento muito melhorado do Tensorflow RMSProp
sgdw e implementação de SGD com redução de peso dissociada
otimizadores fused<name> por nome com NVIDIA Apex instalado
otimizadores bits<name> por nome com BitsAndBytes instalados
Apagamento aleatório de Zhun Zhong - https://arxiv.org/abs/1708.04896)
Mistura - https://arxiv.org/abs/1710.09412
CutMix - https://arxiv.org/abs/1905.04899
AutoAugment (https://arxiv.org/abs/1805.09501) e RandAugment (https://arxiv.org/abs/1909.13719) Configurações ImageNet modeladas após impl para treinamento EfficientNet (https://github.com/tensorflow/tpu/ blob/master/models/official/efficientnet/autoaugment.py)
AugMix com perda de JSD, JSD com suporte de mixagem limpo + aumentado também funciona com AutoAugment e RandAugment - https://arxiv.org/abs/1912.02781
SplitBachNorm - permite dividir camadas de norma de lote entre dados limpos e aumentados (norma de lote auxiliar)
DropPath, também conhecido como "Profundidade Estocástica" - https://arxiv.org/abs/1603.09382
DropBlock - https://arxiv.org/abs/1810.12890
Pool de desfoque - https://arxiv.org/abs/1904.11486
Vários recursos (menos comuns) que utilizo frequentemente em meus projetos estão incluídos. Muitas de suas adições são a razão pela qual mantenho meu próprio conjunto de modelos, em vez de usar outros via PIP:
Todos os modelos têm uma interface de configuração padrão comum e API para
acessando/alterando o classificador - get_classifier e reset_classifier
fazendo um encaminhamento apenas nos recursos - forward_features (consulte a documentação)
isso facilita a gravação de wrappers de rede consistentes que funcionam com qualquer um dos modelos
Todos os modelos suportam extração de mapas de recursos em várias escalas (pirâmides de recursos) via create_model (consulte a documentação)
create_model(name, features_only=True, out_indices=..., output_stride=...)
O argumento de criação out_indices especifica quais mapas de recursos retornar, esses índices são baseados em 0 e geralmente correspondem ao nível de recurso C(i + 1) .
O argumento de criação output_stride controla o passo de saída da rede usando convoluções dilatadas. A maioria das redes tem passo 32 por padrão. Nem todas as redes suportam isso.
contagens de canais do mapa de recursos, nível de redução (passo) podem ser consultados APÓS a criação do modelo por meio do membro .feature_info
Todos os modelos possuem um carregador de peso pré-treinado consistente que adapta a última linear, se necessário, e de 3 para 1 entrada de canal, se desejado
Scripts de treinamento, validação e inferência de referência de alto desempenho que funcionam em vários modos de processo/GPU:
NVIDIA DDP com uma única GPU por processo, vários processos com APEX presente (AMP de precisão mista opcional)
PyTorch DistributedDataParallel com multi-gpu, processo único (AMP desativado porque trava quando ativado)
PyTorch com processo único de GPU (AMP opcional)
Uma implementação dinâmica de pool global que permite selecionar pooling médio, pool máximo, média + máximo ou concat([média, máximo]) na criação do modelo. Todo o pooling global é uma média adaptativa por padrão e compatível com pesos pré-treinados.
Um wrapper 'Test Time Pool' que pode agrupar qualquer um dos modelos incluídos e geralmente fornece melhor desempenho ao fazer inferência com imagens de entrada maiores que o tamanho do treinamento. Idéia adaptada da implementação original do DPN quando eu portei (https://github.com/cypw/DPNs)
Agendadores de taxa de aprendizagem
Agendadores AllenNLP
FAIRseq lr_scheduler
SGDR: descida gradiente estocástica com reinicializações a quente (https://arxiv.org/abs/1608.03983)
Idéias adotadas de
Os agendadores incluem step , cosine com reinicializações, tanh com reinicializações, plateau
Space-to-Depth por mrT23 (https://arxiv.org/abs/1801.04590) - artigo original?
Recorte de gradiente adaptável (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)
Uma extensa seleção de canais e/ou módulos de atenção espacial:
Transformador de gargalo - https://arxiv.org/abs/2101.11605
CBAM - https://arxiv.org/abs/1807.06521
Excitação de compressão eficaz (ESE) - https://arxiv.org/abs/1911.06667
Atenção de Canal Eficiente (ECA) - https://arxiv.org/abs/1910.03151
Reunir-Excitar (GE) - https://arxiv.org/abs/1810.12348
Contexto Global (GC) - https://arxiv.org/abs/1904.11492
Halo - https://arxiv.org/abs/2103.12731
Involução - https://arxiv.org/abs/2103.06255
Camada Lambda - https://arxiv.org/abs/2102.08602
Não local (NL) - https://arxiv.org/abs/1711.07971
Aperto e excitação (SE) - https://arxiv.org/abs/1709.01507
Kernel Seletivo (SK) - (https://arxiv.org/abs/1903.06586
Divisão (SPLAT) - https://arxiv.org/abs/2004.08955
Janela deslocada (SWIN) - https://arxiv.org/abs/2103.14030
Os resultados da validação do modelo podem ser encontrados nas tabelas de resultados
A documentação oficial pode ser encontrada em https://huggingface.co/docs/hub/timm. Contribuições de documentação são bem-vindas.
Primeiros passos com modelos de imagem PyTorch (timm): um guia prático de Chris Hughes é uma extensa postagem no blog que cobre muitos aspectos do timm em detalhes.
timmdocs é um conjunto alternativo de documentação para timm . Um grande obrigado a Aman Arora por seus esforços na criação de timmdocs.
paperswithcode é um bom recurso para navegar pelos modelos dentro timm .
A pasta raiz do repositório contém scripts de treinamento de referência, validação e inferência que funcionam com os modelos incluídos e outros recursos deste repositório. Eles são adaptáveis para outros conjuntos de dados e casos de uso com um pouco de hacking. Consulte a documentação.
Um dos maiores ativos do PyTorch é a comunidade e suas contribuições. Alguns dos meus recursos favoritos que combinam bem com os modelos e componentes aqui estão listados abaixo.
Detectron2 - https://github.com/facebookresearch/detectron2
Modelos de segmentação (semântica) - https://github.com/qubvel/segmentation_models.pytorch
EfficientDet (Obj Det, Semântica em breve) - https://github.com/rwightman/efficientdet-pytorch
Albumentações - https://github.com/albumentations-team/albumentations
Kornia - https://github.com/kornia/kornia
RepDistiller - https://github.com/HobbitLong/RepDistiller
torchdistill - https://github.com/yoshitomo-matsubara/torchdistill
Aprendizado de métricas PyTorch - https://github.com/KevinMusgrave/pytorch-metric-learning
fastai - https://github.com/fastai/fastai
O código aqui é licenciado pelo Apache 2.0. Tomei cuidado para garantir que qualquer código de terceiros incluído ou adaptado tenha licenças compatíveis (permissivas), como MIT, BSD, etc. Fiz um esforço para evitar quaisquer conflitos GPL/LGPL. Dito isto, é sua responsabilidade garantir o cumprimento das licenças aqui e das condições de quaisquer licenças dependentes. Quando aplicável, vinculei as fontes/referências de vários componentes em docstrings. Se você acha que perdi alguma coisa, crie um problema.
Até agora, todos os pesos pré-treinados disponíveis aqui são pré-treinados no ImageNet, com alguns selecionados que possuem algum pré-treinamento adicional (veja a nota extra abaixo). ImageNet foi lançado apenas para fins de pesquisa não comercial (https://image-net.org/download). Não está claro quais são as implicações disso para o uso de pesos pré-treinados desse conjunto de dados. Todos os modelos que treinei com ImageNet são feitos para fins de pesquisa e deve-se presumir que a licença do conjunto de dados original se aplica aos pesos. É melhor procurar aconselhamento jurídico se você pretende usar pesos pré-treinados em um produto comercial.
Vários pesos incluídos ou referências aqui foram pré-treinados com conjuntos de dados proprietários aos quais não tenho acesso. Isso inclui os modelos Facebook WSL, SSL, SWSL ResNe(Xt) e Google Noisy Student EfficientNet. Os modelos do Facebook possuem uma licença não comercial explícita (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images) . Os modelos do Google não parecem ter nenhuma restrição além da licença Apache 2.0 (e preocupações do ImageNet). Em ambos os casos, você deve entrar em contato com o Facebook ou Google com qualquer dúvida.
@misc {rw2019timm, autor = {ross wightman}, title = {pytorch Image Models}, ano = {2019}, editor = {github}, periódico = {github repositor = {url {https://github.com/rwightman/pytorch-image-models}}} 
