Page d'accueil>Lié à la programmation>Python
Télécharger

(Générique) réseaux efficaces pour pytorch 

 - - **NOTE** This repo is not being maintained --

Veuillez utiliser timm à la place. Il comprend toutes ces définitions de modèle (poids compatibles) et bien plus encore.

Une implémentation «générique» d'efficacité, mixnet, mobileNetv3, etc. qui couvre la plupart des architectures efficaces de calcul / paramètres dérivées de la séquence de blocs mobilenet v1 / v2, y compris celles trouvées via une recherche d'architecture neurale automatisée.

Tous les modèles sont mis en œuvre par GenEfficientNet ou MobileNetV3 Classes, avec des définitions d'architecture basées sur des chaînes pour configurer les dispositions de blocs (IDEA d'ici)

Quoi de neuf

19 août 2020

  • Ajouter des poids mis à jour à Pytorch EfficientNet-B3 formé par moi-même avec timm (82.1 TOP-1)
  • Ajouter Pytorch formé EfficientNetNet-Lite0 apporté par @ HAL-314 (75,5 top-1)
  • Mettre à jour les scripts d'exportation / utilitaire de CAFX et de CAFE2 pour travailler avec le dernier Pytorch / ONNX
  • Script de validation basé sur l'ONNX ajouté
  • Les activations (principalement) ont été synchronisées avec les équivalents timm

5 avril 2020

  • Ajoutez des modèles MobileNet-V2 nouvellement formés formés avec les derniers H-Params, Rand Augment. Ils se comparent assez favorablement à EfficientNet-Lite
    • 3,5m param mobilenet-v2 100 @ 73%
    • 4,5m param mobilenet-v2 110d @ 75%
    • 6.1m param mobilenet-v2 140 @ 76,5%
    • 5,8m Param MobileNet-V2 120D @ 77,3%

23 mars 2020

  • Ajouter des modèles efficaces-lite avec des poids portés à partir de TensorFlow TPU
  • Ajouter les gros poids de mobilenet-v3 formé à Pytorch avec 75,77% TOP-1
  • Changement important (Si l'entraînement à partir de zéro) - Init de poids modifié pour mieux faire correspondre Tensorflow Implat, définissez fix_group_fanout=False dans initialize_weight_goog pour un ancien comportement

12 février 2020

  • Ajouter des poids de bruisset efficaces-L2 et B0-B7 portés à partir de TensorFlow TPU
  • PORT NOUVEAU EFFICETNET-B8 (Randaugment)
  • Ajouter Randaugment Pytorch formé EfficientNet-ES (EdgetPu-Small) avec 78,1 top-1. Formé par Andrew Lavin

22 janvier 2020

  • Mettez à jour les poids pour EfficientNet B0, B2, B3 et Mixnet-XL avec les derniers poids formés Randaugment. Formé avec (https://github.com/rwightman/pytorch-image-models)
  • Correction de la compatibilité TORCHScript pour Pytorch 1.4, ajoutez la prise en charge de TorchScript pour mixtesconv2d à l'aide de moduledict
  • Modèles de test, torchscript, ONNX Exportation avec Pytorch 1.4 - Aucun problème

22 novembre 2019

  • Nouveau top-1 haut! PORTAGE OFFICIEL TF EfficientNet Advprop (https://arxiv.org/abs/1911.09665) et spécification du modèle B8. Créé un nouvel ensemble de modèles ap car ils utilisent un prétraitement différent (moyenne de création / std) à partir des poids d'origine EfficientNet Base / AA / RA.

15 novembre 2019

  • TF OFFICIEL PORT
  • Modifications du modèle et composants MobileNet-V3 pour prendre en charge une configuration supplémentaire nécessaire pour les différences entre TF MobileNet-V3 et le mien

30 octobre 2019

  • Beaucoup de modèles fonctionneront désormais avec Torch.jit.script, Mixnet étant la plus grande exception
  • Interface améliorée pour activer les modes compatibles d'exportation TorchScript ou ONNX (via config)
  • Ajouter JIT optimisé Mem-Efficient Swish / Mish autograd.fn en plus de Autgrad.fn économe en mémoire
  • Factory d'activation pour sélectionner la meilleure version de l'activation par son nom ou remplacer un à l'échelle mondiale
  • Ajouter une aide de charge de point de contrôle pré-entraînée qui gère les modifications de l'entrée Conv et du classificateur

27 octobre 2019

  • Ajouter des variantes condconv efficiences entièrement portées à partir de https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet/condconv
  • Ajoutez des poids Randaug pour TF EfficientNet B5 et B7 à partir de https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet
  • Apportez le modèle MIXNET-XL et l'algo de mise à l'échelle de la profondeur de ma base de code Pytorch-Image-Models
  • Activations de commutation et mise en commun mondial vers les modules
  • Ajouter un swish / mésh économe en mémoire
  • Ajouter la méthode as_ Sequential () à tous les modèles et permettre un argument dans le point d'entrée FNS
  • Déplacez MobileNetv3 dans son propre fichier car il a une tête différente
  • Retirez Chamnet, Mobilenet V2 / V1 car ils ne seront probablement jamais utilisés ici

Modèles

Les modèles implémentés comprennent:

  • EfficientNet Noisystudent (B0-B7, L2) (https://arxiv.org/abs/1911.04252)
  • EfficientNet Advprop (B0-B8) (https://arxiv.org/abs/1911.09665)
  • EfficientNet (B0-B8) (https://arxiv.org/abs/1905.11946)
  • EfficientNet-EdgetPu (S, M, L) (https://ai.googleblog.com/2019/08/EfficientT-Edgetpu-creating.html)
  • EfficientNet-CondConv (https://arxiv.org/abs/1904.04971)
  • EfficientNet-Lite (https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet/lite)
  • Mixnet (https://arxiv.org/abs/1907.09595)
  • MNASNET B1, A1 (Squeeze-Excite) et Small (https://arxiv.org/abs/1807.11626)
  • Mobilenet-V3 (https://arxiv.org/abs/1905.02244)
  • FBNET-C (https://arxiv.org/abs/1812.03443)
  • NAS à Path unique (https://arxiv.org/abs/1904.02877)

J'ai initialement implémenté et formé certains de ces modèles avec du code ici, ce référentiel contient uniquement les modèles GenFensivetNet, la validation et le code d'exportation ONNX / CAFE2 associé.

Prénommagé

J'ai réussi à former plusieurs des modèles à des précisions à proximité ou au-dessus des papiers d'origine et des Implat officiels. Mon code de formation est ici: https://github.com/rwightman/pytorch-image-models

Modèle Prec @ 1 (err) Prec @ 5 (err) Param # (m) MADDS (M) Échelle d'image Résolution Recadrer
EfficientNet_B3 82.240 (17.760) 96.116 (3.884) 12.23 TBD bicubique 320 1.0
EfficientNet_B3 82.076 (17,924) 96.020 (3.980) 12.23 TBD bicubique 300 0,904
mixnet_xl 81.074 (18.926) 95.282 (4.718) 11.90 TBD bicubique 256 1.0
EfficientNet_B2 80.612 (19.388) 95.318 (4.682) 9.1 TBD bicubique 288 1.0
mixnet_xl 80.476 (19.524) 94.936 (5.064) 11.90 TBD bicubique 224 0,875
EfficientNet_B2 80.288 (19.712) 95.166 (4.834) 9.1 1003 bicubique 260 0,890
mixnet_l 78.976 (21.024 94.184 (5.816) 7.33 TBD bicubique 224 0,875
EfficientNet_B1 78.692 (21.308) 94.086 (5.914) 7.8 694 bicubique 240 0,882
EfficientNet_ES 78.066 (21.934) 93.926 (6.074) 5.44 TBD bicubique 224 0,875
EfficientNet_B0 77.698 (22.302) 93.532 (6.468) 5.3 390 bicubique 224 0,875
mobilenetv2_120d 77.294 (22.706 93.502 (6.498) 5.8 TBD bicubique 224 0,875
mixnet_m 77.256 (22.744) 93.418 (6.582) 5.01 353 bicubique 224 0,875
mobilenetv2_140 76.524 (23.476) 92.990 (7.010) 6.1 TBD bicubique 224 0,875
mixnet_s 75.988 (24.012) 92.794 (7.206) 4.13 TBD bicubique 224 0,875
mobilenetv3_large_100 75.766 (24.234) 92.542 (7.458) 5.5 TBD bicubique 224 0,875
mobilenetv3_rw 75.634 (24.366) 92.708 (7.292) 5.5 219 bicubique 224 0,875
EfficientNet_lite0 75.472 (24.528) 92.520 (7.480) 4.65 TBD bicubique 224 0,875
mnasnet_a1 75.448 (24.552) 92.604 (7.396) 3.9 312 bicubique 224 0,875
fbnetc_100 75.124 (24.876) 92.386 (7.614) 5.6 385 bilinéaire 224 0,875
mobilenetv2_110d 75.052 (24.948) 92.180 (7.820) 4.5 TBD bicubique 224 0,875
mnasnet_b1 74.658 (25,342) 92.114 (7.886) 4.4 315 bicubique 224 0,875
SPNASNET_100 74.084 (25.916) 91.818 (8.182) 4.4 TBD bilinéaire 224 0,875
mobilenetv2_100 72.978 (27.022) 91.016 (8.984) 3.5 TBD bicubique 224 0,875

Plus de modèles pré-entraînés à venir ...

Poids portés

Les poids portés à partir de points de contrôle TensorFlow pour les modèles efficaces de NET font à peu près la précision dans TensorFlow une fois qu'un même équivalent de rembourrage de convolution est ajouté, et les mêmes facteurs de recadrage, la mise à l'échelle de l'image, etc. (voir tableau) sont utilisés via des args de ligne CMD.

IMPORTANT:

  • Poids portés par TensorFlow pour EfficientNet Advprop (AP), EfficientNet EdgetPU, EfficientNet-CondConv, EfficientNet-Lite et MobileNet-V3 Les modèles utilisent le style de création (0,5, 0,5, 0,5) pour la moyenne et la MST.
  • L'activation du pipeline de prétraitement TensorFlow avec --tf-preprocessing au temps de validation améliorera les scores de 0,1 à 0,5%, très près de TF Imp.

Pour exécuter la validation pour tf_efficientnet_b5: python validate.py /path/to/imagenet/validation/ --model tf_efficientnet_b5 -b 64 --img-size 456 --crop-pct 0.934 --interpolation bicubic

Pour exécuter la validation avec un prétraitement TF pour tf_efficientnet_b5: python validate.py /path/to/imagenet/validation/ --model tf_efficientnet_b5 -b 64 --img-size 456 --tf-preprocessing

Pour exécuter la validation pour un modèle avec le prétraitement de création, c'est-à-dire EfficientNet-B8 Advprop: python validate.py /path/to/imagenet/validation/ --model tf_efficientnet_b8_ap -b 48 --num-gpu 2 --img-size 672 --crop-pct 0.954 --mean 0.5 --std 0.5

Modèle Prec @ 1 (err) Prec @ 5 (err) Param Échelle d'image Taille de l'image Recadrer
tf_efficientnet_l2_ns * tfp 88.352 (11.648) 98,652 (1.348) 480 bicubique 800 N / A
tf_efficientnet_l2_ns TBD TBD 480 bicubique 800 0,961
tf_efficientnet_l2_ns_475 88.234 (11.766) 98.546 (1.454) 480 bicubique 475 0,936
tf_efficientnet_l2_ns_475 * tfp 88.172 (11.828) 98.566 (1.434) 480 bicubique 475 N / A
tf_efficientnet_b7_ns * tfp 86.844 (13.156) 98.084 (1.916) 66.35 bicubique 600 N / A
tf_efficientnet_b7_ns 86.840 (13.160) 98.094 (1.906) 66.35 bicubique 600 N / A
tf_efficientnet_b6_ns 86.452 (13.548) 97.882 (2.118) 43.04 bicubique 528 N / A
tf_efficientnet_b6_ns * tfp 86.444 (13.556) 97.880 (2.120) 43.04 bicubique 528 N / A
tf_efficientnet_b5_ns * tfp 86.064 (13.936) 97.746 (2.254) 30.39 bicubique 456 N / A
tf_efficientnet_b5_ns 86.088 (13.912) 97.752 (2.248) 30.39 bicubique 456 N / A
tf_efficientnet_b8_ap * tfp 85.436 (14.564) 97.272 (2.728) 87.4 bicubique 672 N / A
tf_efficientnet_b8 * tfp 85.384 (14.616) 97.394 (2.606) 87.4 bicubique 672 N / A
tf_efficientnet_b8 85.370 (14,630) 97.390 (2.610) 87.4 bicubique 672 0,954
tf_efficientnet_b8_ap 85.368 (14.632) 97.294 (2.706) 87.4 bicubique 672 0,954
tf_efficientnet_b4_ns * tfp 85.298 (14.702) 97.504 (2.496) 19.34 bicubique 380 N / A
tf_efficientnet_b4_ns 85.162 (14.838) 97.470 (2,530) 19.34 bicubique 380 0,922
tf_efficientnet_b7_ap * tfp 85.154 (14.846) 97.244 (2.756) 66.35 bicubique 600 N / A
tf_efficientnet_b7_ap 85.118 (14.882) 97.252 (2.748) 66.35 bicubique 600 0,949
tf_efficientnet_b7 * tfp 84.940 (15.060) 97.214 (2.786) 66.35 bicubique 600 N / A
tf_efficientnet_b7 84.932 (15.068) 97.208 (2.792) 66.35 bicubique 600 0,949
tf_efficientnet_b6_ap 84.786 (15.214) 97.138 (2.862) 43.04 bicubique 528 0,942
tf_efficientnet_b6_ap * tfp 84.760 (15.240) 97.124 (2.876) 43.04 bicubique 528 N / A
tf_efficientnet_b5_ap * tfp 84.276 (15.724) 96.932 (3.068) 30.39 bicubique 456 N / A
tf_efficientnet_b5_ap 84.254 (15.746) 96.976 (3.024) 30.39 bicubique 456 0,934
tf_efficientnet_b6 * tfp 84.140 (15.860) 96.852 (3.148) 43.04 bicubique 528 N / A
tf_efficientnet_b6 84.110 (15.890) 96.886 (3.114) 43.04 bicubique 528 0,942
tf_efficientnet_b3_ns * tfp 84.054 (15.946) 96.918 (3.082) 12.23 bicubique 300 N / A
tf_efficientnet_b3_ns 84.048 (15.952) 96.910 (3.090) 12.23 bicubique 300 .904
tf_efficientnet_b5 * tfp 83.822 (16.178) 96.756 (3.244) 30.39 bicubique 456 N / A
tf_efficientnet_b5 83.812 (16.188) 96.748 (3.252) 30.39 bicubique 456 0,934
tf_efficientnet_b4_ap * tfp 83.278 (16.722) 96.376 (3,624) 19.34 bicubique 380 N / A
tf_efficientnet_b4_ap 83.248 (16,752) 96.388 (3.612) 19.34 bicubique 380 0,922
tf_efficientnet_b4 83.022 (16.978) 96,300 (3,700) 19.34 bicubique 380 0,922
tf_efficientnet_b4 * tfp 82.948 (17.052) 96.308 (3.692) 19.34 bicubique 380 N / A
tf_efficientnet_b2_ns * tfp 82.436 (17.564) 96.268 (3.732) 9.11 bicubique 260 N / A
tf_efficientnet_b2_ns 82.380 (17,620) 96.248 (3,752) 9.11 bicubique 260 0,89
tf_efficientnet_b3_ap * tfp 81.882 (18.118) 95.662 (4.338) 12.23 bicubique 300 N / A
tf_efficientnet_b3_ap 81.828 (18.172) 95.624 (4.376) 12.23 bicubique 300 0,904
tf_efficientnet_b3 81.636 (18.364) 95.718 (4.282) 12.23 bicubique 300 0,904
tf_efficientnet_b3 * tfp 81.576 (18.424) 95.662 (4.338) 12.23 bicubique 300 N / A
tf_efficientnet_lite4 81.528 (18.472) 95.668 (4.332) 13h00 bilinéaire 380 0,92
tf_efficientnet_b1_ns * tfp 81.514 (18.486) 95.776 (4.224) 7.79 bicubique 240 N / A
tf_efficientnet_lite4 * tfp 81.502 (18.498) 95.676 (4.324) 13h00 bilinéaire 380 N / A
tf_efficientnet_b1_ns 81.388 (18.612) 95.738 (4.262) 7.79 bicubique 240 0,88
tf_efficientnet_el 80.534 (19.466) 95.190 (4.810) 10.59 bicubique 300 0,904
tf_efficientnet_el * tfp 80.476 (19.524) 95.200 (4.800) 10.59 bicubique 300 N / A
tf_efficientnet_b2_ap * tfp 80.420 (19.580) 95.040 (4.960) 9.11 bicubique 260 N / A
tf_efficientnet_b2_ap 80.306 (19.694) 95.028 (4.972) 9.11 bicubique 260 0,890
tf_efficientnet_b2 * tfp 80.188 (19.812) 94.974 (5.026) 9.11 bicubique 260 N / A
tf_efficientnet_b2 80.086 (19.914) 94.908 (5.092) 9.11 bicubique 260 0,890
tf_efficientnet_lite3 79.812 (20.188) 94.914 (5.086) 8.20 bilinéaire 300 0,904
tf_efficientnet_lite3 * tfp 79.734 (20.266) 94.838 (5.162) 8.20 bilinéaire 300 N / A
tf_efficientnet_b1_ap * tfp 79.532 (20.468) 94.378 (5.622) 7.79 bicubique 240 N / A
tf_efficientnet_cc_b1_8e * tfp 79.464 (20.536) 94.492 (5.508) 39.7 bicubique 240 0,88
tf_efficientnet_cc_b1_8e 79.298 (20.702) 94.364 (5.636) 39.7 bicubique 240 0,88
tf_efficientnet_b1_ap 79.278 (20.722) 94.308 (5.692) 7.79 bicubique 240 0,88
tf_efficientnet_b1 * tfp 79.172 (20.828) 94.450 (5,550) 7.79 bicubique 240 N / A
tf_efficientnet_em * tfp 78,958 (21.042) 94.458 (5.542) 6.90 bicubique 240 N / A
tf_efficientnet_b0_ns * tfp 78.806 (21.194) 94.496 (5.504) 5.29 bicubique 224 N / A
tf_mixnet_l * tfp 78.846 (21.154) 94.212 (5.788) 7.33 bilinéaire 224 N / A
TF_EFFICITENET_B1 78.826 (21.174) 94.198 (5.802) 7.79 bicubique 240 0,88
tf_mixnet_l 78.770 (21.230) 94.004 (5.996) 7.33 bicubique 224 0,875
tf_efficientnet_em 78.742 (21.258) 94.332 (5.668) 6.90 bicubique 240 0,875
tf_efficientnet_b0_ns 78,658 (21,342) 94.376 (5.624) 5.29 bicubique 224 0,875
tf_efficientnet_cc_b0_8e * tfp 78.314 (21.686) 93.790 (6.210) 24.0 bicubique 224 0,875
tf_efficientnet_cc_b0_8e 77.908 (22.092) 93.656 (6.344) 24.0 bicubique 224 0,875
tf_efficientnet_cc_b0_4e * tfp 77.746 (22.254) 93.552 (6.448) 13.3 bicubique 224 0,875
tf_efficientnet_cc_b0_4e 77.304 (22.696) 93.332 (6.668) 13.3 bicubique 224 0,875
tf_efficientnet_es * tfp 77.616 (22.384) 93.750 (6.250) 5.44 bicubique 224 N / A
tf_efficientnet_lite2 * tfp 77,544 (22,456) 93.800 (6.200) 6.09 bilinéaire 260 N / A
tf_efficientnet_lite2 77.460 (22.540) 93.746 (6.254) 6.09 bicubique 260 0,89
tf_efficientnet_b0_ap * tfp 77.514 (22.486) 93.576 (6.424) 5.29 bicubique 224 N / A
TF_EFFICITENET_ES 77.264 (22.736) 93.600 (6.400) 5.44 bicubique 224 N / A
tf_efficientnet_b0 * tfp 77.258 (22.742) 93.478 (6.522) 5.29 bicubique 224 N / A
tf_efficientnet_b0_ap 77.084 (22.916) 93.254 (6.746) 5.29 bicubique 224 0,875
tf_mixnet_m * tfp 77.072 (22.928) 93.368 (6.632) 5.01 bilinéaire 224 N / A
tf_mixnet_m 76.950 (23.050) 93.156 (6.844) 5.01 bicubique 224 0,875
TF_EFFICITENET_B0 76.848 (23.152) 93.228 (6.772) 5.29 bicubique 224 0,875
tf_efficientnet_lite1 * tfp 76.764 (23.236) 93.326 (6.674) 5.42 bilinéaire 240 N / A
tf_efficientnet_lite1 76.638 (23.362) 93.232 (6.768) 5.42 bicubique 240 0,882
tf_mixnet_s * tfp 75.800 (24.200) 92.788 (7.212) 4.13 bilinéaire 224 N / A
tf_mobilenetv3_large_100 * tfp 75.768 (24.232) 92.710 (7.290) 5.48 bilinéaire 224 N / A
tf_mixnet_s 75.648 (24.352) 92.636 (7.364) 4.13 bicubique 224 0,875
tf_mobilenetv3_large_100 75.516 (24.484) 92.600 (7.400) 5.48 bilinéaire 224 0,875
tf_efficientnet_lite0 * tfp 75.074 (24.926) 92.314 (7.686) 4.65 bilinéaire 224 N / A
tf_efficientnet_lite0 74.842 (25.158) 92.170 (7.830) 4.65 bicubique 224 0,875
tf_mobilenetv3_large_075 * tfp 73,730 (26.270) 91.616 (8.384) 3.99 bilinéaire 224 N / A
tf_mobilenetv3_large_075 73.442 (26.558) 91.352 (8.648) 3.99 bilinéaire 224 0,875
tf_mobilenetv3_large_minimal_100 * tfp 72.678 (27.322) 90.860 (9.140) 3.92 bilinéaire 224 N / A
tf_mobilenetv3_large_minimal_100 72.244 (27.756) 90.636 (9.364) 3.92 bilinéaire 224 0,875
tf_mobilenetv3_small_100 * tfp 67.918 (32.082) 87.958 (12.042 2.54 bilinéaire 224 N / A
tf_mobilenetv3_small_100 67.918 (32.082) 87.662 (12.338) 2.54 bilinéaire 224 0,875
tf_mobilenetv3_small_075 * tfp 66.142 (33.858) 86.498 (13.502) 2.04 bilinéaire 224 N / A
tf_mobilenetv3_small_075 65.718 (34.282) 86.136 (13.864) 2.04 bilinéaire 224 0,875
tf_mobilenetv3_small_minimal_100 * tfp 63.378 (36,622) 84.802 (15.198) 2.04 bilinéaire 224 N / A
tf_mobilenetv3_small_minimal_100 62.898 (37.102) 84.230 (15.770) 2.04 bilinéaire 224 0,875

* Modèles TFP validés avec le pipeline tf-preprocessing

Google TF et TFLITE

  • https://github.com/tensorflow/tpu/tree/master/models/official/mnasnet
  • https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet
  • https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet

Usage

Environnement

Tout le développement et les tests ont été effectués dans des environnements Conda Python 3 sur les systèmes Linux X86-64, en particulier Python 3.6.x, 3.7.x, 3.8.x.

Les utilisateurs ont signalé qu'une installation Anaconda Python 3 dans Windows fonctionne. Je n'ai pas vérifié cela moi-même.

Les versions Pytorch 1.4, 1.5, 1.6 ont été testées avec ce code.

J'ai essayé de garder les dépendances minimales, la configuration est selon les instructions d'installation par défaut de Pytorch pour conda: 

 conda create -n torch-env
conda activate torch-env
conda install -c pytorch pytorch torchvision cudatoolkit=10.2

Centre de pytorch

Les modèles sont accessibles via l'API Pytorch Hub 

 >>> torch.hub.list('rwightman/gen-efficientnet-pytorch')
['efficientnet_b0', ...]
>>> model = torch.hub.load('rwightman/gen-efficientnet-pytorch', 'efficientnet_b0', pretrained=True)
>>> model.eval()
>>> output = model(torch.randn(1,3,224,224))

Pépin

Ce package peut être installé via PIP.

Installer (après conda env / install): 

 pip install geffnet

Évaluation d'évaluation: 

 >>> import geffnet
>>> m = geffnet.create_model('mobilenetv3_large_100', pretrained=True)
>>> m.eval()

Utilisation du train: 

 >>> import geffnet
>>> # models can also be created by using the entrypoint directly
>>> m = geffnet.efficientnet_b2(pretrained=True, drop_rate=0.25, drop_connect_rate=0.2)
>>> m.train()

Créer dans un conteneur nn., Pour Fast.ai, etc.: 

 >>> import geffnet
>>> m = geffnet.mixnet_l(pretrained=True, drop_rate=0.25, drop_connect_rate=0.2, as_sequential=True)

Exportation

Les scripts sont inclus pour

  • Exporter des modèles vers ONNX ( onnx_export.py )
  • graphique ONNX optimisé ( onnx_optimize.py ou onnx_validate.py w / --onnx-output-opt arg)
  • Valider avec ONNX Runtime ( onnx_validate.py )
  • Convertir le modèle ONNX en Caffe2 ( onnx_to_caffe.py )
  • Valider dans Caffe2 ( caffe2_validate.py )
  • Benchmark in Caffe2 w / flops, paramètres de sortie ( caffe2_benchmark.py )

À titre d'exemple, pour exporter le modèle prétrainé MobileNet-V3, puis exécuter une validation ImageNet: 

 python onnx_export.py --model mobilenetv3_large_100 ./mobilenetv3_100.onnx
python onnx_validate.py /imagenet/validation/ --onnx-input ./mobilenetv3_100.onnx

Ces scripts ont été testés pour fonctionner à partir de Pytorch 1.6 et ONNX 1.7 W / ONNX Runtime 1.4. L'exportation compatible CAFE2 nécessite désormais des args supplémentaires mentionnés dans le script d'exportation (pas nécessaires dans les versions antérieures).

Notes d'exportation

  1. Les poids portés TF avec le «même» rembourrage Conving activé ne peuvent pas être exportés vers ONNX à moins que l'indicateur _EXPORTABLE dans config.py est défini sur true. Utilisez config.set_exportable(True) comme dans le script onnx_export.py .
  2. Les modèles portés par TF avec «même» rembourrage auront le rembourrage fixé au moment de l'exportation vers la résolution utilisée pour l'exportation. Même si le rembourrage dynamique est pris en charge dans OPSET> = 11, je ne peux pas le faire fonctionner.
  3. L'installation ONNX Optimiser ne fonctionne pas de manière fiable dans Pytorch 1.6 / ONNX 1.7. Heureusement, l'inférence basée sur onnxruntime fonctionne très bien maintenant et comprend l'optimisation de la mouche.
  4. ONNX / CAF2 Export / importation se casse fréquemment avec différentes versions de versions Pytorch et ONNX. Veuillez vérifier leurs trackers respectifs avant de déposer des problèmes ici.
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout