UniRepLKNet
1.0.0
??? Actualités : La version journal étendue d'UniRepLKNet est publiée sur arxiv.
Un ConvNet unifie plusieurs modalités et surpasse les modèles spécifiques aux modalités . Cet article résume les directives architecturales pour créer un CNN à grand noyau, qui fonctionne étonnamment bien avec les images et d'autres modalités. Il s'agit de la dernière contribution à deux domaines influents : Structural Re-param (depuis RepVGG, Ding et al. 2021) et ConvNet à très grand noyau (depuis RepLKNet, Ding et al. 2022). Précision ImageNet de 88,0 %, COCO AP de 56,4, ADE20K mIoU de 55,6 avec uniquement la pré-formation ImageNet-22K . Vitesse et performances réelles plus élevées que les modèles récents comme ConvNeXt v2 et InternImage. Avec une architecture unifiée et un prétraitement extrêmement simple spécifique à une modalité, il atteint des performances de pointe en matière de reconnaissance audio et, plus étonnant encore, de prévision globale de la température et de la vitesse du vent (une tâche difficile de prévision de séries chronologiques à grande échelle), surpassant les système de prévision mondial existant.
Plus précisément, nous contribuons sous deux aspects :
UniRepLKNet signifie non seulement un « retour » pour ConvNet dans son domaine d'origine, mais met également en valeur le potentiel de ConvNet à grand noyau pour « conquérir » de nouveaux territoires, mettant en évidence une plus grande adaptabilité et une large utilité dans différentes modalités et tâches.
Les points de contrôle ImageNet, COCO et ADE20K ont été publiés (voir le dépôt huggingface ci-dessous), à l'exception de l'UniRepLKNet-S pré-entraîné ImageNet-22K et de l'UperNet avec UniRepLKNet-XL, qui ont été perdus, et nous les reproduisons.
Dernière nouvelle : correction d'un bug résultant de ce commit du 1er décembre 2023. Il est désormais corrigé. Si vous avez utilisé unireplknet.py après le 1er décembre 2023, veuillez vérifier votre code.
unireplknet.py afin que vous puissiez le copier-coller directement dans votre MMDetection ou MMSegmentation, par exemple ici et ici. Si vous ne souhaitez pas l'utiliser avec MMMDetection ou MMSegmentation, vous pouvez supprimer ces lignes de code en toute sécurité.timm.create_model pour créer les modèles. Par exemple, model = timm.create_model('unireplknet_l', num_classes=num_classes_of_your_task, in_22k_pretrained=True) appellera la fonction unireplknet_l définie ici, qui construira un UniRepLKNet-L et téléchargera automatiquement nos points de contrôle et chargera les poids. # The simplest way to use our model in your project is to copy-paste unireplknet.py into your working directory and create models. For example
from unireplknet import *
model = timm.create_model('unireplknet_l', num_classes=num_classes_of_your_task, in_22k_pretrained=True)
reparameterize_unireplknet() qui convertit un UniRepLKNet formé en structure d'inférence, ce qui supprime de manière équivalente les branches parallèles dans les blocs de reparam composés, les couches de normes par lots et le terme de biais dans GRN. Le pseudo-code du pipeline complet ressemblera à training_model = unireplknet_l (..., deploy = False )
train ( training_model )
trained_results = evaluate ( training_model )
training_model . reparameterize_unireplknet ()
inference_results = evaluate ( training_model )
# you will see inference_results are identical to trained_results
save ( training_model , 'converted_weights.pth' )
# use the converted model
deploy_model = unireplknet_l (..., deploy = True )
load_weights ( deploy_model , 'converted_weights.pth' )
deploy_results = evaluate ( deploy_model )
# you will see deploy_results == inference_results == trained_resultssome_unireplknet_model.reparameterize_unireplknet() équivaut à appeler timm.utils.reparameterize_model(some_unireplknet_model) . Donc, si vous utilisez notre code avec la base de code de timm, par exemple le code d'évaluation de timm, ajoutez simplement --reparam à votre commande pour que timm.utils.reparameterize_model soit appelé (voir ici). Nous avons proposé cinq façons de télécharger nos points de contrôle.
pip install huggingface_hub
Ensuite, utilisez huggingface_hub comme ceci dans votre code python, par exemple,
from huggingface_hub import hf_hub_download
repo_id = 'DingXiaoH/UniRepLKNet'
cache_file = hf_hub_download ( repo_id = repo_id , filename = FILE_NAME )
checkpoint = torch . load ( cache_file , map_location = 'cpu' )
model . load_state_dict ( checkpoint ) Consultez notre dépôt huggingface ou notre code pour FILE_NAME (par exemple, unireplknet_xl_in22k_pretrain.pth ).
Utilisez la CLI huggingface. Consultez le tutoriel.
Téléchargez automatiquement nos points de contrôle en passant in_1k_pretrained=True , in_22k_pretrained=True ou in_22k_to_1k=True lors de l'appel de nos fonctions fournies. Voir le code ici.
| nom | résolution | acc@1 | #params | FLOP | Poids |
|---|---|---|---|---|---|
| UniRepLKNet-A | 224x224 | 77,0 | 4,4 millions | 0,6G | chèque |
| UniRepLKNet-F | 224x224 | 78,6 | 6,2 millions | 0,9G | chèque |
| UniRepLKNet-P | 224x224 | 80,2 | 10,7 millions | 1,6G | chèque |
| UniRepLKNet-N | 224x224 | 81,6 | 18,3 millions | 2,8G | chèque |
| UniRepLKNet-T | 224x224 | 83.2 | 31M | 4,9G | chèque |
| UniRepLKNet-S | 224x224 | 83,9 | 56M | 9.1G | chèque |
| nom | résolution | #params | FLOP | chèque |
|---|---|---|---|---|
| UniRepLKNet-S | 224x224 | 56M | 26,7G | chèque |
| UniRepLKNet-B | 224x224 | 98M | 47,2G | chèque |
| UniRepLKNet-L | 192x192 | 218M | 105,4G | chèque |
| UniRepLKNet-XL | 192x192 | 386M | 187G | chèque |
| nom | résolution | acc@1 | #params | FLOP | chèque |
|---|---|---|---|---|---|
| UniRepLKNet-S | 384x384 | 86,4 | 56M | 26,7G | chèque |
| UniRepLKNet-B | 384x384 | 87,4 | 98M | 47,2G | chèque |
| UniRepLKNet-L | 384x384 | 87,9 | 218M | 105,4G | chèque |
| UniRepLKNet-XL | 384x384 | 88,0 | 386M | 187G | chèque |
Les fichiers de code, de document et de configuration ont été publiés. Voir le guide de détection ici.
Les points de contrôle ont déjà été libérés sur le visage enlacé. Vous pouvez les télécharger dès maintenant sur https://huggingface.co/DingXiaoH/UniRepLKNet/tree/main.
Ou vous pouvez télécharger ces points de contrôle depuis Google Drive comme suit :
| nom | résolution | carte de la boîte | masque carte | #params | FLOP | Poids |
|---|---|---|---|---|---|---|
| UniRepLKNet-T | 1280x800 | 51,7 | 44,9 | 89M | 749G | chèque |
| UniRepLKNet-S | 1280x800 | 53,0 | 45,9 | 113M | 835G | chèque |
| UniRepLKNet-S_22K | 1280x800 | 54.3 | 47.1 | 113M | 835G | chèque |
| UniRepLKNet-B_22K | 1280x800 | 54,8 | 47.4 | 155M | 978G | chèque |
| UniRepLKNet-L_22K | 1280x800 | 55,8 | 48.4 | 276M | 1385G | chèque |
| UniRepLKNet-XL_22K | 1280x800 | 56,4 | 49,0 | 443M | 1952G | chèque |
Les fichiers de code, de document et de configuration ont été publiés. Consultez le guide de segmentation ici.
Les points de contrôle ont déjà été libérés sur le visage enlacé. Vous pouvez les télécharger dès maintenant sur https://huggingface.co/DingXiaoH/UniRepLKNet/tree/main.
Ou vous pouvez télécharger ces points de contrôle depuis Google Drive comme suit :
| nom | résolution | mIoU (ss/ms) | #params | FLOP | Poids |
|---|---|---|---|---|---|
| UniRepLKNet-T | 512x512 | 48,6/49,1 | 61M | 946G | chèque |
| UniRepLKNet-S | 512x512 | 50,5/51,0 | 86M | 1036G | chèque |
| UniRepLKNet-S_22K | 512x512 | 51,9/52,7 | 86M | 1036G | chèque |
| UniRepLKNet-S_22K | 640x640 | 52,3/52,7 | 86M | 1618G | chèque |
| UniRepLKNet-B_22K | 640x640 | 53,5/53,9 | 130M | 1850G | chèque |
| UniRepLKNet-L_22K | 640x640 | 54,5/55,0 | 254M | 2507G | chèque |
| UniRepLKNet-XL_22K | 640x640 | 55,2/55,6 | 425M | 3420G | chèque |
Nous donnons un exemple de commande d'évaluation.
GPU unique
python main.py --model unireplknet_b --eval true
--resume unireplknet_b_in22k_to_in1k_384_acc87.40.pth
--input_size 384
--data_path /path/to/imagenet-1k
Multi-GPU
python -m torch.distributed.launch --nproc_per_node=8 main.py
--model unireplknet_b --eval true
--resume unireplknet_b_in22k_to_in1k_384_acc87.40.pth
--input_size 384
--data_path /path/to/imagenet-1k
Pour la formation ou le réglage fin d'UniRepLKNets sur ImageNet-1K ou 22K, consultez ce guide
Pour une documentation détaillée, veuillez vous référer à ces documents comme suit :
Nous utilisons une implémentation de conv à grand noyau dans PyTorch qui est plus efficace que le torch.nn.Conv2d natif. Il est implémenté sur la base de l'algorithme iGEMM et d'un outil léger nommé cutlass. L'installation est très simple et vous coûtera moins d'une minute. Si vous n'installez pas cette implémentation, vous pouvez toujours utiliser notre modèle partout où vous le souhaitez mais ce sera un peu plus lent.
unzip cutlass.zip et entrez dans le répertoire. Cette version de cutlass fournie dans ce référentiel fonctionne bien avec notre implémentation à grand noyau et plusieurs versions de Python. Vous pouvez également utiliser la branche cutlass maintenue par l'équipe MegEngine (clone https://github.com/MegEngine/cutlass), mais vous devrez peut-être être plus prudent avec votre version python (voir ce problème).cd examples/19_large_depthwise_conv2d_torch_extension./setup.py install --user . Si vous obtenez des erreurs, vérifiez votre CUDA_HOME .python depthwise_conv2d_implicit_gemm.pyPATH_TO_CUTLASS_DIRECTORY/examples/19_large_depthwise_conv2d_torch_extension dans votre PYTHONPATH afin que vous puissiez from depthwise_conv2d_implicit_gemm import DepthWiseConv2dImplicitGEMM n'importe où. Ensuite, vous pouvez utiliser DepthWiseConv2dImplicitGEMM en remplacement de nn.Conv2d .Il devrait fonctionner avec une large gamme de GPU et de versions PyTorch/CUDA. Nous vous suggérons d'essayer d'abord et de vérifier les environnements uniquement si vous obtenez des erreurs. Nos derniers testicules utilisaient les deux
Il est signalé (voir ici) qu'une incompatibilité de version de python peut entraîner une erreur ( forward_fp32.cu(212): error: more than one instance of constructor "cutlass::Tensor4DCoord::Tensor4DCoord" ... ou cutlass/include/cutlass/fast_math.h(741): error: no suitable conversion function from "__half" to "float" exists ). Veuillez mettre à niveau ou rétrograder votre python. Nous remercions sincèrement @sleeplessai et @ewrfcas d'avoir partagé leur expérience.
Les demandes d'extraction (par exemple, des implémentations meilleures ou autres ou des implémentations sur d'autres frameworks) sont les bienvenues.
Si le code et l'article vous aident dans vos recherches, veuillez citer :
@article{zhang2024scaling,
title={Scaling Up Your Kernels: Large Kernel Design in ConvNets towards Universal Representations},
author={Zhang, Yiyuan and Ding, Xiaohan and Yue, Xiangyu},
journal={arXiv preprint arXiv:2410.08049},
year={2024}
}
@inproceedings{ding2024unireplknet,
title={UniRepLKNet: A Universal Perception Large-Kernel ConvNet for Audio Video Point Cloud Time-Series and Image Recognition},
author={Ding, Xiaohan and Zhang, Yiyuan and Ge, Yixiao and Zhao, Sijie and Song, Lin and Yue, Xiangyu and Shan, Ying},
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
pages={5513--5524},
year={2024}
}
Ce projet est publié sous la licence Apache 2.0. Veuillez consulter le fichier LICENCE pour plus d'informations.
