Téléchargement CV CUDA - CV CUDA CODE Téléchargement

CV CUDA

C/C++

v0.13.0

Télécharger

Cv-cuda

CV-Cuda est un projet open source qui permet de construire des applications efficaces de l'intelligence artificielle de l'intelligence artificielle (IA) et de la vision par ordinateur (CV). Il utilise l'accélération de l'unité de traitement graphique (GPU) pour aider les développeurs à créer des pipelines pré et post-traitement très efficaces. CV-Cuda est né comme un effort de collaboration entre NVIDIA et ByTedance.

Reportez-vous à notre Guide de développeur pour plus d'informations sur les opérateurs disponibles.

Commencer

Pour obtenir une copie locale, suivez ces étapes.

Compatibilité

Cv-Cuda Build	Plate-forme	Version CUDA	Capacité de calcul Cuda	Architectures matérielles	Nvidia Driver	Versions Python	Compilateurs pris en charge (construire à partir de la source)	Compatibilité des API avec des binaires préconçus	Distributions OS / Linux testées avec des forfaits prédéfinis
x86_64_cu11	x86_64	11.7 ou plus tard	SM7 et plus tard	Volta, Turing, Ampère, Hopper, Ada Lovelace	R525 ou plus tard ***	3.8, 3.9, 3.10, 3.11	gcc> = 9 * gcc> = 11 **	gcc> = 9	Ubuntu> = 20,04 Wsl2 / ubuntu> = 20,04
x86_64_cu12	x86_64	12.2 ou plus tard	SM7 et plus tard	Volta, Turing, Ampère, Hopper, Ada Lovelace	R525 ou plus tard ***	3.8, 3.9, 3.10, 3.11	gcc> = 9 * gcc> = 11 **	gcc> = 9	Ubuntu> = 20,04 Wsl2 / ubuntu> = 20,04
aarch64_cu11	AARCH64	11.4	SM7 et plus tard	Jetson Agx orin	Jetpack 5.1	3.8	gcc> = 9 * gcc> = 11 **	gcc> = 9	Jetson Linux 35.x
aarch64_cu12	AARCH64	12.2	SM7 et plus tard	Jetson Agx Orin, Igx Orin + Ampère RTX6000, IGX ORIN + ADA RTX6000	Jetpack 6.0 DP, R535 (IGX OS V0.6)	3.10	gcc> = 9 * gcc> = 11 **	gcc> = 9	Jetson Linux 36.2 Igx os v0.6

* construction partielle, pas de module de test (voir limitations connues)
** build complet, y compris le module de test
*** Les échantillons nécessitent le conducteur R535 ou ultérieure pour fonctionner et ne sont officiellement soutenus avec CUDA 12.

Limites et problèmes connus

Pour les versions GCC inférieures à 11,0, le support C ++ 17 doit être activé lors de la compilation de CV-Cuda.
Le module de test C ++ ne peut pas construire avec GCC <11 (nécessite des fonctionnalités C ++ - 20 spécifiques). Avec GCC-9 ou GCC-10, veuillez construire avec l'option -DBUILD_TESTS=0
Les échantillons CV-Cuda nécessitent le conducteur R535 ou ultérieurement pour fonctionner et ne sont officiellement soutenus avec CUDA 12.
Une seule version CUDA (CUDA 11.X ou CUDA 12.x) de packages CV-Cuda (packages Debian, Tarballs, Python Wheels) peut être installé à la fois. Veuillez désinstaller tous les packages à partir d'une version CUDA donnée avant d'installer des packages à partir d'une version différente.
La documentation construite sur Ubuntu 20.04 a besoin d'une version à jour de Sphinx ( pip install --upgrade sphinx ) ainsi que de l'analyse explicitement de la version Python par défaut du système ./ci/build_docs path/to/build -DPYTHON_VERSIONS="<py_ver>" .
Les opérateurs de redimensionnement et de RandomrédimensementCroP interpolent incorrectement les valeurs de pixels près de la limite d'une image ou d'un tenseur lors de l'utilisation d'interpolation cubique. Cela sera fixé dans une version à venir.

Installation

Pour plus de commodité, nous fournissons des packages prédéfinis pour diverses combinaisons de versions CUDA, de versions Python et d'architectures ici. Les étapes suivantes décrivent comment installer CV-Cuda à partir de ces packages prédéfinis.

Nous soutenons deux principales voies alternatives:

Roues Python autonomes (contenant des bibliothèques C ++ / Cuda et des liaisons Python)
Installation d'archives Deb ou TAR (bibliothèques C ++ / CUDA, en-têtes, liaisons Python)

Choisissez la méthode d'installation qui répond à vos besoins d'environnement.

Installation de fichiers de roue Python

Téléchargez le fichier .whl approprié pour votre architecture informatique, votre version Python et CUDA à partir des actifs de version de la version actuelle de CV-Cuda. Les informations de publication de toutes les versions CV-Cuda peuvent être trouvées ici. Une fois téléchargé, exécutez la commande pip install pour installer la roue Python. Par exemple:

pip install cvcuda_ < cu_ver > - < x.x.x > -cp < py_ver > -cp < py_ver > -linux_ < arch > .whl

Où <cu_ver> est la version CUDA souhaitée, <xxx> est la version de version CV-Cuda, <py_ver> est la version Python souhaitée et <arch> est l'architecture souhaitée.

Veuillez noter que les roues Python sont autonomes, elles incluent à la fois les bibliothèques C ++ / CUDA et les liaisons Python.

Installation de fichiers Deb

Installez les bibliothèques C ++ / CUDA (Cvcuda-Lib *) et les en-têtes de développement (Cvcuda-Dev *) en utilisant apt :

sudo apt install -y ./cvcuda-lib- < x.x.x > - < cu_ver > - < arch > -linux.deb ./cvcuda-dev- < x.x.x > - < cu_ver > - < arch > -linux.deb

Installez les liaisons Python (cvcuda-python *) en utilisant apt :

sudo apt install -y ./cvcuda-python < py_ver > - < x.x.x > - < cu_ver > - < arch > -linux.deb

Où <cu_ver> est la version CUDA souhaitée, <py_ver> est la version Python souhaitée et <arch> est l'architecture souhaitée.

Installation de fichiers de goudron

Installez les bibliothèques C ++ / CUDA (Cvcuda-Lib *) et les en-têtes de développement (Cvcuda-Dev *):

tar -xvf cvcuda-lib- < x.x.x > - < cu_ver > - < arch > -linux.tar.xz
tar -xvf cvcuda-dev- < x.x.x > - < cu_ver > - < arch > -linux.tar.xz

Installez les liaisons Python (cvcuda-python *)

tar -xvf cvcuda-python < py_ver > - < x.x.x > - < cu_ver > - < arch > -linux.tar.xz

Où <cu_ver> est la version CUDA souhaitée, <py_ver> est la version Python souhaitée et <arch> est l'architecture souhaitée.

Construire à partir de la source

Suivez ces instructions pour construire CV-Cuda à partir de la source:

1. Configurez votre référentiel CV-Cuda local

Installez les dépendances nécessaires pour configurer le référentiel:

git
GIT-LFS: Pour récupérer des fichiers binaires à partir du référentiel distant

Sur Ubuntu> = 20.04, installez les packages suivants à l'aide apt :

sudo apt install -y git git-lfs

Cloner le référentiel

git clone https://github.com/CVCUDA/CV-CUDA.git

En supposant que le référentiel a été cloné dans ~/cvcuda , il doit être correctement configuré en exécutant le script init_repo.sh une seule fois.

 cd ~ /cvcuda
./init_repo.sh

2. Construire CV-Cuda

Installez les dépendances nécessaires pour construire CV-Cuda:

G ++ - 11: compilateur à utiliser
cmake (> = 3,20), ninja-build (facultatif): gérer les règles de construction
python3-dev: pour les liaisons Python
LibSSL-DEV: nécessaire par la rédaction de tests (utilitaires de hachage MD5)
Boîte à outils CUDA
patcher

Sur Ubuntu> = 20.04, installez les packages suivants à l'aide apt :

sudo apt install -y g++-11 cmake ninja-build python3-dev libssl-dev patchelf

Toute version de la boîte à outils 11.x ou 12.x CUDA devrait fonctionner. CV-Cuda a été testé avec 11.7 et 12.2, ces versions sont donc recommandées.

sudo apt install -y cuda-11-7
# or
sudo apt install -y cuda-12-2

Construisez le projet:

ci/build.sh [release | debug] [output build tree path] [-DBUILD_TESTS = 1 | 0] [-DPYTHON_VERSIONS = ' 3.8;3.9;3.10;3.11 ' ] [-DPUBLIC_API_COMPILERS = ' gcc-9;gcc-11;clang-11;clang-14 ' ]

Le type de build par défaut est «release».
Si le chemin de l'arborescence de build de sortie n'est pas spécifié, il sera build-rel pour les versions de libération et build-deb pour débogage.
La bibliothèque est dans build-rel/lib et les exécutables (tests, etc ...) sont dans build-rel/bin .
L'option -DBUILD_TESTS peut être utilisée pour désactiver / activer la construction des tests (activé par défaut, voir les limitations connues).
L'option -DPYTHON_VERSIONS peut être utilisée pour sélectionner les versions Python pour construire des liaisons et des roues pour. Par défaut, seule la version système par défaut Python3 sera sélectionnée.
L'option -DPUBLIC_API_COMPILERS peut être utilisée pour sélectionner les compilateurs utilisés pour vérifier la compatibilité publique de l'API. Par défaut, GCC-11, GCC-9, Clang-11 et Clang-14 sont essayés d'être sélectionnés et vérifiés.

3. Construire la documentation

Limitation connue: La documentation construite sur Ubuntu 20.04 a besoin d'une version à jour de Sphinx ( pip install --upgrade sphinx ) ainsi que de l'analyse explicitement de la version Python par défaut du système ./ci/build_docs path/to/build -DPYTHON_VERSIONS="<py_ver>" .

Installez les dépendances requises pour construire la documentation:

DOXYGEN: fichiers d'en-tête d'analyse pour la documentation de référence
Python3, Python3-Pip: Pour installer certains packages Python nécessaires
Sphinx, souffle, recommandation, graphiviz: pour rendre la documentation
sphinx-rtd-thème: thème de documentation utilisé

Sur Ubuntu, installez les packages suivants en utilisant apt et pip :

sudo apt install -y doxygen graphviz python3 python3-pip sphinx
python3 -m pip install breathe recommonmark graphviz sphinx-rtd-theme

Construisez la documentation:

ci/build_docs.sh [build folder]

Le dossier de construction par défaut est «build».

4. Construire et exécuter des échantillons

Pour des instructions sur la façon de construire des échantillons à partir de la source et les exécuter, consultez la documentation des échantillons.

5. Exécuter des tests

Installez les dépendances requises pour exécuter les tests:

Python3, Python3-Pip: Pour exécuter les tests de liaisons Python
torche: dépendances nécessaires aux tests de liaisons Python

Sur Ubuntu> = 20.04, installez les packages suivants à l'aide apt et pip :

sudo apt install -y python3 python3-pip
python3 -m pip install pytest torch numpy==1.26

Les tests sont dans <buildtree>/bin . Vous pouvez exécuter le script ci-dessous pour exécuter tous les tests à la fois. Voici un exemple lorsque Build Tree est créé dans build-rel :

build-rel/bin/run_tests.sh

6. Installateurs de package et roues Python

Installateurs de packages

Les installateurs peuvent être générés à l'aide de la commande CPACK suivante une fois que vous avez réussi le projet:

 cd build-rel
cpack .

Cela générera dans le répertoire de construction, les installateurs de Debian et Tarball (* .tar.xz), nécessaires à l'intégration dans d'autres distros.

Pour un choix à grain fin de ce que les installateurs généreront, la syntaxe complète est:

cpack . -G [DEB | TXZ]

Deb pour les forfaits Debian
Txz pour * .tar.xz tarballs.

Roues python

Par défaut, lors de la version de release , les liaisons et roues Python sont créées pour la version CUDA disponible et la ou les version (s) Python spécifiée. Les roues sont désormais sorties dans le dossier build-rel/python3/repaired_wheels (après avoir été traité par la commande auditwheel repair dans le cas de Manylinux). La roue Python générée unique est compatible avec toutes les versions de Python spécifiées lors de l'étape de construction CMake. Ici, build-rel est le répertoire de construction utilisé pour construire la construction de version.

Les nouvelles roues Python pour la conformité PYPI doivent être construites dans l'environnement Docker Manylinux 2014. Les images Docker peuvent être générées à l'aide du script docker/manylinux/docker_buildx.sh . Ces images garantissent que les roues répondent à Manylinux 2014 et aux normes PYPI.

Les roues construites peuvent toujours être installées à l'aide de pip . Par exemple, pour installer la roue Python construite pour CUDA 12.x, Python 3.10 et 3.11 sur les systèmes Linux X86_64:

pip install cvcuda_cu12- < x.x.x > -cp310.cp311-cp310.cp311-linux_x86_64.whl

Contributif

CV-Cuda est un projet open source. Dans le cadre de la communauté open source, nous nous engageons dans le cycle d'apprentissage, d'amélioration et de mise à jour qui fait prospérer cette communauté. Cependant, CV-Cuda n'est pas encore prêt pour les contributions externes.

Pour comprendre le processus de contribution du CV-Cuda, consultez notre page contributive. Pour comprendre notre engagement envers la communauté open source et fournir un environnement qui soutient et respecte les efforts de tous les contributeurs, veuillez lire notre code de conduite.

Cv-Cuda faire un outil d'opérateur

Le script mkop.sh est un outil puissant pour créer un échafaudage pour les nouveaux opérateurs dans la bibliothèque CV-Cuda. Il automatise plusieurs tâches, garantissant la cohérence et le temps d'économie.

Caractéristiques de `mkop.sh` :

Création de talons de l'opérateur : génère des modèles d'opérateur sans opération (sans opération), qui servent de point de départ pour la mise en œuvre de nouvelles fonctionnalités.
Personnalisation du fichier : modifie les fichiers de modèle pour inclure le nom du nouvel opérateur, assurant des conventions de dénomination cohérentes à travers la base de code.
Intégration CMake : ajoute les nouveaux fichiers d'opérateur aux CMakelists appropriés, facilitant la compilation et l'intégration transparentes dans le système de construction.
Python Bindings : Crée des talons de wrapper Python pour le nouvel opérateur, ce qui lui permet d'être utilisé dans des environnements Python.
Configuration des tests : génère des fichiers de test pour C ++ et Python, permettant le développement immédiat des tests unitaires pour le nouvel opérateur.

Comment utiliser `mkop.sh` :

Exécutez le script avec le nom de l'opérateur souhaité. Le script suppose qu'il est situé dans ~/cvcuda/tools/mkop .

./mkop.sh [Operator Name]

Si le script est exécuté à partir d'un emplacement différent, fournissez le chemin du répertoire racine CV-Cuda.

./mkop.sh [Operator Name] [CV-CUDA root]

Remarque : La première lettre du nouveau nom de l'opérateur est captialisée si nécessaire pour correspondre au reste des structures de fichiers.

Détails du processus:

Configuration initiale : le script commence par valider l'entrée et configurer les variables nécessaires. Il capitalise ensuite la première lettre du nom de l'opérateur pour adhérer aux conventions de dénomination.
Modification du modèle : il traite divers fichiers de modèle ( Public.h , PrivateImpl.cpp , etc.), en remplacement des espaces réservés par le nom du nouveau opérateur. Cela comprend l'ajustement des en-têtes de fichiers, des espaces de noms et des signatures de fonction.
CMake et Python Intégration : le script met à jour les fichiers CMakeLists.txt et les fichiers de modules Python pour inclure le nouvel opérateur, en veillant à ce qu'il soit reconnu par le système de construction et l'interface Python.
Test Framework : Enfin, il configure des fichiers de test pour C ++ et Python, permettant aux développeurs de commencer immédiatement à écrire des tests pour le nouvel opérateur.