Eu instalei o tensorflow no meu ubuntu 16.04 usando a segunda resposta aqui com a instalação interna do apt cuda do ubuntu.

Agora, minha pergunta é como posso testar se o tensorflow está realmente usando a gpu? Eu tenho uma GPU GTX 960m. Quando eu import tensorflowesta é a saída

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

Esta saída é suficiente para verificar se o tensorflow está usando a GPU?

Não, acho que a "biblioteca CUDA aberta" não é suficiente, porque diferentes nós do gráfico podem estar em dispositivos diferentes.

Para descobrir qual dispositivo é usado, você pode ativar o posicionamento do dispositivo de log desta maneira:

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

Verifique seu console para esse tipo de saída.

Além de usar o sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))que é descrito em outras respostas, bem como na documentação oficial do TensorFlow , você pode tentar atribuir um cálculo à gpu e verificar se há algum erro.

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

Aqui

• "/ cpu: 0": a CPU da sua máquina.
• "/ gpu: 0": a GPU da sua máquina, se você tiver uma.

Se você tem um gpu e pode usá-lo, verá o resultado. Caso contrário, você verá um erro com um longo rastreamento de pilha. No final, você terá algo parecido com isto:

Não é possível atribuir um dispositivo ao nó 'MatMul': não foi possível atender à especificação explícita do dispositivo '/ device: GPU: 0' porque nenhum dispositivo correspondente a essa especificação está registrado nesse processo

Recentemente, algumas funções úteis apareceram no TF:

• tf.test.is_gpu_available informa se o gpu está disponível
• tf.test.gpu_device_name retorna o nome do dispositivo gpu

Você também pode verificar os dispositivos disponíveis na sessão:

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

devices retornará 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)

O código a seguir deve fornecer todos os dispositivos disponíveis para o fluxo tensor.

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

Saída de amostra

[nome: "/ cpu: 0" device_type: "CPU" memory_limit: 268435456 locality {} encarnação: 4402277519343584096,

nome: "/ gpu: 0" device_type: "GPU" memory_limit: 6772842168 localidade {bus_id: 1} encarnação: 7471795903849088328 physical_device_desc: "device: 0, nome: GeForce GTX 1070, identificação de barramento pci: 0000: 05: 00.0"]

Eu acho que existe uma maneira mais fácil de conseguir isso.

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

Geralmente imprime como

Default GPU Device: /device:GPU:0

Isso me parece mais fácil do que os logs detalhados.

Tensorflow 2.0

As sessões não são mais usadas no 2.0. Em vez disso, pode-se usar tf.test.is_gpu_available:

import tensorflow as tf

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

Se você receber um erro, precisará verificar sua instalação.

Isso confirmará que o tensorflow usando a GPU durante o treinamento também?

Código

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

Resultado

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

Além de outras respostas, o seguinte deve ajudá-lo a garantir que sua versão do tensorflow inclua suporte à GPU.

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

Ok, primeiro inicie um ipython shelldo terminal e o 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

Agora, podemos assistir o uso da memória da GPU em um console usando o seguinte comando:

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

Como apenas importeditamos o TensorFlow, mas ainda não usamos nenhuma GPU, as estatísticas de uso serão:

Observe como o uso de memória da GPU é muito menor (~ 700 MB); Às vezes, o uso da memória da GPU pode chegar a 0 MB.

Agora, vamos carregar a GPU em nosso código. Conforme indicado em tf documentation, faça:

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

Agora, os relógios estatísticas devem mostrar um uso de memória GPU atualizado conforme a seguir:

Observe agora como nosso processo Python a partir do shell ipython está usando ~ 7 GB da memória da GPU.

PS Você pode continuar observando essas estatísticas enquanto o código está sendo executado, para ver a intensidade do uso da GPU ao longo do tempo.

Isso deve fornecer a lista de dispositivos disponíveis para o Tensorflow (em 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)

Eu prefiro usar a nvidia-smi para monitorar o uso da GPU. se aumentar significativamente quando você inicia o programa, é um forte sinal de que seu tensorflow está usando GPU.

Com as atualizações recentes do Tensorflow, você pode verificá-lo da seguinte forma:

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

Isso retornará Truese a GPU estiver sendo usada Tensorflowe, Falsecaso contrário , retornará .

Se você quiser dispositivo device_name, você pode digitar: tf.test.gpu_device_name(). Obtenha mais detalhes daqui

Execute o seguinte no Jupyter,

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

Se você configurou seu ambiente corretamente, obterá a seguinte saída no terminal em que executou o "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

Você pode ver aqui que estou usando o TensorFlow com uma Nvidia Quodro K620.

Acho que consultar a gpu na linha de comando é mais 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 |
+-----------------------------------------------------------------------------+

se o seu aprendizado é um processo em segundo plano, o pid jobs -pdeve corresponder ao pid denvidia-smi

Você pode verificar se atualmente está usando a GPU executando o seguinte código:

import tensorflow as tf
tf.test.gpu_device_name()

Se a saída for '', significa que você está usando CPUapenas;
Se a saída é algo assim /device:GPU:0, significa que GPUfunciona.

E use o seguinte código para verificar qual GPUvocê está usando:

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

Coloque isso perto da parte superior do seu notebook jupyter. Comente o que você não precisa.

# 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: Com o lançamento do TensorFlow 2.0, o Keras agora está incluído como parte da API TF.

Originalmente respondida aqui .

Para Tensorflow 2.0

import tensorflow as tf

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

fonte aqui

outra opção é:

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

ATUALIZAÇÃO PARA FLUXO DE TENSOR> = 2.1.

A maneira recomendada de verificar se o TensorFlow está usando GPU é a seguinte:

tf.config.list_physical_devices('GPU') 

A partir do TensorFlow 2.1, tf.test.gpu_device_name()foi preterido em favor do mencionado acima.

Esta é a linha que estou usando para listar os dispositivos disponíveis tf.sessiondiretamente no 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__);"

Ele imprimirá os dispositivos disponíveis e a versão do tensorflow, por exemplo:

_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

Encontrei abaixo o snippet é muito útil para testar a gpu ..

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

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

O seguinte também retornará o nome dos seus dispositivos GPU.

import tensorflow as tf
tf.test.gpu_device_name()

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

Como sugerido por @AmitaiIrron:

Esta seção indica que uma gpu foi encontrada

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 aqui que foi adicionado como um dispositivo físico disponível

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

Você tem algumas opções para testar se a aceleração da GPU está sendo usada pela instalação do TensorFlow.

Você pode digitar os seguintes comandos em três plataformas diferentes.

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

1. Jupyter Notebook - Verifique o console que está executando o Jupyter Notebook. Você poderá ver a GPU sendo usada.
2. Shell Python - Você poderá ver diretamente a saída. (Nota - não atribua a saída do segundo comando à variável 'sess'; se isso ajudar).

3. Spyder - Digite o seguinte comando no console.

   import tensorflow as tf tf.test.is_gpu_available()

Tensorflow 2.1

Um cálculo simples que pode ser verificado com a nvidia-smi para uso de memória na 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 você estiver usando o TensorFlow 2.0, poderá usar isso para loop para mostrar os dispositivos:

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

se você estiver usando o tensorflow 2.x, use:

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

Execute este comando no Jupyter ou no seu IDE para verificar se o Tensorflow está usando uma GPU ou não: tf.config.list_physical_devices('GPU')