He instalado tensorflow en mi ubuntu 16.04 usando la segunda respuesta aquí con la instalación de cuda apt incorporada de ubuntu.

Ahora mi pregunta es ¿cómo puedo probar si tensorflow realmente está usando gpu? Tengo una gtx gtx 960m. Cuando yo import tensorfloweste es el resultado

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

¿Es esta salida suficiente para verificar si tensorflow está usando gpu?

No, no creo que "abrir la biblioteca CUDA" sea suficiente, porque diferentes nodos del gráfico pueden estar en diferentes dispositivos.

Para saber qué dispositivo se utiliza, puede habilitar la ubicación del dispositivo de registro de esta manera:

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

Verifique su consola para este tipo de salida.

Además de utilizar lo sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))que se describe en otras respuestas, así como en la documentación oficial de TensorFlow , puede intentar asignar un cálculo a la GPU y ver si tiene un error.

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

aquí

• "/ cpu: 0": la CPU de su máquina.
• "/ gpu: 0": la GPU de su máquina, si tiene una.

Si tiene una GPU y puede usarla, verá el resultado. De lo contrario, verá un error con un largo stacktrace. Al final tendrás algo como esto:

No se puede asignar un dispositivo al nodo 'MatMul': no ​​se pudo satisfacer la especificación explícita del dispositivo '/ dispositivo: GPU: 0' porque no se registraron dispositivos que coincidan con esa especificación en este proceso

Recientemente aparecieron algunas funciones útiles en TF:

• tf.test.is_gpu_available le dice si el gpu está disponible
• tf.test.gpu_device_name devuelve el nombre del dispositivo gpu

También puede verificar los dispositivos disponibles en la sesión:

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

devices te devolveré algo como

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

El siguiente fragmento de código debería proporcionarle todos los dispositivos disponibles para tensorflow.

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

Salida de muestra

[name: "/ cpu: 0" device_type: "CPU" memory_limit: 268435456 localidad {} encarnación: 4402277519343584096,

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

Creo que hay una manera más fácil de lograr esto.

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

Por lo general, se imprime como

Default GPU Device: /device:GPU:0

Esto me parece más fácil que esos registros detallados.

Tensorflow 2.0

Las sesiones ya no se usan en 2.0. En cambio, uno puede usar tf.test.is_gpu_available:

import tensorflow as tf

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

Si obtiene un error, debe verificar su instalación.

¿Esto confirmará que tensorflow usa GPU durante el entrenamiento también?

Código

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

Salida

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

Además de otras respuestas, lo siguiente debería ayudarlo a asegurarse de que su versión de tensorflow incluya soporte para GPU.

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

Ok, primero inicie un ipython shelldesde la terminal y 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

Ahora, podemos ver el uso de memoria de la GPU en una consola usando el siguiente comando:

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

Como solo hemos importeditado TensorFlow pero aún no hemos usado ninguna GPU, las estadísticas de uso serán:

Observe cómo el uso de la memoria de la GPU es muy inferior (~ 700 MB); A veces, el uso de memoria de la GPU puede ser tan bajo como 0 MB.

Ahora, carguemos la GPU en nuestro código. Como se indica en tf documentation, hacer:

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

Ahora el reloj estadísticas deberían mostrar una memoria de uso de GPU actualizada como se muestra a continuación:

Observe ahora cómo nuestro proceso Python desde el shell ipython está utilizando ~ 7 GB de la memoria de la GPU.

PD: puede seguir viendo estas estadísticas mientras se ejecuta el código para ver qué tan intenso es el uso de la GPU con el tiempo.

Esto debería proporcionar la lista de dispositivos disponibles para Tensorflow (en 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)

Prefiero usar nvidia-smi para monitorear el uso de GPU. Si aumenta significativamente cuando inicia su programa, es una buena señal de que su tensorflow está utilizando GPU.

Con las actualizaciones recientes de Tensorflow, puede verificarlo de la siguiente manera:

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

Esto regresará Truesi GPU está siendo utilizado por Tensorflow, y regresará de lo Falsecontrario.

Si desea que el dispositivo device_namese puede escribir: tf.test.gpu_device_name(). Obtenga más detalles desde aquí

Ejecute lo siguiente en Jupyter,

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

Si ha configurado su entorno correctamente, obtendrá el siguiente resultado en el terminal donde ejecutó "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

Puedes ver aquí que estoy usando TensorFlow con un Nvidia Quodro K620.

Encuentro que consultar el gpu desde la línea de comandos es más fácil:

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 su aprendizaje es un proceso en segundo plano, el pid jobs -pdebería coincidir con el pid denvidia-smi

Puede verificar si actualmente está utilizando la GPU ejecutando el siguiente código:

import tensorflow as tf
tf.test.gpu_device_name()

Si la salida es '', significa que CPUsolo está usando ;
Si el resultado es algo así /device:GPU:0, significa que GPUfunciona.

Y use el siguiente código para verificar cuál GPUestá usando:

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

Pon esto cerca de la parte superior de tu cuaderno jupyter. Comenta lo que no necesitas.

# 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 el lanzamiento de TensorFlow 2.0, Keras ahora se incluye como parte de la API TF.

Originalmente respondido aquí .

Para Tensorflow 2.0

import tensorflow as tf

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

fuente aquí

otra opción es:

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

ACTUALIZACIÓN PARA FLUJO TENSOR> = 2.1.

La forma recomendada para verificar si TensorFlow está usando GPU es la siguiente:

tf.config.list_physical_devices('GPU') 

A partir de TensorFlow 2.1, tf.test.gpu_device_name()ha quedado en desuso a favor de lo anterior.

Esta es la línea que estoy usando para enumerar los dispositivos disponibles tf.sessiondirectamente desde 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__);"

Imprimirá los dispositivos disponibles y la versión de tensorflow, por ejemplo:

_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

Encontré que el fragmento a continuación es muy útil para probar el gpu.

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

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

Lo siguiente también devolverá el nombre de sus dispositivos 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')]

Según lo sugerido por @AmitaiIrron:

Esta sección indica que se encontró 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

Y aquí que se agregó como un dispositivo físico 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')]

Tiene algunas opciones para probar si su instalación de TensorFlow está utilizando la aceleración de GPU.

Puede escribir los siguientes comandos en tres plataformas diferentes.

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

1. Jupyter Notebook: comprueba la consola que ejecuta Jupyter Notebook. Podrá ver la GPU en uso.
2. Python Shell: podrá ver directamente el resultado. (Nota: no asigne la salida del segundo comando a la variable 'sess'; si eso ayuda).

3. Spyder: escriba el siguiente comando en la consola.

   import tensorflow as tf tf.test.is_gpu_available()

Tensorflow 2.1

Un cálculo simple que se puede verificar con nvidia-smi para el uso de memoria en la 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 está utilizando TensorFlow 2.0, puede usar esto para loop para mostrar los dispositivos:

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

si está utilizando tensorflow 2.x use:

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

Ejecute este comando en Jupyter o su IDE para verificar si Tensorflow está usando una GPU o no: tf.config.list_physical_devices('GPU')