EfficientNetV2
EfficientNetV2 est un classifieur d'images dont la profondeur, la largeur et le choix des blocs par étage ont été trouvés par neural architecture search, en optimisant conjointement l'exactitude et la vitesse d'entraînement plutôt que la seule exactitude. LibreYOLO le prend en charge pour une seule tâche : la classification.
- Tâches
- classify
- Tailles
- b0, b1, b2, b3 at 224 to 300 px
- Installer
pip install libreyolo- Niveau de support
- Pris en charge, depuis v. Modèles entraînables complémentaires : maintenus au vert dans la CI, avec des fonctionnalités ajoutées selon les occasions.
- Licences
- Code Apache-2.0, poids Apache-2.0. Usage commercial
Installation
EfficientNetV2 ne demande aucun extra optionnel. Tout ce qu'il importe fait partie de l'installation de base.
pip install libreyoloPrédire
Les poids sont téléchargés depuis Hugging Face au premier usage, puis mis en cache localement.
from libreyolo import LibreYOLO, SAMPLE_IMAGE model = LibreYOLO("LibreEfficientNetV2b0-cls.pt")result = model(SAMPLE_IMAGE, save=True) print(result.probs.top1, result.probs.top1conf)print(result.probs.top5)libreyolo predict model=LibreEfficientNetV2b0-cls.pt source=cat.jpg save=TrueL'objet Results renvoyé est celui que renvoie chaque famille, si bien que
passer à un autre modèle tient en une ligne. Un classifieur ne porte ni boîtes
ni masques : result.probs contient la prédiction sur l'image entière, avec
top1, top5, top1conf et top5conf. conf, iou et max_det sont
acceptés par parité d'API mais n'ont aucun effet, puisqu'il n'y a rien à
seuiller ni à supprimer sur un simple vecteur de probabilités. Voir
la prédiction pour les sources, le streaming et le traitement
des résultats.
Variantes
Quatre tailles, de b0 à b3, chacune évaluée à sa propre résolution et à son
propre ratio de crop plutôt qu'avec une taille d'entrée unique partagée par
toute la famille. Choisir une taille revient à arbitrer directement entre
nombre de paramètres et exactitude. La tâche est fixe : chaque taille ne
couvre que la classification. Le nom du fichier de poids se termine par
-cls.pt à toutes les tailles, et c'est ce suffixe que lit la factory pour
router vers cette famille ; aucun argument task= n'est nécessaire.
Entraîner
Le fine-tuning part du backbone ImageNet publié et reconstruit automatiquement
la couche de classification finale au nombre de classes du dataset cible.
imgsz prend par défaut la résolution d'évaluation propre à la taille
choisie, sauf si vous la fixez explicitement.
from libreyolo import LibreYOLO model = LibreYOLO("LibreEfficientNetV2b0-cls.pt")model.train(data="imagenette160", epochs=5)libreyolo train model=LibreEfficientNetV2b0-cls.pt data=imagenette160 epochs=5libreyolo train model=LibreEfficientNetV2b0-cls.pt data=imagenette160 \ epochs=50 device=0,1 batch=-1Sans réglage particulier, l'entraînement fait 100 époques à lr0=1e-3 avec
AdamW, un batch de 64 et un early stopping après 50 époques sans amélioration.
data accepte une racine de dataset (train/ et val/, un dossier par
classe), un nom court connu comme imagenette160, ou une URL .zip.
lora=True n'est pas pris en charge ici ; le passer lève une erreur, puisque
LoRA dans LibreYOLO vise les composants transformer dotés de couches
nn.Linear, et les blocs MBConv de cette famille n'en ont aucune.
Voir l'entraînement pour les datasets, l'augmentation, le multi-GPU et les loggers.
Valider
val() renvoie un dictionnaire de clés metrics/. Pour la classification, il
s'agit de l'exactitude top-1 et top-5 sur le split de validation.
from libreyolo import LibreYOLO model = LibreYOLO("LibreEfficientNetV2b0-cls.pt")metrics = model.val(data="imagenette160") print(metrics["metrics/accuracy_top1"])print(metrics["metrics/accuracy_top5"])libreyolo val model=LibreEfficientNetV2b0-cls.pt data=imagenette160Exporter
| Tâche | ONNX | TorchScript | ExecuTorch | TensorRT | OpenVINO | Paddle | MNN | RKNN | ncnn | TFLite | CoreML | Core AI |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| classify | classify to ONNX : pris en charge | classify to TorchScript : pris en charge | classify to ExecuTorch : pris en charge | classify to TensorRT : pris en charge | classify to OpenVINO : pris en charge | classify to Paddle : non pris en charge | classify to MNN : non pris en charge | classify to RKNN : non pris en charge | classify to ncnn : pris en charge | classify to TFLite : pris en charge | classify to CoreML : non pris en charge | classify to Core AI : pris en charge |
Un artefact exporté se recharge via LibreYOLO() selon son extension de
fichier, si bien qu'un fichier .onnx ou .engine se comporte comme un
checkpoint et renvoie le même Results. L'export liste les
arguments que chaque format accepte, ainsi que les extras que quelques-uns
ajoutent.
from libreyolo import LibreYOLO model = LibreYOLO("LibreEfficientNetV2b0-cls.pt")model.export(format="onnx")model.export(format="tensorrt", half=True)libreyolo export model=LibreEfficientNetV2b0-cls.pt format=onnxlibreyolo export model=LibreEfficientNetV2b0-cls.pt format=tensorrt half=Truefrom libreyolo import LibreYOLO, SAMPLE_IMAGE # La factory s'appuie sur l'extension du fichier, donc un artefact# exporté se charge comme n'importe quel checkpoint et renvoie le# même objet Results.model = LibreYOLO("LibreEfficientNetV2b0-cls.onnx")result = model(SAMPLE_IMAGE) print(result.probs.top1)Checkpoints
Tous les fichiers de poids publiés de cette famille.
| Fichier | Entrée (px) | Licence des poids |
|---|---|---|
| classify | ||
| LibreEfficientNetV2b0-cls.pt | 224 | apache-2.0 |
| LibreEfficientNetV2b1-cls.pt | 240 | apache-2.0 |
| LibreEfficientNetV2b2-cls.pt | 260 | apache-2.0 |
| LibreEfficientNetV2b3-cls.pt | 300 | apache-2.0 |
Tous les fichiers ci-dessus sont actuellement disponibles dans l<link>organisation LibreYOLO</link> et sont téléchargés à la première utilisation.
Licence
Vérifiez la licence dans le dépôt Hugging Face des poids précis que vous téléchargez. Chaque checkpoint de l<link>organisation LibreYOLO</link> en possède une, et elles ne sont pas toujours identiques au sein dune même famille. Ce dépôt fait autorité ; le résumé ci-dessous décrit les conditions applicables lors de la dernière vérification de cette page.
Ceci décrit les licences concernées et ne constitue pas un conseil juridique. Si la réponse a une importance commerciale, lisez vous-même les licences et consultez votre propre avocat.
- Travail d'origine
- EfficientNetV2, Google
- Licence du projet d'origine
- Apache-2.0
- Source du projet d'origine
- github.com/huggingface/pytorch-image-models
- Code de LibreYOLO
- MIT
- Poids
- Apache-2.0, republiés sur huggingface.co/LibreYOLO
- Interprétation
- Apache-2.0 is a permissive license, so these weights can be used in commercial and closed-source products. It asks you to keep its license text and attribution notices with any copy of the weights you redistribute, and it grants a patent license. It places no obligation on your own application code, and weights you train yourself on your own data are yours. The architecture is Google's design, whose reference implementation at google/automl is also Apache-2.0; LibreYOLO's implementation follows the block definitions, TensorFlow "SAME" padding and naming in timm, whose tf_efficientnetv2_b{0,1,2,3} ImageNet-1k weights (ported by Ross Wightman, no ImageNet-21k or extra data) are licensed Apache-2.0 and are what LibreYOLO ships.