Inicio>Relacionado con la programación>Otro código fuente
Descargar

Modelos de imagen de PyTorch

  • Qué hay de nuevo

  • Introducción

  • Modelos

  • Características

  • Resultados

  • Primeros pasos (documentación)

  • Guiones de entrenamiento, validación e inferencia

  • Impresionantes recursos de PyTorch

  • Licencias

  • Citando

Qué hay de nuevo

19 de octubre de 2024

  • Limpie el uso del amplificador de antorcha para evitar llamadas específicas de cuda, combine el soporte para dispositivos Ascend (NPU) de MengqingCao que debería funcionar ahora en PyTorch 2.5 con la nueva función de carga automática de extensión de dispositivo. También probé Intel Arc (XPU) en Pytorch 2.5 y (en su mayoría) funcionó.

16 de octubre de 2024

  • Se corrigió el error al importar desde la ruta obsoleta timm.models.registry , se aumentó la prioridad de las advertencias de obsolescencia existentes para que sean visibles

  • Pesos de puerto de InternViT-300M (https://huggingface.co/OpenGVLab/InternViT-300M-448px) para timm como vit_intern300m_patch14_448

14 de octubre de 2024

  • Versión de preactivación (ResNetV2) de las definiciones del modelo ResNet 18/18d/34/34d agregadas mediante solicitud (pesos pendientes)

  • Versión 1.0.10

11 de octubre de 2024

  • Se agregaron modelos y pesos de MambaOut (https://github.com/yuweihao/MambaOut). Una versión atrevida de los modelos de visión SSM sin SSM (esencialmente ConvNeXt con puerta). Una combinación de pesos originales + variaciones y pesos personalizados.

modelo tamaño_img arriba1 top5 param_count
mambaout_base_plus_rw.sw_e150_r384_in12k_ft_in1k 384 87.506 98.428 101,66
mambaout_base_plus_rw.sw_e150_in12k_ft_in1k 288 86.912 98.236 101,66
mambaout_base_plus_rw.sw_e150_in12k_ft_in1k 224 86.632 98.156 101,66
mambaout_base_tall_rw.sw_e500_in1k 288 84.974 97.332 86,48
mambaout_base_wide_rw.sw_e500_in1k 288 84.962 97.208 94,45
mambaout_base_short_rw.sw_e500_in1k 288 84.832 97,27 88,83
mambaout_base.in1k 288 84,72 96,93 84,81
mambaout_small_rw.sw_e450_in1k 288 84.598 97.098 48,5
mambaout_small.in1k 288 84,5 96.974 48,49
mambaout_base_wide_rw.sw_e500_in1k 224 84.454 96.864 94,45
mambaout_base_tall_rw.sw_e500_in1k 224 84.434 96.958 86,48
mambaout_base_short_rw.sw_e500_in1k 224 84.362 96.952 88,83
mambaout_base.in1k 224 84.168 96,68 84,81
mambaout_small.in1k 224 84.086 96,63 48,49
mambaout_small_rw.sw_e450_in1k 224 84.024 96.752 48,5
mambaout_tiny.in1k 288 83.448 96.538 26,55
mambaout_tiny.in1k 224 82.736 96.1 26,55
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 realiza ajustes finos en ImageNet-1k @ 378x378, se agregó la opción de 378x378 para los 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 ViT SigLIP SO400M de la variante multilingüe reciente (i18n), parche 16 @ 256x256 (https://huggingface.co/timm/ViT-SO400M-16-SigLIP-i18n-256). Actualización de OpenCLIP pendiente.

  • Agregue dos modelos y pesos ConvNeXt 'Zepto' (uno con vástago superpuesto y otro con vástago de parche). Utiliza RMSNorm, más pequeño que el 'Atto' anterior, 2,2 millones de parámetros.

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

    • convnext_zepto_rms.ra4_e3600_r224_in1k - 72,81 @ 224

septiembre de 2024

  • Agregue un conjunto de pequeños modelos de prueba para pruebas unitarias mejoradas y aplicaciones específicas de bajos recursos (https://huggingface.co/blog/rwightman/timm-tiny-test)

  • Agregue el modelo MobileNetV4-Conv-Small (0.5x) (https://huggingface.co/posts/rwightman/793053396198664)

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

  • Agregue variantes MobileNetV3-Large entrenadas con la receta MNV4 Small

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

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

21 de agosto de 2024

  • Modelos SBB ViT actualizados entrenados en ImageNet-12k y ajustados en ImageNet-1k, desafiando una gran cantidad de modelos mucho más grandes y más lentos.

modelo arriba1 top5 param_count tamaño_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 de MobileNet-V1 1.25, EfficientNet-B1 y ResNet50-D con receta de desafío de referencia MNV4

modelo arriba1 top5 param_count tamaño_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
móvilnetv1_125.ra4_e3600_r224_in1k 77.600 93.804 6.27 256
móvilnetv1_125.ra4_e3600_r224_in1k 76.924 93.234 6.27 224

  • Agregue arco vertebral SAM2 (HieraDet) y soporte de carga de peso

  • Agregue pesas Hiera Small entrenadas con abswin pos incrustadas en in12k y afinadas en 1k

modelo arriba1 top5 param_count
hiera_small_abswin_256.sbb2_e200_in12k_ft_in1k 84.912 97.260 35.01
hiera_small_abswin_256.sbb2_pd_e200_in12k_ft_in1k 84.560 97.106 35.01

8 de agosto de 2024

  • Agregue RDNet ('DenseNets Reloaded', https://arxiv.org/abs/2403.19588), gracias Donghyun Kim

28 de julio de 2024

  • Agregue pesos mobilenet_edgetpu_v2_m con receta basada en ra4 mnv4-small. 80,1% top-1 @ 224 y 80,7 @ 256.

  • Versión 1.0.8

26 de julio de 2024

  • Más pesos de MobileNet-v4, preentrenamiento de ImageNet-12k con ajustes finos y modelos ConvLarge suavizados

modelo arriba1 top1_err top5 top5_err param_count tamaño_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 15.36 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

  • Impresionantes desafíos básicos de MobileNet-V1 y EfficientNet-B0 (https://huggingface.co/blog/rwightman/mobilenet-baselines)

modelo arriba1 top1_err top5 top5_err param_count tamaño_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
móvilnetv1_100h.ra4_e3600_r224_in1k 76.596 23.404 93.272 6.728 5.28 256
móvilnetv1_100.ra4_e3600_r224_in1k 76.094 23.906 93.004 6.996 4.23 256
móvilnetv1_100h.ra4_e3600_r224_in1k 75.662 24.338 92.504 7.496 5.28 224
móvilnetv1_100.ra4_e3600_r224_in1k 75.382 24.618 92.312 7.688 4.23 224

  • Prototipo de set_input_size() agregado a los modelos vit y swin v1/v2 para permitir cambiar el tamaño de la imagen, el tamaño del parche y el tamaño de la ventana después de la creación del modelo.

  • Soporte mejorado en swin para el manejo de diferentes tamaños, además de los argumentos set_input_size , always_partition y strict_img_size se han agregado a __init__ para permitir restricciones de tamaño de entrada más flexibles.

  • Corrija la información de índices fuera de servicio para el contenedor de funciones 'Getter' intermedio, consulte o rango de índices para los mismos.

  • Agregue varios modelos de parámetros tiny < .5M para pruebas que en realidad están entrenados en ImageNet-1k

modelo arriba1 top1_err top5 top5_err param_count tamaño_img crop_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

  • Arreglar el inicio del token vit reg, gracias Promisery

  • Otras correcciones varias

24 de junio de 2024

  • 3 pesos híbridos MobileNetV4 más con diferente esquema de inicio de peso MQA

modelo arriba1 top1_err top5 top5_err param_count tamaño_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

  • carga de peso florence2 en el modelo DaViT

12 de junio de 2024

  • Se agregaron modelos MobileNetV4 y un conjunto inicial de pesos entrenados timm :

modelo arriba1 top1_err top5 top5_err param_count tamaño_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
móvilnetv4_conv_small.e2400_r224_in1k 74.616 25.384 92.072 7.928 3.77 256
móvilnetv4_conv_small.e1200_r224_in1k 74.292 25.708 92.116 7.884 3.77 256
móvilnetv4_conv_small.e2400_r224_in1k 73.756 26.244 91.422 8.578 3.77 224
móvilnetv4_conv_small.e1200_r224_in1k 73.454 26.546 91,34 8.66 3.77 224

  • Se agregaron pesos y compatibilidad con el modelo de torre de imágenes Apple MobileCLIP (https://arxiv.org/pdf/2311.17049, FastViT y ViT-B) (parte de la compatibilidad con OpenCLIP).

  • ViTamin (https://arxiv.org/abs/2404.02132) Modelo de torre de imágenes CLIP y pesos agregados (parte del soporte de OpenCLIP).

  • OpenAI CLIP Modelado de torres de imágenes ResNet modificado y soporte de peso (a través de ByobNet). Refactorizar AttentionPool2d.

14 de mayo de 2024

  • Admite la carga de pesas PaliGemma jax en modelos SigLIP ViT con agrupación promedio.

  • Agregue modelos Hiera desde Meta (https://github.com/facebookresearch/hiera).

  • Agregue normalize= bandera para transorms, devuelva antorcha no normalizada. Tensor con dytpe original (para chug )

  • Lanzamiento de la versión 1.0.3

11 de mayo de 2024

  • Searching for Better ViT Baselines (For the GPU Poor) y variantes de vit publicadas. Explorando las formas del modelo entre Tiny y Base.

modelo arriba1 top5 param_count tamaño_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 15.25 256
vit_mediumd_patch16_reg4_gap_256.sbb_in12k N / A N / A 64.11 256
vit_betwixt_patch16_reg4_gap_256.sbb_in12k N / A N / A 60,4 256

  • Se agregó el asistente AttentionExtract para extraer mapas de atención de modelos timm . Ver ejemplo en el n.° 1232 (comentario)

  • La API forward_intermediates() se refinó y se agregó a más modelos, incluidas algunas ConvNets que tienen otros métodos de extracción.

  • 1017 de 1047 arquitecturas de modelos admiten features_only=True . Se pueden admitir las 34 arquitecturas restantes, pero en función de solicitudes de prioridad.

  • Elimine las funciones anotadas de torch.jit.script, incluidas las activaciones JIT antiguas. El conflicto con dinamo y dinamo funciona mucho mejor cuando se usa.

11 de abril de 2024

  • Preparándose para una versión 1.0 muy retrasada, las cosas han estado estables desde hace un tiempo.

  • Característica importante que ha estado faltando por un tiempo, features_only=True soporte para modelos ViT con estados planos ocultos o diseños de módulos no estándar (hasta ahora cubre 'vit_*', 'twins_*', 'deit*', 'beit*', 'mvitv2*', 'eva*', 'samvit_*', 'flexivit*' )

  • El soporte de funciones anterior se logra a través de una nueva API forward_intermediates() que se puede usar con un módulo de ajuste de funciones o directamente.

 modelo = timm.create_model('vit_base_patch16_224')final_feat, intermedios = model.forward_intermediates(entrada)
 salida = model.forward_head(final_feat) # agrupación + clasificador headprint(final_feat.shape)torch.Size([2, 197, 768])para f en intermedios:print(f.shape)torch.Size([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha .Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño([2, 768, 14, 14])antorcha.Tamaño ([2, 768, 14, 14])imprimir(salida.forma)antorcha.Tamaño([2, 1000])
 modelo = timm.create_model('eva02_base_patch16_clip_224', preentrenado=True, img_size=512, características_solo=True, out_indices=(-3, -2,))salida = model(torch.randn(2, 3, 512, 512)) para o en la salida: print(o.shape)
   tamaño.antorcha([2, 768, 32, 32])tamaño.antorcha([2, 768, 32, 32])

  • Se agregaron pesos de la torre de visión TinyCLIP, gracias Thien Tran

19 de febrero de 2024

  • Se agregaron los modelos Next-ViT. Adaptado de https://github.com/bytedance/Next-ViT

  • Se agregaron los modelos HGNet y PP-HGNetV2. Adaptado de https://github.com/PaddlePaddle/PaddleClas por SeeFun

  • Se eliminó setup.py, se movió a una compilación basada en pyproject.toml y compatible con PDM.

  • Agregue el modelo actualizado EMA impl usando _for_each para reducir los gastos generales

  • Admite argumentos de dispositivo en script de tren para dispositivos sin GPU

  • Otras correcciones varias y pequeñas adiciones

  • La versión mínima de Python admitida aumentó a 3.8

  • Versión 0.9.16

8 de enero de 2024

Conjuntos de datos y refactorización de transformación

  • Compatibilidad con conjuntos de datos de transmisión (iterable) de HuggingFace ( --dataset hfids:org/dataset )

  • Ajustes del contenedor Webdataset para mejorar la obtención de información dividida, puede recuperar automáticamente divisiones desde el conjunto de datos web del concentrador HF compatible

  • datasets de HF probados y transmisión de contenedor de conjuntos de datos web desde el centro de HF con cargas recientes timm ImageNet a https://huggingface.co/timm

  • Haga que las claves de campo/columna de entrada y de destino sean consistentes en todos los conjuntos de datos y pase a través de argumentos

  • Compatibilidad monocromática total cuando se utiliza, por ejemplo: --input-size 1 224 224 o --in-chans 1 , configura la conversión de imágenes PIL de forma adecuada en el conjunto de datos

  • Se mejoraron varias transformaciones alternativas de recorte y cambio de tamaño (ResizeKeepRatio, RandomCropOrPad, etc.) para usar en el proyecto de IA de documentos PixParse.

  • Agregue el problema de fluctuación de color del estilo SimCLR junto con opciones de escala de grises y desenfoque gaussiano a los aumentos y argumentos.

  • Permitir tren sin conjunto de validación ( --val-split '' ) en el script de tren

  • Agregue los argumentos --bce-sum (suma sobre clase tenue) y --bce-pos-weight (ponderación positiva) para el entrenamiento, ya que son ajustes comunes de pérdida de BCE que a menudo estaba codificando

23 de noviembre de 2023

  • Se agregaron modelos EfficientViT-Large, gracias SeeFun

  • Se corrigió la compatibilidad con Python 3.7; pronto dejará de ser compatible

  • Otras correcciones varias

  • Versión 0.9.12

20 de noviembre de 2023

  • Se agregó una flexibilidad significativa para los modelos de timm basados ​​en Hugging Face Hub a través de la entrada de configuración model_args . model_args se pasará como kwargs a los modelos en el momento de la creación.

    • Vea el ejemplo en https://huggingface.co/gaunernst/vit_base_patch16_1024_128.audiomae_as2m_ft_as20k/blob/main/config.json

    • Uso: #2035

  • Archivos csv de conjunto de prueba y evaluación de imagenet actualizados con los últimos modelos

  • Mecanografía y limpieza de documentos vision_transformer.py por Laureηt

  • versión 0.9.11

3 de noviembre de 2023

  • Se agregaron pesos DFN (redes de filtrado de datos) y MetaCLIP ViT

  • Se agregaron pesos del modelo ViT de 'registro' DINOV2 (https://huggingface.co/papers/2309.16588, https://huggingface.co/papers/2304.07193)

  • Agregue variantes quickgelu ViT para pesos OpenAI, DFN, MetaCLIP que lo usan (menos eficientes)

  • Escritura mejorada agregada a ResNet, MobileNet-v3 gracias a Aryan

  • ImageNet-12k ajustado (desde LAION-2B CLIP) convnext_xxlarge

  • versión 0.9.9

20 de octubre de 2023

  • Pesos de torre de imágenes SigLIP compatibles con vision_transformer.py .

    • Gran potencial para el uso de funciones de ajuste y posteriores.

  • Soporte de 'registro' experimental en modelos vit según Vision Transformers Need Registers

  • RepViT actualizado con nueva versión de peso. gracias wangao

  • Agregue soporte para cambio de tamaño de parche (en cargas de peso previamente entrenadas) a los modelos Swin

  • 0.9.8 lanzamiento pendiente

1 de septiembre de 2023

  • TinyViT añadido por SeeFun

  • Repare EfficientViT (MIT) para usar torch.autocast para que vuelva a funcionar en PT 1.10

  • versión 0.9.7

Introducción

Py T orch Image Models ( timm ) es una colección de modelos de imágenes, capas, utilidades, optimizadores, programadores, cargadores/aumentos de datos y scripts de validación/entrenamiento de referencia que tienen como objetivo reunir una amplia variedad de modelos SOTA con capacidad. para reproducir los resultados del entrenamiento de ImageNet.

El trabajo de muchos otros está presente aquí. Intenté asegurarme de que todo el material fuente se reconozca a través de enlaces a github, artículos arxiv, etc. en el archivo README, la documentación y las cadenas de documentación del código. Por favor, avíseme si me perdí algo.

Características

Modelos

Todas las familias de arquitectura de modelos incluyen variantes con pesos previamente entrenados. Hay variantes de modelos específicos sin pesos, NO es un error. Siempre se agradece la ayuda para entrenar pesas nuevas o mejores.

  • Agregación de transformadores anidados: https://arxiv.org/abs/2105.12723

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

  • Gran transferencia ResNetV2 (BiT) - https://arxiv.org/abs/1912.11370

  • Transformadores de cuello de botella: https://arxiv.org/abs/2101.11605

  • CaiT (Atención de clase en transformadores de imágenes) - https://arxiv.org/abs/2103.17239

  • CoaT (Transformadores de imágenes conv-atención co-escala) - https://arxiv.org/abs/2104.06399

  • CoAtNet (Convolución y Atención) - https://arxiv.org/abs/2106.04803

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

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

  • ConViT (Transformadores de visión de polarización inductiva convolucional suave) - https://arxiv.org/abs/2103.10697

  • CspNet (redes parciales entre etapas): https://arxiv.org/abs/1911.11929

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

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

  • Red densa: https://arxiv.org/abs/1608.06993

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

  • DPN (red de ruta dual): https://arxiv.org/abs/1707.01629

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

  • Formador eficiente: https://arxiv.org/abs/2206.01191

  • EfficientNet (familia MBConvNet)

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

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

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

    • EfficientNet-EdgeTPU (S, M, L): https://ai.googleblog.com/2019/08/ficientnet-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) y pequeño: https://arxiv.org/abs/1807.11626

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

    • NAS de ruta única: https://arxiv.org/abs/1904.02877

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

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

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

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

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

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

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

  • FocalNet (Redes de modulación focal) - https://arxiv.org/abs/2203.11926

  • GCViT (Transformador de visión 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 en GPU: https://arxiv.org/abs/2006.14090

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

  • HGNet / HGNet-V2 - Por determinar

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

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

  • Inicio-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 visión en la ropa de ConvNet) - https://arxiv.org/abs/2104.01136

  • MaxViT (transformador de visión de ejes múltiples) - https://arxiv.org/abs/2204.01697

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

  • Mezclador MLP: https://arxiv.org/abs/2105.01601

  • CLIP móvil: https://arxiv.org/abs/2311.17049

  • MobileNet-V3 (MBConvNet con cabezal 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

  • MóvilOne: https://arxiv.org/abs/2206.04040

  • MóvilViT: https://arxiv.org/abs/2110.02178

  • MóvilViT-V2: https://arxiv.org/abs/2206.02680

  • MViT-V2 (Transformador de visión multiescala mejorado): https://arxiv.org/abs/2112.01526

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

  • Nest: https://arxiv.org/abs/2105.12723

  • Siguiente 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 visión basado en agrupación (PiT): https://arxiv.org/abs/2103.16302

  • PVT-V2 (Transformador de visión piramidal mejorado): https://arxiv.org/abs/2106.13797

  • RDNet (DenseNets recargado): 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

    • 'Bolsa de trucos' / Variaciones de Gluon C, D, E, S - https://arxiv.org/abs/1812.01187

    • Instagram preentrenado y supervisado débilmente (WSL) / ImageNet sintonizado ResNeXt101 - https://arxiv.org/abs/1805.00932

    • ResNet/ResNeXts semisupervisado (SSL)/supervisado semidébilmente (SWSL): https://arxiv.org/abs/1905.00546

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

    • Redes de compresión y excitación (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

  • SelecciónSLS: https://arxiv.org/abs/1907.00837

  • Redes de kernel selectivas: https://arxiv.org/abs/1903.06586

  • Secuenciador 2D: 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

  • Gemelos (Atención espacial en transformadores de visión) - https://arxiv.org/pdf/2104.13840.pdf

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

  • Transformador de visión: https://arxiv.org/abs/2010.11929

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

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

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

  • Xcepción: https://arxiv.org/abs/1610.02357

  • Xception (alineado modificado, gluón) - https://arxiv.org/abs/1802.02611

  • Xception (alineado modificado, TF) - https://arxiv.org/abs/1802.02611

  • XCiT (Transformadores de imágenes de covarianza cruzada): https://arxiv.org/abs/2106.09681

Optimizadores

Optimizadores incluidos disponibles a través de los métodos de fábrica create_optimizer / create_optimizer_v2 :

  • adabelief una implementación 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 y sgdp por Naver ClovAI - https://arxiv.org/abs/2006.08217

  • adan una implementación de Adan adaptada de https://github.com/sail-sg/Adan - https://arxiv.org/abs/2208.06677

  • lamb una implementación de Lamb y LambC (con recorte de confianza) limpiada y modificada para admitir el uso con XLA: https://arxiv.org/abs/1904.00962

  • lars una implementación de LARS y LARC (con recorte de confianza) - https://arxiv.org/abs/1708.03888

  • lion e implementación de 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 implementación de MADGRAD adaptado de https://github.com/facebookresearch/madgrad - https://arxiv.org/abs/2101.11075

  • nadam una implementación de Adam con impulso de Nesterov

  • nadamw una impementación de AdamW (Adán con decaimiento de peso desacoplado) con impulso de Nesterov. Una implementación simplificada basada en 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 de PyTorch RMSProp por mí mismo. Reproduce un comportamiento muy mejorado de Tensorflow RMSProp

  • sgdw e implementación de SGD con caída de peso desacoplada

  • Optimizadores fused<name> por nombre con NVIDIA Apex instalado

  • optimizadores bits<name> por nombre con BitsAndBytes instalados

Aumentos

  • Borrado aleatorio de Zhun Zhong - https://arxiv.org/abs/1708.04896)

  • Confusión: https://arxiv.org/abs/1710.09412

  • Mezcla de corte: https://arxiv.org/abs/1905.04899

  • AutoAugment (https://arxiv.org/abs/1805.09501) y RandAugment (https://arxiv.org/abs/1909.13719) Configuraciones de ImageNet modeladas a partir de impl para entrenamiento EfficientNet (https://github.com/tensorflow/tpu/ blob/master/models/official/ficientnet/autoaugment.py)

  • AugMix con pérdida de JSD, JSD con soporte de mezcla limpia y aumentada también funciona con AutoAugment y RandAugment: https://arxiv.org/abs/1912.02781

  • SplitBachNorm: permite dividir capas de normas por lotes entre datos limpios y aumentados (norma por lotes auxiliar)

Regularización

  • DropPath también conocido como "Profundidad estocástica" - https://arxiv.org/abs/1603.09382

  • Bloqueo de caída: https://arxiv.org/abs/1810.12890

  • Agrupación de desenfoque: https://arxiv.org/abs/1904.11486

Otro

Se incluyen varias características (menos comunes) que utilizo a menudo en mis proyectos. Muchas de sus adiciones son la razón por la que mantengo mi propio conjunto de modelos, en lugar de usar los de otros a través de PIP:

  • Todos los modelos tienen una interfaz de configuración predeterminada común y API para

    • acceder/cambiar el clasificador - get_classifier y reset_classifier

    • haciendo un pase hacia adelante solo en las funciones - forward_features (ver documentación)

    • Esto facilita la escritura de contenedores de red consistentes que funcionen con cualquiera de los modelos.

  • Todos los modelos admiten la extracción de mapas de características de múltiples escalas (pirámides de características) a través de create_model (ver documentación)

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

    • El argumento de creación out_indices especifica qué mapas de características devolver; estos índices se basan en 0 y generalmente corresponden al nivel de característica C(i + 1) .

    • El argumento de creación output_stride controla el paso de salida de la red mediante el uso de convoluciones dilatadas. La mayoría de las redes tienen zancada 32 de forma predeterminada. No todas las redes admiten esto.

    • Los recuentos de canales del mapa de características y el nivel de reducción (zancada) se pueden consultar DESPUÉS de la creación del modelo a través del miembro .feature_info

  • Todos los modelos tienen un cargador de peso consistente previamente entrenado que adapta el último lineal si es necesario, y de 3 a 1 canal de entrada si lo desea.

  • Scripts de inferencia, validación y entrenamiento de referencia de alto rendimiento que funcionan en varios modos de proceso/GPU:

    • NVIDIA DDP con una sola GPU por proceso, múltiples procesos con APEX presente (AMP de precisión mixta opcional)

    • PyTorch DistributedDataParallel con multi-gpu, proceso único (AMP deshabilitado ya que falla cuando está habilitado)

    • PyTorch con proceso único de GPU única (AMP opcional)

  • Una implementación de grupo global dinámico que permite seleccionar entre grupo promedio, grupo máximo, promedio + máximo o concat([promedio, máximo]) en la creación del modelo. Toda la agrupación global es un promedio adaptativo de forma predeterminada y es compatible con pesos previamente entrenados.

  • Un contenedor 'Test Time Pool' que puede envolver cualquiera de los modelos incluidos y generalmente proporciona un rendimiento mejorado al realizar inferencias con imágenes de entrada más grandes que el tamaño de entrenamiento. Idea adaptada de la implementación DPN original cuando la porté (https://github.com/cypw/DPNs)

  • Programadores de tasas de aprendizaje

    • Programadores AllenNLP

    • FAIRseq lr_scheduler

    • SGDR: descenso de gradiente estocástico con reinicios en caliente (https://arxiv.org/abs/1608.03983)

    • Ideas adoptadas de

    • Los programadores incluyen step , cosine con reinicios, tanh con reinicios, plateau

  • Space-to-Depth por mrT23 (https://arxiv.org/abs/1801.04590) - ¿artículo original?

  • Recorte de gradiente adaptativo (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)

  • Una amplia selección de módulos de atención de canales y/o espaciales:

    • Transformador de cuello de botella: https://arxiv.org/abs/2101.11605

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

    • Excitación-excitación efectiva (ESE): https://arxiv.org/abs/1911.06667

    • Atención de canal eficiente (ECA): https://arxiv.org/abs/1910.03151

    • Reunir-Emocionar (GE) - https://arxiv.org/abs/1810.12348

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

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

    • Involución: https://arxiv.org/abs/2103.06255

    • Capa Lambda: https://arxiv.org/abs/2102.08602

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

    • Apretar y excitar (SE) - https://arxiv.org/abs/1709.01507

    • Núcleo selectivo (SK) - (https://arxiv.org/abs/1903.06586

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

    • Ventana desplazada (SWIN): https://arxiv.org/abs/2103.14030

Resultados

Los resultados de la validación del modelo se pueden encontrar en las tablas de resultados.

Primeros pasos (documentación)

La documentación oficial se puede encontrar en https://huggingface.co/docs/hub/timm. Las contribuciones de documentación son bienvenidas.

Introducción a los modelos de imágenes de PyTorch (timm): una guía para profesionales de Chris Hughes es una publicación de blog extensa que cubre muchos aspectos de timm en detalle.

timmdocs es un conjunto alternativo de documentación para timm . Muchas gracias a Aman Arora por sus esfuerzos en la creación de timmdocs.

paperswithcode es un buen recurso para explorar los modelos dentro de timm .

Guiones de entrenamiento, validación e inferencia

La carpeta raíz del repositorio contiene scripts de tren de referencia, validación e inferencia que funcionan con los modelos incluidos y otras características de este repositorio. Son adaptables a otros conjuntos de datos y casos de uso con un poco de piratería. Ver documentación.

Impresionantes recursos de PyTorch

Uno de los mayores activos de PyTorch es la comunidad y sus contribuciones. A continuación se enumeran algunos de mis recursos favoritos que combinan bien con los modelos y componentes aquí.

Detección de objetos, instancias y segmentación semántica

  • Detectron2: https://github.com/facebookresearch/detectron2

  • Modelos de segmentación (semánticos): https://github.com/qubvel/segmentation_models.pytorch

  • EfficientDet (Obj Det, Semántico próximamente) - https://github.com/rwightman/ficientdet-pytorch

Visión por computadora / aumento de imagen

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

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

Destilación del conocimiento

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

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

Aprendizaje métrico

  • Aprendizaje métrico de PyTorch: https://github.com/KevinMusgrave/pytorch-metric-learning

Formación/Marcos

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

Licencias

Código

El código aquí tiene licencia Apache 2.0. Me he asegurado de que cualquier código de terceros incluido o adaptado tenga licencias compatibles (permisivas) como MIT, BSD, etc. Me he esforzado por evitar conflictos GPL/LGPL. Dicho esto, es su responsabilidad asegurarse de cumplir con las licencias aquí y las condiciones de cualquier licencia dependiente. Cuando corresponde, he vinculado las fuentes/referencias de varios componentes en cadenas de documentos. Si cree que me he perdido algo, cree un problema.

Pesas previamente entrenadas

Hasta ahora, todos los pesos previamente entrenados disponibles aquí están entrenados previamente en ImageNet y unos pocos seleccionados tienen algún entrenamiento previo adicional (consulte la nota adicional a continuación). ImageNet se lanzó únicamente con fines de investigación no comerciales (https://image-net.org/download). No está claro cuáles son las implicaciones de esto para el uso de pesos previamente entrenados a partir de ese conjunto de datos. Todos los modelos que he entrenado con ImageNet se realizan con fines de investigación y se debe asumir que la licencia del conjunto de datos original se aplica a los pesos. Es mejor buscar asesoramiento legal si tiene la intención de utilizar pesas previamente entrenadas en un producto comercial.

Preentrenado en más que ImageNet

Varios pesos incluidos o referencias aquí fueron entrenados previamente con conjuntos de datos propietarios a los que no tengo acceso. Estos incluyen los modelos Facebook WSL, SSL, SWSL ResNe(Xt) y Google Noisy Student EfficientNet. Los modelos de Facebook tienen una licencia no comercial explícita (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images) . Los modelos de Google no parecen tener ninguna restricción más allá de la licencia Apache 2.0 (y las preocupaciones de Imagenet). En cualquier caso, debe comunicarse con Facebook o Google con cualquier pregunta.

Citando

BibTeX

 @misc {rw2019Timm, autor = {Ross Wightman}, title = {Pytorch Image Models}, Year = {2019}, Publisher = {Github}, Journal = {Repository de Github}, doi = {10.5281/zenodo.44414861}, cómo = {url {https://github.com/rwightman/pytorch-image-models}}}
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo