J'ai installé tensorflow dans mon Ubuntu 16.04 en utilisant la deuxième réponse ici avec l'installation intégrée de cuda d'ubuntu apt.

Maintenant, ma question est de savoir comment puis-je tester si tensorflow utilise vraiment gpu? J'ai un gpx gtx 960m. Quand je import tensorflowc'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 "bibliothèque CUDA ouverte" soit suffisante pour le dire, car différents nœuds du graphique peuvent se trouver sur différents appareils.

Pour savoir quel appareil est utilisé, vous pouvez activer le placement de l'appareil de journalisation comme ceci:

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))ce qui est décrit dans d'autres réponses ainsi que dans la documentation officielle de TensorFlow , 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 CPU 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 une longue trace de pile. À la fin, vous aurez quelque chose comme ceci:

Impossible d'affecter un périphérique au nœud 'MatMul': impossible de satisfaire la spécification de périphérique explicite '/ périphérique: 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 vérifier les appareils disponibles dans la session:

with tf.Session() as sess:
  devices = sess.list_devices()

devices vous rendra 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 appareils disponibles pour tensorflow.

from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())

Exemple de sortie

[name: "/ cpu: 0" device_type: "CPU" memory_limit: 268435456 locality {} incarnation: 4402277519343584096,

name: "/ gpu: 0" device_type: "GPU" memory_limit: 6772842168 locality {bus_id: 1} incarnation: 7471795903849088328 physical_device_desc: "device: 0, name: GeForce GTX 1070, id du bus pci: 0000: 05: 00.0"]

Je pense qu'il existe un moyen plus simple 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.

Tensorflow 2.0

Les sessions ne sont plus utilisées dans 2.0. Au lieu de cela, on peut utiliser tf.test.is_gpu_available:

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 confirmera que tensorflow utilise le GPU pendant l'entraînement?

Code

sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))

Production

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

En plus des autres réponses, les éléments suivants devraient vous aider à vous assurer que votre version de tensorflow inclut la prise en charge GPU.

import tensorflow as tf
print(tf.test.is_built_with_cuda())

Ok, lancez d'abord un ipython shelldepuis le terminal et importTensorFlow:

$ 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 regarder l'utilisation de la mémoire du GPU dans une console en utilisant la commande suivante:

# realtime update for every 2s
$ watch -n 2 nvidia-smi

Puisque nous n'avons importédité que TensorFlow mais que nous n'avons pas encore utilisé de GPU, les statistiques d'utilisation seront:

Remarquez que l'utilisation de la mémoire du GPU est très inférieure (~ 700 Mo); Parfois, l'utilisation de la mémoire GPU peut même être aussi faible que 0 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 une mémoire d'utilisation du GPU mise à jour comme ci-dessous:

Observez maintenant comment notre processus Python à partir du shell ipython utilise ~ 7 Go de mémoire GPU.

PS Vous pouvez continuer à regarder ces statistiques pendant l'exécution du code, pour voir à quel point l'utilisation du GPU est intense au fil du temps.

Cela devrait donner la liste des appareils 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 GPU. si elle augmente considérablement lorsque vous démarrez votre programme, c'est un signe fort que votre tensorflow utilise le GPU.

Avec les récentes mises à jour de Tensorflow, vous pouvez le vérifier comme suit:

tf.test.is_gpu_available( cuda_only=False, min_cuda_compute_capability=None)

Cela retournera Truesi le GPU est utilisé par Tensorflow, et retourneraFalse cas contraire.

Si vous voulez appareil , device_namevous pouvez taper: tf.test.gpu_device_name(). Obtenez plus de détails d' ici

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 la sortie suivante dans le terminal où vous avez exécuté "cahier jupyter" ,

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.

Je trouve que l'interrogation du GPU à partir de la ligne de commande est la 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 d'arrière-plan, le pid de jobs -pdoit correspondre au pid denvidia-smi

Vous pouvez vérifier si vous utilisez actuellement le GPU en exécutant le code suivant:

import tensorflow as tf
tf.test.gpu_device_name()

Si la sortie est '', cela signifie que vous utilisez CPUuniquement;
Si la sortie est quelque chose comme ça /device:GPU:0, cela signifie que cela GPUfonctionne.

Et utilisez le code suivant pour vérifier lequel GPUvous utilisez:

from tensorflow.python.client import device_lib 
device_lib.list_local_devices()

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 (for TensorFlow 1.X + Keras)
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()))

REMARQUE: avec la sortie de TensorFlow 2.0, Keras est désormais inclus dans le cadre de l'API TF.

Répondu à l'origine ici .

Pour Tensorflow 2.0

import tensorflow as tf

tf.test.is_gpu_available(
    cuda_only=False,
    min_cuda_compute_capability=None
)

source ici

une autre option est:

tf.config.experimental.list_physical_devices('GPU')

MISE À JOUR DU TENSORFLOW> = 2.1.

La méthode recommandée pour vérifier si TensorFlow utilise le GPU est la suivante:

tf.config.list_physical_devices('GPU') 

Depuis TensorFlow 2.1, tf.test.gpu_device_name()a été déprécié au profit de ce qui précède.

Voici la ligne que j'utilise pour répertorier les périphériques disponibles tf.sessiondirectement depuis 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 appareils disponibles et la version 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

J'ai trouvé ci-dessous l'extrait est très pratique pour tester le GPU ..

Test Tensorflow 2.0

import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
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))

Test Tensorflow 1

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))

Ce qui suit renverra également le nom de vos périphériques GPU.

import tensorflow as tf
tf.test.gpu_device_name()

Avec tensotflow 2.0> =

import tensorflow as tf
sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))

>>> import tensorflow as tf 
>>> tf.config.list_physical_devices('GPU')

2020-05-10 14:58:16.243814: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1
2020-05-10 14:58:16.262675: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-05-10 14:58:16.263119: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1555] Found device 0 with properties:
pciBusID: 0000:01:00.0 name: GeForce GTX 1060 6GB computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 10 deviceMemorySize: 5.93GiB deviceMemoryBandwidth: 178.99GiB/s
2020-05-10 14:58:16.263143: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-05-10 14:58:16.263188: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-05-10 14:58:16.264289: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-05-10 14:58:16.264495: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-05-10 14:58:16.265644: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-05-10 14:58:16.266329: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-05-10 14:58:16.266357: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-05-10 14:58:16.266478: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-05-10 14:58:16.266823: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-05-10 14:58:16.267107: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

Comme suggéré par @AmitaiIrron:

Cette section indique qu'un GPU a été trouvé

2020-05-10 14:58:16.263119: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1555] Found device 0 with properties:

pciBusID: 0000:01:00.0 name: GeForce GTX 1060 6GB computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 10 deviceMemorySize: 5.93GiB deviceMemoryBandwidth: 178.99GiB/s

Et ici, il a été ajouté en tant que périphérique physique disponible

2020-05-10 14:58:16.267107: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0

[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

Vous avez quelques options pour tester si l'accélération GPU est utilisée par votre installation TensorFlow.

Vous pouvez taper les commandes suivantes sur trois plates-formes différentes.

import tensorflow as tf
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))

1. Jupyter Notebook - Vérifiez la console qui exécute le Jupyter Notebook. Vous pourrez voir le GPU utilisé.
2. Python Shell - Vous pourrez voir directement la sortie. (Remarque - n'affectez pas la sortie de la deuxième commande à la variable 'sess'; si cela aide).

3. Spyder - Tapez la commande suivante dans la console.

   import tensorflow as tf tf.test.is_gpu_available()

Tensorflow 2.1

Un calcul simple qui peut être vérifié avec nvidia-smi pour l'utilisation de la mémoire sur le GPU.

import tensorflow as tf 

c1 = []
n = 10

def matpow(M, n):
    if n < 1: #Abstract cases where n < 1
        return M
    else:
        return tf.matmul(M, matpow(M, n-1))

with tf.device('/gpu:0'):
    a = tf.Variable(tf.random.uniform(shape=(10000, 10000)), name="a")
    b = tf.Variable(tf.random.uniform(shape=(10000, 10000)), name="b")
    c1.append(matpow(a, n))
    c1.append(matpow(b, n))

Si vous utilisez TensorFlow 2.0, vous pouvez l'utiliser pour la boucle pour afficher les périphériques:

with tf.compat.v1.Session() as sess:
  devices = sess.list_devices()
devices

si vous utilisez tensorflow 2.x, utilisez:

sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))

Exécutez cette commande dans Jupyter ou votre IDE pour vérifier si Tensorflow utilise ou non un GPU: tf.config.list_physical_devices('GPU')