NVIDIA Jetson Nano: tests et premières impressions

Salut, Habr.

Relativement récemment, en 2019, NVIDIA a annoncé un ordinateur à carte unique compatible avec le facteur de forme Raspberry Pi, axé sur l'IA et les calculs gourmands en ressources.



Après sa mise en vente, il est devenu intéressant de voir comment cela fonctionne et ce qui peut être fait. Il n'est pas si intéressant d'utiliser des benchmarks standard, nous allons donc trouver les nôtres; pour tous les tests, le code source est donné dans le texte. Pour ceux qui s'intéressent à ce qui s'est passé, a continué sous la coupe.

Matériel informatique


Pour commencer, les spécifications du site Web de NVIDIA:



Parmi les intéressants, voici quelques points.

Le premier est un GPU avec 128 cœurs, respectivement, sur la carte, vous pouvez exécuter des tâches orientées GPU, telles que CUDA (pris en charge et installé immédiatement) ou Tensorflow. Le processeur principal est à 4 cœurs et, comme indiqué ci-dessous, est assez bon. 4 Go de mémoire partagée entre le processeur et le GPU.

Le second est la compatibilité avec le Raspberry Pi. La carte dispose d'un connecteur à 40 broches avec différentes interfaces (I2C, SPI, etc.), il y a aussi un connecteur de caméra, qui est également compatible avec le Raspberry Pi. On peut supposer qu'un grand nombre d'accessoires existants (écrans, cartes de commande de moteur, etc.) fonctionneront (vous devrez peut-être utiliser une rallonge, car Jetson Nano est toujours de taille différente).

Troisièmement, la carte dispose de 2 sorties vidéo, Gigabit-Ethernet et USB 3.0, c'est-à-dire Jetson Nano dans son ensemble est même un peu plus fonctionnel que le prototype. L'alimentation 5 V peut être prise à la fois via Micro USB et via un connecteur séparé, ce qui est recommandé pour extraire des bitcoins de tâches gourmandes en ressources. Comme dans le Raspberry Pi, le logiciel est chargé à partir de la carte SD, dont l'image doit d'abord être enregistrée. En général, idéologiquement, la carte est assez similaire au Raspberry Pi, qui a apparemment été conçu dans NVIDIA. Mais il n'y a pas de WiFi sur la carte, il y a un inconvénient certain, ceux qui le souhaitent devront utiliser un module USB-WiFi.

Si vous regardez de près, vous pouvez voir que la structure de l'appareil se compose de deux modules - le module Jetson Nano lui-même et la carte inférieure avec connecteurs, la connexion se fait via un connecteur.



C'est-à-dire la carte peut être déconnectée et utilisée séparément, elle peut être pratique pour les solutions intégrées.

En parlant de prix. Le prix d'origine de Jetson Nano aux États-Unis est de 99 $, le prix en Europe avec une majoration dans les magasins locaux est d'environ 130 euros (si vous obtenez des rabais, vous pouvez probablement trouver moins cher). On ne sait pas combien coûte Nano en Russie.

Logiciels


Comme mentionné ci-dessus, le téléchargement et l'installation ne sont pas très différents du Raspberry Pi. Nous chargeons l' image sur la carte SD via Etcher ou Win32DiskImager, entrons dans Linux, mettons les bibliothèques nécessaires. Un excellent guide étape par étape est ici , je l'ai utilisé. Passons tout de suite aux tests - essayez d'exécuter différents programmes sous Nano et voyez comment ils fonctionnent. À titre de comparaison, j'ai utilisé trois ordinateurs - mon ordinateur portable de travail (Core I7-6500U 2,5 GHz), le Raspberry Pi 3B + et le Jetson Nano.

Test CPU

Pour commencer, une capture d'écran de la commande lscpu.

Raspberry Pi 3B +:



Jetson nano:



Pour les calculs, commençons par quelque chose de simple, mais qui nécessite du temps processeur. Par exemple, en calculant le nombre Pi. J'ai pris un simple programme Python avec stackoverflow .

Je ne sais pas si c'est optimal ou pas, mais cela n'a pas d'importance pour nous - nous sommes intéressés par le temps relatif .

Code source sous le spoiler
import time # Source: https://stackoverflow.com/questions/9004789/1000-digits-of-pi-in-python def make_pi(): q, r, t, k, m, x = 1, 0, 1, 1, 3, 3 for j in range(10000): if 4 * q + r - t < m * t: yield m q, r, t, k, m, x = 10*q, 10*(rm*t), t, k, (10*(3*q+r))//t - 10*m, x else: q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2 t1 = time.time() pi_array = [] for i in make_pi(): pi_array.append(str(i)) pi_array = pi_array[:1] + ['.'] + pi_array[1:] pi_array_str = "".join(pi_array) print("PI:", pi_array_str) print("dT:", time.time() - t1) 


Comme prévu, le programme ne fonctionne pas rapidement. Résultat pour Jetson Nano: 0.8c.



Le Raspberry Pi 3B + a montré un temps sensiblement plus long: 3.06c. L'ordinateur portable «exemplaire» a terminé la tâche en 0,27 s. En général, même sans utiliser de GPU, le processeur principal de Nano est assez bon pour son facteur de forme. Ceux qui le souhaitent peuvent vérifier sur le Raspberry Pi 4, je ne l'ai pas disponible.

Il y a sûrement ceux qui veulent écrire dans les commentaires que Python n'est pas le meilleur choix pour de tels calculs, je répète encore une fois qu'il était important pour nous de comparer le temps, il n'est pas nécessaire de le minimiser. Il est clair qu'il existe des programmes qui calculent le nombre de Pi beaucoup plus rapidement.

Pycuda

Passons à des calculs plus intéressants en utilisant le GPU, pour lequel bien sûr (la carte est de NVIDIA), nous utiliserons CUDA. La bibliothèque PyCUDA a nécessité un certain chamanisme lors de l'installation, elle n'a pas trouvé cuda.h, l'utilisation de la commande "sudo env" PATH = $ PATH "pip install pycuda" a aidé, il y a peut-être une autre façon (plus d'options ont été discutées sur le forum devtalk.nvidia.com ).

Pour le test, j'ai pris le programme simple SimpleSpeedTest pour PyCUDA, qui compte simplement les sinus dans une boucle, il ne fait rien d'utile, mais il est tout à fait possible de l'évaluer, et son code est simple et clair.

Code source sous le spoiler
 # SimpleSpeedTest.py # https://wiki.tiker.net/PyCuda/Examples/SimpleSpeedTest import pycuda.driver as drv import pycuda.autoinit from pycuda.compiler import SourceModule import numpy import time blocks = 64 block_size = 128 nbr_values = blocks * block_size n_iter = 100000 print("Calculating %d iterations" % (n_iter)) print() ##################### # SourceModule SECTION # create two timers so we can speed-test each approach start = drv.Event() end = drv.Event() mod = SourceModule("""__global__ void gpusin(float *dest, float *a, int n_iter) { const int i = blockDim.x*blockIdx.x + threadIdx.x; for(int n = 0; n < n_iter; n++) { a[i] = sin(a[i]); } dest[i] = a[i]; }""") gpusin = mod.get_function("gpusin") # create an array of 1s a = numpy.ones(nbr_values).astype(numpy.float32) # create a destination array that will receive the result dest = numpy.zeros_like(a) start.record() # start timing gpusin(drv.Out(dest), drv.In(a), numpy.int32(n_iter), grid=(blocks,1), block=(block_size,1,1) ) end.record() # end timing # calculate the run length end.synchronize() secs = start.time_till(end)*1e-3 print("PyCUDA time and first three results:") print("%fs, %s" % (secs, str(dest[:3]))) print() ############# # CPU SECTION # use numpy the calculate the result on the CPU for reference a = numpy.ones(nbr_values).astype(numpy.float32) t1 = time.time() for i in range(n_iter): a = numpy.sin(a) print("CPU time and first three results:") print("%fs, %s" % (time.time() - t1, str(a[:3]))) 


Comme vous pouvez le voir, le calcul est effectué en utilisant le GPU via CUDA et en utilisant le CPU via numpy.

Résultats:
Jetson nano - GPU 0,67c, CPU 13,3c.
Raspberry Pi 3B + - CPU 41.85c, GPU - pas de données, CUDA sur RPi ne fonctionne pas.
Ordinateur portable - GPU 0,05 s, processeur 3,08 c.

Tout est assez attendu. Les calculs sur le GPU sont beaucoup plus rapides que les calculs sur le CPU (toujours 128 cœurs), le Raspberry Pi est assez en retard. Eh bien, bien sûr, peu importe combien vous nourrissez le loup, l'éléphant a toujours une carte vidéo pour ordinateur portable beaucoup plus rapide que la carte de Jetson Nano - il est probable qu'il y ait beaucoup plus de cœurs de traitement.

Conclusion


Comme vous pouvez le voir, la carte NVIDIA s'est avérée assez intéressante et très productive. Il est un peu plus grand et plus cher que le Raspberry Pi, mais si quelqu'un a besoin de plus de puissance de calcul avec une taille compacte, cela en vaut la peine. Bien sûr, ce n'est pas toujours nécessaire - par exemple, pour envoyer la température à narodmon, le Raspberry Pi Zero est suffisant, et avec plusieurs marges. Jetson Nano ne prétend donc pas remplacer la framboise et les clones, mais pour les tâches gourmandes en ressources, il est très intéressant (il peut s'agir non seulement de drones ou de robots mobiles, mais aussi, par exemple, d'une caméra pour sonnette avec reconnaissance faciale).

D'une part, tout ce qui était conçu ne convenait pas. Dans la deuxième partie, il y aura des tests de la partie AI - tests de Keras / Tensorflow et des tâches sur la classification et la reconnaissance d'image.

Source: https://habr.com/ru/post/fr460723/


All Articles