web-dev-qa-db-esp.com

¿Cómo saber si tensorflow está utilizando la aceleración gpu desde el interior de la carcasa de python?

He instalado tensorflow en mi ubuntu 16.04 usando la segunda respuesta here con la instalación integrada de Ubuntu CUD de Ubuntu.

Ahora mi pregunta es ¿cómo puedo probar si tensorflow realmente está usando gpu? Tengo un gtx 960m gpu. Cuando import tensorflow esta es la salida

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 comprobar si tensorflow está utilizando gpu?

184
Tamim Addari

No, no creo que la "biblioteca CUDA abierta" sea suficiente para decirlo, ya que los diferentes nodos del gráfico pueden estar en diferentes dispositivos.

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

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

Compruebe su consola para este tipo de salida.

 

198
Yao Zhang

Además de usar sess = tf.Session(config=tf.ConfigProto(log_device_placement=True)) que se describe en otras respuestas, así como en el TensorFlow oficial documentación , puede intentar asignar un cálculo al 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 tienes un gpu y puedes usarlo, verás el resultado. De lo contrario, verá un error con un largo seguimiento de pila. 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 '/ device: GPU: 0' porque no se han registrado dispositivos que coincidan con esa especificación en este proceso


Recientemente, algunas funciones útiles aparecieron en TF:

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

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

devices te devolverá algo así 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)
203
Salvador Dali

El siguiente fragmento de código debe proporcionarle todos los dispositivos disponibles para tensorflow.

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

Salida de muestra

[nombre: "/ cpu: 0" tipo de dispositivo: "CPU" memory_limit: 268435456 localidad {} encarnación: 4402277519343584096,

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

87
Sheraz

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 los registros detallados.

38
Ishan Bhatt

¿Esto confirmará que tensorflow usa GPU mientras entrena 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
26
himanshurobo

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

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

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

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

10
scott huang

Ok, primero lanza un ipython Shell desde la terminal y 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

Ahora, podemos ver el uso de la memoria de la GPU usando el comando:

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

Ya que solo hemos imported TensorFlow pero aún no hemos utilizado ninguna GPU, las estadísticas de uso serán:

 tf non-gpu usage

Observe cómo el uso de la memoria de la GPU es muy inferior (~ 200 MB).



Ahora, vamos a cargar la GPU en nuestro código. Como se indica en tf documentation , haga:

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

Ahora, watch stats debería mostrar la memoria de uso de GPU actualizada como se muestra a continuación:

 tf gpu-watch

Observe cómo nuestro proceso de Python desde el shell de ipython utiliza 7.7GB de la memoria de la GPU.


PD Puede continuar viendo estas estadísticas mientras se ejecuta el código, para ver qué tan intenso es el uso de la GPU.

8
kmario23

Me parece más fácil consultar el gpu desde la línea de comandos:

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 de jobs -p debe coincidir con el pid de nvidia-smi

7
Tim

Ejecuta 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á la siguiente salida de en el terminal donde ejecutó el "cuaderno 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

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

5
wafflecat

Tensorflow 2.0

A partir de tensorflow 2.0, las sesiones ya no se utilizan. Una forma que sigue funcionando para probar la funcionalidad de la GPU es:

import tensorflow as tf

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

Si recibe un error, necesita verificar su instalación.

5
ma3oun

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 está usando CPU solamente;
Si la salida es algo así como /device:GPU:0, significa que GPU funciona.


Y use el siguiente código para verificar qué GPU está usando:

from tensorflow.python.client import device_lib 
device_lib.list_local_devices()
3
Hu Xixi

Para asegurarse de que se estén utilizando actualmente tensoflow, keras y pytorch, consulte https://stackoverflow.com/a/53244520/420400

0
Paul Williams

Simplemente desde el símbolo del sistema o el entorno Linux, ejecute el siguiente comando.

python -c 'import torch; print(torch.cuda.is_available())' Lo anterior debe imprimir 'Verdadero'

python -c 'import torch; print(torch.Rand(2,3).cuda())' Esta debería imprimir lo siguiente

tensor([[0.7997, 0.6170, 0.7042], [0.4174, 0.1494, 0.0516]], device='cuda:0')

0
DSBLR