Ho installato tensorflow nel mio Ubuntu 16.04 usando la seconda risposta qui con l'installazione di apt Cuda integrata di Ubuntu.

Ora la mia domanda è come posso verificare se tensorflow sta davvero usando la gpu? Ho una GTX 960m GPU. Quando I import tensorflowquesto è l'output

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

Questo output è sufficiente per verificare se tensorflow sta usando gpu?

No, non credo che "aprire la libreria CUDA" sia sufficiente per dirlo, perché diversi nodi del grafico potrebbero trovarsi su dispositivi diversi.

Per scoprire quale dispositivo viene utilizzato, è possibile abilitare il posizionamento del dispositivo di registro in questo modo:

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

Controlla la tua console per questo tipo di output.

Oltre a utilizzare ciò sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))che è descritto in altre risposte e nella documentazione ufficiale di TensorFlow , puoi provare ad assegnare un calcolo alla gpu e vedere se hai un errore.

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

Qui

• "/ cpu: 0": la CPU della tua macchina.
• "/ gpu: 0": la GPU del tuo computer, se ne hai uno.

Se hai una gpu e puoi usarla, vedrai il risultato. Altrimenti vedrai un errore con una stacktrace lunga. Alla fine avrai qualcosa del genere:

Impossibile assegnare un dispositivo al nodo "MatMul": Impossibile soddisfare le specifiche esplicite del dispositivo "/ dispositivo: GPU: 0" perché nessun dispositivo corrispondente a tale specifica è registrato in questo processo

Recentemente alcune funzioni utili sono apparse in TF:

• tf.test.is_gpu_available indica se la gpu è disponibile
• tf.test.gpu_device_name restituisce il nome del dispositivo gpu

Puoi anche controllare i dispositivi disponibili nella sessione:

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

devices ti restituirà qualcosa di simile

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

Il seguente codice dovrebbe fornirti tutti i dispositivi disponibili per tensorflow.

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

Uscita campione

[name: "/ cpu: 0" device_type: "CPU" memory_limit: 268435456 località {} incarnazione: 4402277519343584096,

name: "/ gpu: 0" device_type: "GPU" memory_limit: 6772842168 località {bus_id: 1} incarnazione: 7471795903849088328 physical_device_desc: "dispositivo: 0, nome: GeForce GTX 1070, id bus pci: 0000: 05: 00.0"]

Penso che ci sia un modo più semplice per raggiungere questo obiettivo.

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

Di solito stampa come

Default GPU Device: /device:GPU:0

Questo mi sembra più facile piuttosto che quei registri dettagliati.

Tensorflow 2.0

Le sessioni non vengono più utilizzate in 2.0. Invece, si può usare tf.test.is_gpu_available:

import tensorflow as tf

assert tf.test.is_gpu_available()
assert tf.test.is_built_with_cuda()

Se viene visualizzato un errore, è necessario verificare l'installazione.

Ciò confermerà che tensorflow utilizza la GPU anche durante l'allenamento?

Codice

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

Produzione

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

Oltre ad altre risposte, quanto segue dovrebbe aiutarti ad assicurarti che la tua versione di tensorflow includa il supporto GPU.

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

Ok, prima lancia un ipython shelldal terminale e 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

Ora, possiamo guardare l'utilizzo della memoria GPU in una console usando il seguente comando:

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

Dato che abbiamo solo importeditato TensorFlow ma non abbiamo ancora usato alcuna GPU, le statistiche di utilizzo saranno:

Notare come l'utilizzo della memoria GPU è molto inferiore (~ 700 MB); A volte l'utilizzo della memoria della GPU potrebbe anche essere inferiore a 0 MB.

Ora, cariciamo la GPU nel nostro codice. Come indicato in tf documentation, fare:

In [2]: sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))

Ora, le statistiche dell'orologio dovrebbero mostrare una memoria di utilizzo della GPU aggiornata come di seguito:

Ora osserva come il nostro processo Python dalla shell ipython sta usando ~ 7 GB di memoria GPU.

PS Puoi continuare a guardare queste statistiche mentre il codice è in esecuzione, per vedere quanto intenso è l'uso della GPU nel tempo.

Questo dovrebbe fornire l'elenco dei dispositivi disponibili per Tensorflow (sotto 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)

Preferisco usare nvidia-smi per monitorare l'utilizzo della GPU. se aumenta in modo significativo all'avvio del programma, è un forte segnale che tensorflow sta usando la GPU.

Con i recenti aggiornamenti di Tensorflow, puoi verificarlo come segue:

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

Questo tornerà Truese la GPU viene utilizzata da Tensorflow, e restituirà Falsealtrimenti.

Se volete dispositivo device_nameè possibile digitare: tf.test.gpu_device_name(). Ottieni maggiori dettagli da qui

Esegui quanto segue in Jupyter,

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

Se hai impostato correttamente il tuo ambiente, otterrai il seguente output nel terminale in cui hai eseguito "notebook 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

Puoi vedere qui che sto usando TensorFlow con un Nvidia Quodro K620.

Trovo che sia più semplice interrogare la GPU dalla riga di comando:

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

se l'apprendimento è un processo in background da cui il pid jobs -pdovrebbe corrispondere al pid danvidia-smi

Puoi verificare se stai utilizzando la GPU eseguendo il seguente codice:

import tensorflow as tf
tf.test.gpu_device_name()

Se l'output è '', significa che stai usando CPUsolo;
Se l'output è qualcosa del genere /device:GPU:0, significa che GPUfunziona.

E usa il seguente codice per verificare quale GPUstai usando:

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

Metti questo vicino alla parte superiore del tuo quaderno jupyter. Commenta ciò che non ti serve.

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

NOTA: Con il rilascio di TensorFlow 2.0, Keras è ora incluso come parte dell'API TF.

Originariamente risposto qui .

Per Tensorflow 2.0

import tensorflow as tf

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

fonte qui

altra opzione è:

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

AGGIORNAMENTO PER TENSORFLOW> = 2.1.

Il modo raccomandato per verificare se TensorFlow utilizza la GPU è il seguente:

tf.config.list_physical_devices('GPU') 

A partire da TensorFlow 2.1, tf.test.gpu_device_name()è stato deprecato a favore di quanto sopra.

Questa è la linea che sto usando per elencare i dispositivi disponibili tf.sessiondirettamente da 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__);"

Stamperà i dispositivi disponibili e la versione tensorflow, ad esempio:

_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

Ho trovato di seguito lo snippet molto utile per testare la gpu ..

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

Di seguito verrà inoltre restituito il nome dei dispositivi GPU.

import tensorflow as tf
tf.test.gpu_device_name()

Con 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')]

Come suggerito da @AmitaiIrron:

Questa sezione indica che è stata trovata una gpu

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

E qui che è stato aggiunto come dispositivo fisico disponibile

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

Sono disponibili alcune opzioni per verificare se l'accelerazione GPU viene utilizzata dall'installazione di TensorFlow.

È possibile digitare i seguenti comandi in tre diverse piattaforme.

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

1. Notebook Jupyter: controlla la console su cui è in esecuzione Notebook Jupyter. Sarai in grado di vedere la GPU in uso.
2. Python Shell - Sarai in grado di vedere direttamente l'output. (Nota: non assegnare l'output del secondo comando alla variabile 'sess'; se questo aiuta).

3. Spyder: digitare il seguente comando nella console.

   import tensorflow as tf tf.test.is_gpu_available()

Tensorflow 2.1

Un semplice calcolo che può essere verificato con nvidia-smi per l'utilizzo della memoria sulla 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))

Se stai usando TensorFlow 2.0, puoi usarlo per loop per mostrare i dispositivi:

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

se stai usando tensorflow 2.x usa:

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

Esegui questo comando in Jupyter o nel tuo IDE per verificare se Tensorflow sta usando o meno una GPU: tf.config.list_physical_devices('GPU')