pytorch image models
1.0.11
Was ist neu
Einführung
Modelle
Merkmale
Ergebnisse
Erste Schritte (Dokumentation)
Trainings-, Validierungs- und Inferenzskripte
Tolle PyTorch-Ressourcen
Lizenzen
Zitieren
Bereinigen Sie die Nutzung des Taschenlampenverstärkers, um Cuda-spezifische Aufrufe zu vermeiden, und führen Sie die Unterstützung für Ascend (NPU)-Geräte von MengqingCao zusammen, die jetzt in PyTorch 2.5 mit der neuen Funktion zum automatischen Laden von Geräteerweiterungen funktionieren sollten. Habe Intel Arc (XPU) auch in Pytorch 2.5 getestet und es hat (meistens) funktioniert.
Fehler beim Importieren aus dem veralteten Pfad timm.models.registry behoben, Priorität der Sichtbarkeit vorhandener veralteter Warnungen erhöht
Portgewichte von InternViT-300M (https://huggingface.co/OpenGVLab/InternViT-300M-448px) sollen als vit_intern300m_patch14_448 timm
Voraktivierungsversion (ResNetV2) der 18/18d/34/34d ResNet-Modelldefinitionen auf Anfrage hinzugefügt (Gewichtungen stehen noch aus)
Version 1.0.10
MambaOut (https://github.com/yuweihao/MambaOut) Modell und Gewichte hinzugefügt. Eine freche Interpretation von SSM-Vision-Modellen ohne SSM (im Wesentlichen ConvNeXt mit Gating). Eine Mischung aus Originalgewichten und benutzerdefinierten Variationen und Gewichten.
| Modell | img_size | top1 | 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 optimiert ImageNet-1k bei 378 x 378 und fügt die Option 378 x 378 für bestehende SigLIP 384 x 384-Modelle hinzu
vit_so400m_patch14_siglip_378.webli_ft_in1k - 89,42 Top-1
vit_so400m_patch14_siglip_gap_378.webli_ft_in1k - 89.03
SigLIP SO400M ViT-Encoder aus der aktuellen mehrsprachigen (i18n) Variante, Patch16 @ 256x256 (https://huggingface.co/timm/ViT-SO400M-16-SigLIP-i18n-256). OpenCLIP-Update steht aus.
Fügen Sie zwei ConvNeXt „Zepto“-Modelle und -Gewichte hinzu (eines mit überlappendem Stiel und eines mit aufgesetztem Stiel). Verwendet RMSNorm, kleiner als das vorherige „Atto“, 2,2 Mio. Parameter.
convnext_zepto_rms_ols.ra4_e3600_r224_in1k – 73,20 Top-1 @ 224
convnext_zepto_rms.ra4_e3600_r224_in1k – 72,81 @ 224
Fügen Sie eine Reihe winziger Testmodelle für verbesserte Unit-Tests und ressourcenarme Nischenanwendungen hinzu (https://huggingface.co/blog/rwightman/timm-tiny-test)
Modell MobileNetV4-Conv-Small (0,5x) hinzufügen (https://huggingface.co/posts/rwightman/793053396198664)
mobilenetv4_conv_small_050.e3000_r224_in1k – 65,81 Top-1 bei 256, 64,76 bei 224
Fügen Sie MobileNetV3-Large-Varianten hinzu, die mit dem MNV4 Small-Rezept trainiert wurden
mobilenetv3_large_150d.ra4_e3600_r256_in1k – 81,81 bei 320, 80,94 bei 256
mobilenetv3_large_100.ra4_e3600_r224_in1k – 77,16 bei 256, 76,31 bei 224
Aktualisierte SBB ViT-Modelle, die auf ImageNet-12k trainiert und auf ImageNet-1k verfeinert wurden, stellen eine Herausforderung für eine ganze Reihe viel größerer, langsamerer Modelle dar
| Modell | top1 | top5 | param_count | img_size |
|---|---|---|---|---|
| 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 |
MobileNet-V1 1.25-, EfficientNet-B1- und ResNet50-D-Gewichte mit MNV4-Basis-Challenge-Rezept
| Modell | top1 | top5 | param_count | img_size |
|---|---|---|---|---|
| resnet50d.ra4_e3600_r224_in1k | 81.838 | 95.922 | 25.58 | 288 |
| effizientnet_b1.ra4_e3600_r240_in1k | 81.440 | 95.700 | 7,79 | 288 |
| resnet50d.ra4_e3600_r224_in1k | 80.952 | 95.384 | 25.58 | 224 |
| effizientnet_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 |
Fügen Sie SAM2 (HieraDet) Rückgratbogen und Gewichtsbelastungsunterstützung hinzu
Fügen Sie Hiera hinzu. Kleine Gewichte, trainiert mit Bauchmuskeln, eingebettet in 12 km und verfeinert auf 1 km
| Modell | top1 | 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 |
RDNet („DenseNets Reloaded“, https://arxiv.org/abs/2403.19588) hinzufügen, danke Donghyun Kim
Fügen Sie mobilenet_edgetpu_v2_m -Gewichte mit einem auf ra4 mnv4-small basierenden Rezept hinzu. 80,1 % Top-1 bei 224 und 80,7 bei 256.
Version 1.0.8
Weitere MobileNet-v4-Gewichte, ImageNet-12k-Vortraining mit Feinabstimmungen und Anti-Aliasing-ConvLarge-Modelle
| Modell | top1 | top1_err | top5 | top5_err | param_count | img_size |
|---|---|---|---|---|---|---|
| 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 |
Beeindruckende Baseline-Herausforderungen für MobileNet-V1 und EfficientNet-B0 (https://huggingface.co/blog/rwightman/mobilenet-baselines)
| Modell | top1 | top1_err | top5 | top5_err | param_count | img_size |
|---|---|---|---|---|---|---|
| effizientnet_b0.ra4_e3600_r224_in1k | 79.364 | 20.636 | 94.754 | 5.246 | 5.29 | 256 |
| effizientnet_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 |
Prototyp von set_input_size() wurde den Modellen vit und swin v1/v2 hinzugefügt, um das Ändern von Bildgröße, Patchgröße und Fenstergröße nach der Modellerstellung zu ermöglichen.
Verbesserte Unterstützung in swin für die Handhabung unterschiedlicher Größen. Zusätzlich zu set_input_size wurden die Argumente always_partition und strict_img_size zu __init__ hinzugefügt, um flexiblere Einschränkungen der Eingabegröße zu ermöglichen
Korrigieren Sie Informationen zu Indizes außerhalb der Reihenfolge für den Intermediate-'Getter'-Feature-Wrapper, überprüfen Sie die Indizes oder Bereichsindizes dafür.
Fügen Sie zum Testen mehrere tiny Parametermodelle < 0,5 Mio. hinzu, die tatsächlich auf ImageNet-1k trainiert werden
| Modell | top1 | top1_err | top5 | top5_err | param_count | img_size | Crop_pct |
|---|---|---|---|---|---|---|---|
| test_efficientnet.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_efficientnet.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 |
Die Initialisierung des Vit-Reg-Tokens wurde behoben, danke Promisery
Andere verschiedene Korrekturen
3 weitere MobileNetV4-Hyridgewichte mit unterschiedlichem MQA-Gewichtungsinitialisierungsschema
| Modell | top1 | top1_err | top5 | top5_err | param_count | img_size |
|---|---|---|---|---|---|---|
| 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 |
Florence2-Gewichtsbelastung im DaViT-Modell
MobileNetV4-Modelle und erster Satz von timm trainierten Gewichten hinzugefügt:
| Modell | top1 | top1_err | top5 | top5_err | param_count | img_size |
|---|---|---|---|---|---|---|
| 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 |
Apple MobileCLIP (https://arxiv.org/pdf/2311.17049, FastViT und ViT-B) Unterstützung und Gewichtungen für Image Tower-Modelle hinzugefügt (Teil der OpenCLIP-Unterstützung).
ViTamin (https://arxiv.org/abs/2404.02132) CLIP-Bildturmmodell und Gewichte hinzugefügt (Teil der OpenCLIP-Unterstützung).
OpenAI CLIP Modifizierte ResNet-Bildturmmodellierung und Gewichtsunterstützung (über ByobNet). Refaktorieren Sie AttentionPool2d.
Unterstützt das Laden von PaliGemma-Jax-Gewichten in SigLIP ViT-Modelle mit durchschnittlichem Pooling.
Fügen Sie Hiera-Modelle aus Meta hinzu (https://github.com/facebookresearch/hiera).
Fügen Sie das Flag normalize= für Transorms hinzu und geben Sie den nicht normalisierten Torch.Tensor mit dem Original-Dytpe zurück (für chug ).
Version 1.0.3
Searching for Better ViT Baselines (For the GPU Poor) werden Gewichte und Vit-Varianten veröffentlicht. Erkunden Sie Modellformen zwischen Tiny und Base.
| Modell | top1 | top5 | param_count | img_size |
|---|---|---|---|---|
| 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 |
AttentionExtract-Helfer hinzugefügt, um Aufmerksamkeitskarten aus timm -Modellen zu extrahieren. Siehe Beispiel in #1232 (Kommentar)
Die API „ forward_intermediates() wurde verfeinert und zu weiteren Modellen hinzugefügt, einschließlich einiger ConvNets, die über andere Extraktionsmethoden verfügen.
1017 von 1047 Modellarchitekturen unterstützen features_only=True Feature-Extraktion. Die verbleibenden 34 Architekturen können unterstützt werden, jedoch basierend auf Prioritätsanfragen.
Entfernen Sie mit Torch.jit.script annotierte Funktionen, einschließlich alter JIT-Aktivierungen. Konflikt mit Dynamo und Dynamo leistet viel bessere Arbeit, wenn er verwendet wird.
Während wir uns auf die längst überfällige Version 1.0 vorbereiten, laufen die Dinge nun seit einiger Zeit stabil.
Bedeutende Funktion, die schon seit einiger Zeit fehlt, features_only=True Unterstützung für ViT-Modelle mit flachen versteckten Zuständen oder nicht standardmäßigen Modullayouts (bislang abgedeckt 'vit_*', 'twins_*', 'deit*', 'beit*', 'mvitv2*', 'eva*', 'samvit_*', 'flexivit*' )
Die obige Funktionsunterstützung wird durch eine neue forward_intermediates() API erreicht, die mit einem Feature-Wrapping-Modul oder direkt verwendet werden kann.
model = timm.create_model('vit_base_patch16_224')final_feat, medievals = model.forward_intermediates(input)
Ausgabe = model.forward_head(final_feat) # Pooling + Klassifikator headprint(final_feat.shape)torch.Size([2, 197, 768])für f in Zwischenstufen:print(f.shape)torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch .Size([2, 768, 14, 14])fackel.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size([2, 768, 14, 14])Torch.Size ([2, 768, 14, 14])print(output.shape)torch.Size([2, 1000]) model = timm.create_model('eva02_base_patch16_clip_224', pretrained=True, img_size=512, Features_only=True, out_indices=(-3, -2,))output = model(torch.randn(2, 3, 512, 512)) für o in der Ausgabe: print(o.shape)
Torch.Size([2, 768, 32, 32])Torch.Size([2, 768, 32, 32])TinyCLIP Vision Tower-Gewichte hinzugefügt, danke Thien Tran
Next-ViT-Modelle hinzugefügt. Angepasst von https://github.com/bytedance/Next-ViT
HGNet- und PP-HGNetV2-Modelle hinzugefügt. Angepasst von https://github.com/PaddlePaddle/PaddleClas von SeeFun
setup.py wurde entfernt und in einen auf pyproject.toml basierenden Build verschoben, der von PDM unterstützt wird
Fügen Sie ein aktualisiertes Modell-EMA-Impl mit _for_each hinzu, um den Overhead zu verringern
Unterstützt Geräteargumente im Trainingsskript für Nicht-GPU-Geräte
Weitere verschiedene Korrekturen und kleine Ergänzungen
Die minimal unterstützte Python-Version wurde auf 3.8 erhöht
Version 0.9.16
Datensätze und Transformations-Refactoring
Unterstützung für HuggingFace-Streaming-Datensätze (iterierbar) ( --dataset hfids:org/dataset )
Webdataset-Wrapper-Optimierungen für verbessertes Abrufen von Split-Informationen, können Splits automatisch aus unterstützten HF-Hub-Webdatasets abrufen
Getestete HF- datasets und Webdataset-Wrapper-Streaming vom HF-Hub mit aktuellen timm ImageNet-Uploads auf https://huggingface.co/timm
Machen Sie Eingabe- und Zielspalten-/Feldschlüssel in allen Datensätzen konsistent und übergeben Sie sie über Argumente
Vollständige Monochrom-Unterstützung bei Verwendung von z. B.: --input-size 1 224 224 oder --in-chans 1 legt die PIL-Bildkonvertierung im Datensatz entsprechend fest
Mehrere alternative Transformationen zum Zuschneiden und Ändern der Größe (ResizeKeepRatio, RandomCropOrPad usw.) für die Verwendung im PixParse-Dokument-KI-Projekt wurden verbessert
Fügen Sie den Erweiterungen und Argumenten ein Farbjitterproblem im SimCLR-Stil sowie Graustufen- und Gaußsche Unschärfeoptionen hinzu
Zug ohne Validierungssatz ( --val-split '' ) im Zugskript zulassen
Fügen Sie die Argumente --bce-sum (Summe über Klassendim) und --bce-pos-weight (positive Gewichtung) für das Training hinzu, da es sich dabei um häufige BCE-Verlustoptimierungen handelt. Ich habe oft hart codiert
EfficientViT-Large-Modelle hinzugefügt, danke SeeFun
Korrigieren Sie die Kompatibilität mit Python 3.7, die Unterstützung dafür wird bald eingestellt
Andere verschiedene Korrekturen
Version 0.9.12
Erhebliche Flexibilität für Hugging Face Hub-basierte Timm-Modelle über den Konfigurationseintrag model_args hinzugefügt. model_args werden bei der Erstellung als Kwargs an die Modelle weitergegeben.
Siehe Beispiel unter https://huggingface.co/gaunernst/vit_base_patch16_1024_128.audiomae_as2m_ft_as20k/blob/main/config.json
Verwendung: #2035
Aktualisierte Imagenet-Evaluierungs- und Testset-CSV-Dateien mit den neuesten Modellen
vision_transformer.py Typisierung und Dokumentbereinigung durch Laureηt
0.9.11-Version
DFN- (Data Filtering Networks) und MetaCLIP ViT-Gewichte hinzugefügt
DINOv2 „registrieren“ ViT-Modellgewichte hinzugefügt (https://huggingface.co/papers/2309.16588, https://huggingface.co/papers/2304.07193)
quickgelu ViT-Varianten für OpenAI-, DFN- und MetaCLIP-Gewichte hinzufügen, die es verwenden (weniger effizient)
Verbesserte Eingabe zu ResNet, MobileNet-v3 dank Aryan hinzugefügt
ImageNet-12k verfeinert (von LAION-2B CLIP) convnext_xxlarge
Version 0.9.9
SigLIP-Bildturmgewichte werden in vision_transformer.py unterstützt.
Großes Potenzial für die Feinabstimmung und nachgelagerte Funktionsnutzung.
Experimentelle „Register“-Unterstützung in Vit-Modellen gemäß Vision Transformers Need Registers
Aktualisiertes RepViT mit neuer Gewichtsfreigabe. Danke Wangao
Fügen Sie Swin-Modellen Unterstützung für die Größenänderung von Patches (bei vorab trainierter Gewichtsbelastung) hinzu
0.9.8-Veröffentlichung steht noch aus
TinyViT hinzugefügt von SeeFun
Korrigieren Sie EfficientViT (MIT), um Torch.autocast zu verwenden, damit es wieder auf PT 1.10 funktioniert
Version 0.9.7
Py Torch Image Models ( timm ) ist eine Sammlung von Bildmodellen, Ebenen, Dienstprogrammen, Optimierern, Planern , Datenladern/-erweiterungen und Referenztrainings-/Validierungsskripten, die darauf abzielen, eine Vielzahl von SOTA-Modellen kompetent zusammenzuführen um ImageNet-Trainingsergebnisse zu reproduzieren.
Die Arbeit vieler anderer ist hier vertreten. Ich habe versucht sicherzustellen, dass das gesamte Quellmaterial über Links zu Github, Arxiv-Papieren usw. in der README-Datei, der Dokumentation und den Code-Dokumentzeichenfolgen erwähnt wird. Bitte lassen Sie mich wissen, wenn ich etwas verpasst habe.
Alle Modellarchitekturfamilien umfassen Varianten mit vorab trainierten Gewichten. Es gibt bestimmte Modellvarianten ohne Gewichte, das ist KEIN Fehler. Hilfe beim Training neuer oder besserer Gewichte ist immer willkommen.
Aggregieren verschachtelter Transformatoren – https://arxiv.org/abs/2105.12723
BEiT – https://arxiv.org/abs/2106.08254
Big Transfer ResNetV2 (BiT) – https://arxiv.org/abs/1912.11370
Engpasstransformatoren – https://arxiv.org/abs/2101.11605
CaiT (Class-Attention in Image Transformers) – https://arxiv.org/abs/2103.17239
CoaT (Co-Scale Conv-Attentional Image Transformers) – https://arxiv.org/abs/2104.06399
CoAtNet (Faltung und Aufmerksamkeit) – https://arxiv.org/abs/2106.04803
ConvNeXt – https://arxiv.org/abs/2201.03545
ConvNeXt-V2 – http://arxiv.org/abs/2301.00808
ConViT (Soft Convolutional Induction Biases Vision Transformers) – https://arxiv.org/abs/2103.10697
CspNet (Cross-Stage Partial Networks) – 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 (Dual-Path Network) – https://arxiv.org/abs/1707.01629
EdgeNeXt – https://arxiv.org/abs/2206.10589
EfficientFormer – https://arxiv.org/abs/2206.01191
EfficientNet (MBConvNet-Familie)
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/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) und Small – https://arxiv.org/abs/1807.11626
MobileNet-V2 – https://arxiv.org/abs/1801.04381
Single-Path-NAS – 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 (Focal Modulation Networks) – https://arxiv.org/abs/2203.11926
GCViT (Global Context Vision Transformer) – 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
GPU-effiziente Netzwerke – https://arxiv.org/abs/2006.14090
Halo-Netze – https://arxiv.org/abs/2103.12731
HGNet / HGNet-V2 – TBD
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 und Inception-V4 – https://arxiv.org/abs/1602.07261
Lambda-Netzwerke – https://arxiv.org/abs/2102.08602
LeViT (Vision Transformer in ConvNets Kleidung) – https://arxiv.org/abs/2104.01136
MaxViT (Multi-Axis Vision Transformer) – https://arxiv.org/abs/2204.01697
MetaFormer (PoolFormer-v2, ConvFormer, CAFormer) – https://arxiv.org/abs/2210.13452
MLP-Mixer – https://arxiv.org/abs/2105.01601
MobileCLIP – https://arxiv.org/abs/2311.17049
MobileNet-V3 (MBConvNet mit effizientem Kopf) – 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 (Verbesserter Multiscale Vision Transformer) – 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
Pooling-basierter Vision Transformer (PiT) – https://arxiv.org/abs/2103.16302
PVT-V2 (Verbesserter Pyramid Vision Transformer) – https://arxiv.org/abs/2106.13797
RDNet (DenseNets Reloaded) – 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' / Gluon C-, D-, E-, S-Variationen – https://arxiv.org/abs/1812.01187
Schwach überwachtes (WSL) Instagram vorab trainiert / ImageNet abgestimmt ResNeXt101 – https://arxiv.org/abs/1805.00932
Halbüberwacht (SSL) / Halbschwach überwacht (SWSL) ResNet/ResNeXts – https://arxiv.org/abs/1905.00546
ECA-Net (ECAResNet) – https://arxiv.org/abs/1910.03151v4
Squeeze-and-Excitation-Netzwerke (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
Selektive Kernel-Netzwerke – https://arxiv.org/abs/1903.06586
Sequencer2D – https://arxiv.org/abs/2205.01972
Swin S3 (AutoFormerV2) – https://arxiv.org/abs/2111.14725
Swin Transformer – https://arxiv.org/abs/2103.14030
Swin Transformer V2 – https://arxiv.org/abs/2111.09883
Transformer-iN-Transformer (TNT) – https://arxiv.org/abs/2103.00112
TResNet – https://arxiv.org/abs/2003.13630
Zwillinge (räumliche Aufmerksamkeit in Vision Transformers) – https://arxiv.org/pdf/2104.13840.pdf
Visformer – https://arxiv.org/abs/2104.12533
Vision Transformer – https://arxiv.org/abs/2010.11929
ViTamin – https://arxiv.org/abs/2404.02132
VOLO (Vision Outlooker) – https://arxiv.org/abs/2106.13112
VovNet V2 und V1 – https://arxiv.org/abs/1911.06667
Xception – https://arxiv.org/abs/1610.02357
Xception (Modified Aligned, Gluon) – https://arxiv.org/abs/1802.02611
Xception (Modified Aligned, TF) – https://arxiv.org/abs/1802.02611
XCiT (Cross-Covariance Image Transformers) – https://arxiv.org/abs/2106.09681
Enthaltene Optimierer, die über die Factory-Methoden create_optimizer / create_optimizer_v2 verfügbar sind:
adabelief ist eine Implementierung von AdaBelief, angepasst von https://github.com/juntang-zhuang/Adabelief-Optimizer – https://arxiv.org/abs/2010.07468
adafactor angepasst von FAIRSeq impl – https://arxiv.org/abs/1804.04235
adahessian von David Samuel – https://arxiv.org/abs/2006.00719
adamp und sgdp von Naver ClovAI – https://arxiv.org/abs/2006.08217
adan eine Implementierung von Adan, angepasst von https://github.com/sail-sg/Adan – https://arxiv.org/abs/2208.06677
lamb eine Implementierung von Lamb und LambC (mit Trust-Clipping), bereinigt und geändert, um die Verwendung mit XLA zu unterstützen – https://arxiv.org/abs/1904.00962
lars eine Implementierung von LARS und LARC (mit Trust-Clipping) – https://arxiv.org/abs/1708.03888
lion und Implementierung von Lion angepasst von https://github.com/google/automl/tree/master/lion – https://arxiv.org/abs/2302.06675
lookahead angepasst von impl von Liam – https://arxiv.org/abs/1907.08610
madgrad – und Implementierung von MADGRAD angepasst von https://github.com/facebookresearch/madgrad – https://arxiv.org/abs/2101.11075
nadam eine Implementierung von Adam mit Nesterov-Momentum
nadamw eine Umsetzung von AdamW (Adam mit entkoppeltem Gewichtszerfall) mit Nesterov-Impuls. Ein vereinfachtes Impl basierend auf https://github.com/mlcommons/algorithmic-efficiency
novograd von Masashi Kimura – https://arxiv.org/abs/1905.11286
radam von Liyuan Liu – https://arxiv.org/abs/1908.03265
rmsprop_tf von mir selbst aus PyTorch RMSProp angepasst. Reproduziert das deutlich verbesserte Verhalten von Tensorflow RMSProp
sgdw und Implementierung von SGD mit entkoppeltem Gewichtsabfall
fused<name> -Optimierer namentlich mit installiertem NVIDIA Apex
bits<name> -Optimierer nach Namen mit installiertem BitsAndBytes
Zufälliges Löschen von Zhun Zhong – https://arxiv.org/abs/1708.04896)
Verwechslung – https://arxiv.org/abs/1710.09412
CutMix – https://arxiv.org/abs/1905.04899
AutoAugment (https://arxiv.org/abs/1805.09501) und RandAugment (https://arxiv.org/abs/1909.13719) ImageNet-Konfigurationen nach dem Vorbild von IPL für EfficientNet-Training (https://github.com/tensorflow/tpu/ blob/master/models/official/efficientnet/autoaugment.py)
AugMix mit JSD-Verlust, JSD mit Clean + Augmented-Mixing-Unterstützung funktioniert auch mit AutoAugment und RandAugment – https://arxiv.org/abs/1912.02781
SplitBachNorm – ermöglicht die Aufteilung von Batch-Normebenen zwischen sauberen und erweiterten (Hilfs-Batch-Norm-)Daten
DropPath, auch bekannt als „Stochastic Depth“ – https://arxiv.org/abs/1603.09382
DropBlock – https://arxiv.org/abs/1810.12890
Unschärfe-Pooling – https://arxiv.org/abs/1904.11486
Mehrere (weniger häufige) Funktionen, die ich in meinen Projekten häufig verwende, sind enthalten. Viele ihrer Ergänzungen sind der Grund, warum ich meine eigenen Modelle pflege, anstatt die anderer über PIP zu verwenden:
Alle Modelle verfügen über eine gemeinsame Standardkonfigurationsschnittstelle und API für
Zugriff auf/Änderung des Klassifikators – get_classifier und reset_classifier
eine Vorwärtsweitergabe nur für die Features durchführen – forward_features (siehe Dokumentation)
Dadurch ist es einfach, konsistente Netzwerk-Wrapper zu schreiben, die mit jedem der Modelle funktionieren
Alle Modelle unterstützen die Multiskalen-Feature-Map-Extraktion (Feature-Pyramiden) über create_model (siehe Dokumentation).
create_model(name, features_only=True, out_indices=..., output_stride=...)
out_indices -Erstellungsarg gibt an, welche Feature-Maps zurückgegeben werden sollen. Diese Indizes basieren auf 0 und entsprechen im Allgemeinen der C(i + 1) -Feature-Ebene.
Das Ausgabeargument output_stride “ steuert die Ausgabeschrittweite des Netzwerks mithilfe erweiterter Faltungen. Die meisten Netzwerke haben standardmäßig Schrittweite 32. Nicht alle Netzwerke unterstützen dies.
Die Anzahl der Feature-Map-Kanäle und der Reduktionsgrad (Schritt) können NACH der Modellerstellung über das .feature_info Mitglied abgefragt werden
Alle Modelle verfügen über einen konsistent vortrainierten Gewichtslader, der sich bei Bedarf linear anpasst, und bei Bedarf von 3 auf 1 Kanaleingang
Hochleistungs-Referenztrainings-, Validierungs- und Inferenzskripte, die in verschiedenen Prozess-/GPU-Modi funktionieren:
NVIDIA DDP mit einer einzelnen GPU pro Prozess, mehrere Prozesse mit vorhandenem APEX (AMP mit gemischter Präzision optional)
PyTorch DistributedDataParallel mit Multi-GPU, einzelner Prozess (AMP deaktiviert, da es bei Aktivierung abstürzt)
PyTorch mit Einzel-GPU-Einzelprozess (AMP optional)
Eine dynamische globale Pool-Implementierung, die bei der Modellerstellung die Auswahl zwischen durchschnittlichem Pooling, maximalem Pooling, Durchschnitt + Max oder Concat([Durchschnitt, Max]) ermöglicht. Das gesamte globale Pooling ist standardmäßig ein adaptiver Durchschnitt und mit vorab trainierten Gewichten kompatibel.
Ein „Test Time Pool“-Wrapper, der jedes der enthaltenen Modelle umschließen kann und in der Regel eine verbesserte Leistung bei Inferenzen mit Eingabebildern bietet, die größer als die Trainingsgröße sind. Die Idee wurde bei der Portierung von der ursprünglichen DPN-Implementierung übernommen (https://github.com/cypw/DPNs).
Lernratenplaner
AllenNLP-Planer
FAIRseq lr_scheduler
SGDR: Stochastischer Gradientenabstieg mit Warmstarts (https://arxiv.org/abs/1608.03983)
Ideen übernommen von
Zu den Planern gehören step , cosine mit Neustarts, tanh mit Neustarts und plateau
Space-to-Depth von mrT23 (https://arxiv.org/abs/1801.04590) – Originalpapier?
Adaptives Gradienten-Clipping (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)
Eine umfangreiche Auswahl an Kanal- und/oder räumlichen Aufmerksamkeitsmodulen:
Engpasstransformator – https://arxiv.org/abs/2101.11605
CBAM – https://arxiv.org/abs/1807.06521
Effektive Squeeze-Excitation (ESE) – https://arxiv.org/abs/1911.06667
Effiziente Kanalaufmerksamkeit (ECA) – https://arxiv.org/abs/1910.03151
Gather-Excite (GE) – https://arxiv.org/abs/1810.12348
Globaler Kontext (GC) – https://arxiv.org/abs/1904.11492
Halo – https://arxiv.org/abs/2103.12731
Involution – https://arxiv.org/abs/2103.06255
Lambda-Schicht – https://arxiv.org/abs/2102.08602
Nicht-lokal (NL) – https://arxiv.org/abs/1711.07971
Squeeze-and-Excitation (SE) – https://arxiv.org/abs/1709.01507
Selektiver Kernel (SK) – (https://arxiv.org/abs/1903.06586
Split (SPLAT) – https://arxiv.org/abs/2004.08955
Verschobenes Fenster (SWIN) – https://arxiv.org/abs/2103.14030
Die Ergebnisse der Modellvalidierung finden Sie in den Ergebnistabellen
Die offizielle Dokumentation finden Sie unter https://huggingface.co/docs/hub/timm. Dokumentationsbeiträge sind willkommen.
Getting Started with PyTorch Image Models (timm): A Practitioner's Guide von Chris Hughes ist ein ausführlicher Blogbeitrag, der viele Aspekte von timm im Detail behandelt.
timmdocs ist eine alternative Dokumentation für timm . Ein großer Dank geht an Aman Arora für seine Bemühungen bei der Erstellung von Timmdocs.
paperswithcode ist eine gute Ressource zum Durchsuchen der Modelle in timm .
Der Stammordner des Repositorys enthält Referenzzug-, Validierungs- und Inferenzskripte, die mit den enthaltenen Modellen und anderen Funktionen dieses Repositorys arbeiten. Sie können mit ein wenig Hacking an andere Datensätze und Anwendungsfälle angepasst werden. Siehe Dokumentation.
Einer der größten Vorteile von PyTorch ist die Community und ihre Beiträge. Nachfolgend sind einige meiner Lieblingsressourcen aufgeführt, die gut zu den hier aufgeführten Modellen und Komponenten passen.
Detectron2 – https://github.com/facebookresearch/detectron2
Segmentierungsmodelle (semantisch) – https://github.com/qubvel/segmentation_models.pytorch
EfficientDet (Obj Det, Semantic bald) – https://github.com/rwightman/efficientdet-pytorch
Albumentations – 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
PyTorch Metric Learning – https://github.com/KevinMusgrave/pytorch-metric-learning
Fastai – https://github.com/fastai/fastai
Der Code hier ist lizenzierter Apache 2.0. Ich habe darauf geachtet, sicherzustellen, dass der enthaltene oder angepasste Code Dritter über kompatible (zulässige) Lizenzen wie MIT, BSD usw. verfügt. Ich habe mich bemüht, GPL-/LGPL-Konflikte zu vermeiden. Es liegt jedoch in Ihrer Verantwortung sicherzustellen, dass Sie die hier aufgeführten Lizenzen und die Bedingungen aller abhängigen Lizenzen einhalten. Wo zutreffend, habe ich die Quellen/Referenzen für verschiedene Komponenten in Dokumentzeichenfolgen verlinkt. Wenn Sie der Meinung sind, dass ich etwas übersehen habe, erstellen Sie bitte ein Problem.
Bisher sind alle hier verfügbaren vorab trainierten Gewichte auf ImageNet vorab trainiert, wobei einige wenige über zusätzliches Vortraining verfügen (siehe zusätzlichen Hinweis unten). ImageNet wurde nur für nichtkommerzielle Forschungszwecke veröffentlicht (https://image-net.org/download). Es ist nicht klar, welche Auswirkungen dies auf die Verwendung vorab trainierter Gewichte aus diesem Datensatz hat. Alle Modelle, die ich mit ImageNet trainiert habe, werden zu Forschungszwecken erstellt und man sollte davon ausgehen, dass die ursprüngliche Datensatzlizenz für die Gewichte gilt. Wenn Sie beabsichtigen, die vortrainierten Gewichte in einem kommerziellen Produkt zu verwenden, sollten Sie sich am besten rechtlich beraten lassen.
Mehrere hier enthaltene Gewichtungen oder Referenzen wurden mit proprietären Datensätzen vorab trainiert, auf die ich keinen Zugriff habe. Dazu gehören die Facebook-Modelle WSL, SSL, SWSL ResNe(Xt) und Google Noisy Student EfficientNet. Die Facebook-Modelle verfügen über eine explizite nichtkommerzielle Lizenz (CC-by-nc 4.0, https://github.com/facebookresearch/Semi-supervised-imagenet1k-models, https://github.com/facebookresearch/wsl-image) . Die Google -Modelle scheinen keine Einschränkung über die Apache 2.0 -Lizenz (und die Bedenken hinsichtlich der ImageNet) zu haben. In jedem Fall sollten Sie sich mit Fragen an Facebook oder Google wenden.
@misc {rw2019timm, Author = {Ross Wightman}, title = {Pytorch -Bildmodelle}, Jahr = {2019}, Publisher = {Github}, Journal = {Github Repository}, doi = {10.5281/Zenodo.444861}, howpubliert = {url {https://github.com/rwightman/pytorch-image-models}}} 
