Comment savoir si tensorflow utilise l'accélération gpu depuis le shell python?
J'ai installé tensorflow dans mon Ubuntu 16.04 en utilisant la deuxième réponse ici avec Ubuntu intégré à apt cuda installation.
Maintenant, ma question est de savoir comment puis-je vérifier si tensorflow utilise vraiment gpu? J'ai un gtu 960m GTX. Quand je import tensorflow c'est la sortie
I tensorflow/stream_executor/dso_loader.cc:105] successfully opened CUDA library libcublas.so locally
I tensorflow/stream_executor/dso_loader.cc:105] successfully opened CUDA library libcudnn.so locally
I tensorflow/stream_executor/dso_loader.cc:105] successfully opened CUDA library libcufft.so locally
I tensorflow/stream_executor/dso_loader.cc:105] successfully opened CUDA library libcuda.so.1 locally
I tensorflow/stream_executor/dso_loader.cc:105] successfully opened CUDA library libcurand.so locally
Cette sortie est-elle suffisante pour vérifier si tensorflow utilise gpu?
Non, je ne pense pas que "ouvrir la bibliothèque CUDA" soit suffisant, car différents nœuds du graphique peuvent se trouver sur différents périphériques.
Pour savoir quel périphérique est utilisé, vous pouvez activer le placement du périphérique de journal comme suit:
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
Vérifiez votre console pour ce type de sortie.
En plus d'utiliser sess = tf.Session(config=tf.ConfigProto(log_device_placement=True)) qui est décrit dans d'autres réponses ainsi que dans le document officiel TensorFlow documentation , vous pouvez essayer d'assigner un calcul au gpu et voir si vous avez une erreur.
import tensorflow as tf
with tf.device('/gpu:0'):
a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
c = tf.matmul(a, b)
with tf.Session() as sess:
print (sess.run(c))
Ici
- "/ cpu: 0": le processeur de votre machine.
- "/ gpu: 0": Le GPU de votre machine, si vous en avez un.
Si vous avez un gpu et pouvez l'utiliser, vous verrez le résultat. Sinon, vous verrez une erreur avec un long stacktrace. À la fin, vous aurez quelque chose comme ça:
Impossible d'assigner un périphérique au nœud 'MatMul': impossible de satisfaire à la spécification de périphérique explicite '/ device: GPU: 0' car aucun périphérique correspondant à cette spécification n'est enregistré dans ce processus.
Récemment, quelques fonctions utiles sont apparues dans TF:
- tf.test.is_gpu_available indique si le gpu est disponible
- tf.test.gpu_device_name renvoie le nom du périphérique gpu
Vous pouvez également rechercher les périphériques disponibles dans la session:
with tf.Session() as sess:
devices = sess.list_devices()
devices vous retournera quelque chose comme
[_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:CPU:0, CPU, -1, 4670268618893924978),
_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 17179869184, 6127825144471676437),
_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:XLA_GPU:0, XLA_GPU, 17179869184, 16148453971365832732),
_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:0, TPU, 17179869184, 10003582050679337480),
_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:1, TPU, 17179869184, 5678397037036584928)
Le morceau de code suivant devrait vous donner tous les dispositifs disponibles pour tensorflow.
from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())
Exemple de sortie
[nom: "/ cpu: 0" type_périphérique: "CPU" limite_mémoire: 268435456 localité {} incarnation: 4402277519343584096,
name: "/ gpu: 0" device_type: "GPU" memory_limit: 6772842168 locality {autobus_id: 1} incarnation: 7471795903849088328 physical_device_desc: "device: 0, name: GeForce GTX 1070, ID de bus pci: 0000: 05:00"
Je pense qu'il y a un moyen plus facile d'y parvenir.
import tensorflow as tf
if tf.test.gpu_device_name():
print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
else:
print("Please install GPU version of TF")
Il imprime généralement comme
Default GPU Device: /device:GPU:0
Cela me semble plus facile que ces journaux verbeux.
Cela confirmera que tensorflow utilisant GPU lors de la formation également?
Code
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
sortie
I tensorflow/core/common_runtime/gpu/gpu_device.cc:885] Found device 0 with properties:
name: GeForce GT 730
major: 3 minor: 5 memoryClockRate (GHz) 0.9015
pciBusID 0000:01:00.0
Total memory: 1.98GiB
Free memory: 1.72GiB
I tensorflow/core/common_runtime/gpu/gpu_device.cc:906] DMA: 0
I tensorflow/core/common_runtime/gpu/gpu_device.cc:916] 0: Y
I tensorflow/core/common_runtime/gpu/gpu_device.cc:975] Creating TensorFlow device (/gpu:0) -> (device: 0, name: GeForce GT 730, pci bus id: 0000:01:00.0)
Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: GeForce GT 730, pci bus id: 0000:01:00.0
I tensorflow/core/common_runtime/direct_session.cc:255] Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: GeForce GT 730, pci bus id: 0000:01:00.0
Outre les autres réponses, les éléments suivants devraient vous aider à vous assurer que votre version de tensorflow inclut la prise en charge du processeur graphique.
import tensorflow as tf
print(tf.test.is_built_with_cuda())
Tensorflow 2.
A partir de tensorflow 2.0, les sessions ne sont plus utilisées. Un moyen encore efficace de tester la fonctionnalité du processeur graphique est le suivant:
import tensorflow as tf
assert tf.test.is_gpu_available()
assert tf.test.is_built_with_cuda()
Si vous obtenez une erreur, vous devez vérifier votre installation.
Cela devrait donner la liste des périphériques disponibles pour Tensorflow (sous Py-3.6):
tf = tf.Session(config=tf.ConfigProto(log_device_placement=True))
tf.list_devices()
# _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 268435456)
Je préfère utiliser nvidia-smi pour surveiller l'utilisation du processeur graphique. s'il augmente de manière significative lorsque vous démarrez votre programme, c'est un signe fort que votre tensorflow utilise le processeur graphique.
Ok, lancez d’abord un _ipython Shell_ à partir du terminal et import TensorFlow
_$ ipython --pylab
Python 3.6.5 |Anaconda custom (64-bit)| (default, Apr 29 2018, 16:14:56)
Type 'copyright', 'credits' or 'license' for more information
IPython 6.4.0 -- An enhanced Interactive Python. Type '?' for help.
Using matplotlib backend: Qt5Agg
In [1]: import tensorflow as tf
_Maintenant, nous pouvons surveiller l'utilisation de la mémoire du GPU à l'aide de la commande:
_# realtime update for every 2s
$ watch -n 2 nvidia-smi
_Comme nous n’avons que importededans TensorFlow mais n’avons encore utilisé aucun GPU, les statistiques d’utilisation seront:
Observez comment l'utilisation de la mémoire du GPU est très réduite (~ 200 Mo).
Maintenant, chargeons le GPU dans notre code. Comme indiqué dans tf documentation , faites:
_In [2]: sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
_Maintenant, les statistiques de la montre doivent afficher la mémoire d'utilisation du GPU mise à jour comme ci-dessous:
Observez comment notre processus Python de l’ipython Shell utilise 7,7 Go de mémoire GPU.
P.S. Vous pouvez continuer à regarder ces statistiques pendant que le code est en cours d'exécution, pour voir l'intensité de l'utilisation du processeur graphique.
Je trouve que simplement interroger le gpu à partir de la ligne de commande est le plus simple:
nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 384.98 Driver Version: 384.98 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
|===============================+======================+======================|
| 0 GeForce GTX 980 Ti Off | 00000000:02:00.0 On | N/A |
| 22% 33C P8 13W / 250W | 5817MiB / 6075MiB | 0% Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: GPU Memory |
| GPU PID Type Process name Usage |
|=============================================================================|
| 0 1060 G /usr/lib/xorg/Xorg 53MiB |
| 0 25177 C python 5751MiB |
+-----------------------------------------------------------------------------+
si votre apprentissage est un processus en arrière-plan, le pid de jobs -p doit correspondre au pid de nvidia-smi
Exécutez ce qui suit dans Jupyter,
import tensorflow as tf
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
Si vous avez correctement configuré votre environnement, vous obtiendrez ce qui suit sortie dans le terminal sur lequel vous avez exécuté "jupyter notebook",
2017-10-05 14:51:46.335323: I c:\tf_jenkins\home\workspace\release-win\m\windows-gpu\py\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1030] Creating TensorFlow device (/gpu:0) -> (device: 0, name: Quadro K620, pci bus id: 0000:02:00.0)
Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: Quadro K620, pci bus id: 0000:02:00.0
2017-10-05 14:51:46.337418: I c:\tf_jenkins\home\workspace\release-win\m\windows-gpu\py\35\tensorflow\core\common_runtime\direct_session.cc:265] Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: Quadro K620, pci bus id: 0000:02:00.0
Vous pouvez voir ici que j'utilise TensorFlow avec un Nvidia Quodro K620.
Vous pouvez vérifier si vous utilisez actuellement le processeur graphique en exécutant le code suivant:
import tensorflow as tf
tf.test.gpu_device_name()
Si la sortie est '', cela signifie que vous utilisez uniquement CPU;
Si le résultat est quelque chose du genre /device:GPU:0, cela signifie que GPU fonctionne.
Et utilisez le code suivant pour vérifier quelle GPU vous utilisez:
from tensorflow.python.client import device_lib
device_lib.list_local_devices()
Avec les mises à jour récentes de Tensorflow, vous pouvez le vérifier comme suit:
tf.test.is_gpu_available( cuda_only=False, min_cuda_compute_capability=None)
Ceci retournera True si le GPU est utilisé par Tensorflow, et retournera False sinon.
Si vous voulez un périphérique device_name, vous pouvez taper: tf.test.gpu_device_name(). Obtenez plus de détails de ici
C’est la ligne que j’utilise pour répertorier les périphériques disponibles pour tf.session directement à partir de bash:
python -c "import os; os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'; import tensorflow as tf; sess = tf.Session(); [print(x) for x in sess.list_devices()]; print(tf.__version__);"
Il imprimera les périphériques disponibles et la version de tensorflow, par exemple:
_DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 268435456, 10588614393916958794)
_DeviceAttributes(/job:localhost/replica:0/task:0/device:XLA_GPU:0, XLA_GPU, 17179869184, 12320120782636586575)
_DeviceAttributes(/job:localhost/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 17179869184, 13378821206986992411)
_DeviceAttributes(/job:localhost/replica:0/task:0/device:GPU:0, GPU, 32039954023, 12481654498215526877)
1.14.0
Placez-le près du haut de votre cahier Jupyter. Commentez ce dont vous n'avez pas besoin.
# confirm TensorFlow sees the GPU
from tensorflow.python.client import device_lib
assert 'GPU' in str(device_lib.list_local_devices())
# confirm Keras sees the GPU
from keras import backend
assert len(backend.tensorflow_backend._get_available_gpus()) > 0
# confirm PyTorch sees the GPU
from torch import cuda
assert cuda.is_available()
assert cuda.device_count() > 0
print(cuda.get_device_name(cuda.current_device()))
A l'origine répondu ici .
Simplement à partir de la commande Invite ou de l'environnement Linux, exécutez la commande suivante.
python -c 'import torch; print(torch.cuda.is_available())' Ce qui précède doit afficher 'True'
python -c 'import torch; print(torch.Rand(2,3).cuda())' Celui-ci devrait imprimer ce qui suit
tensor([[0.7997, 0.6170, 0.7042], [0.4174, 0.1494, 0.0516]], device='cuda:0')