Como saber se o tensorflow está usando a aceleração gpu de dentro do shell python?

303

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?

Tamim Addari
fonte
1
Você deve ver algo assim no seu log: I tensorflow / core / common_runtime / gpu / gpu_device.cc: 838] Criando um dispositivo TensorFlow (/ gpu: 0) -> (dispositivo: 0, nome: GeForce GTX 980, identificação do barramento pci : 0000: 03: 00.0)
Yaroslav Bulatov
2
Existe uma log_device_placementabordagem em resposta. A maneira mais confiável é olhada cronograma conforme especificado neste comentário: github.com/tensorflow/tensorflow/issues/...
Yaroslav Bulatov
Sim, eu tenho essa saída seguinte resposta de Yao Zhang ...
Tamim Addari
@YaroslavBulatov em que log? Ele grava em um arquivo ou onde verifico se uma declaração como essa aparece?
Charlie Parker
1
Ele escreve em stdout ou stderr
Yaroslav Bulatov

Respostas:

290

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.

Yao Zhang
fonte
17
Eu tentei isso e imprime absolutamente nada. Alguma idéia do porquê disso?
Qubix 01/02
8
Você fez isso em um notebook jupiter?
Tamim Addari
27
A saída pode ser produzida no console a partir do qual você executou o Jupyter Notebook.
musically_ut
18
Podemos obter uma resposta atualizada para o Tensorflow V2 (onde o tf.Sessions não é suportado).
precisa saber é
6
@ iyop45 Para o tensorflow V2, o comando é um pouco modificado:sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))
Vandan 17/03
276

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:

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)
Salvador Dalí
fonte
17
Resultado: [[22. 28.] [49. 64.]]
George Pligoropoulos
6
@GeorgePligor, o resultado não é realmente importante aqui. Ou você tem um resultado e a GPU foi usado ou você tem um erro, o que significa que ele não foi usado
Salvador Dali
1
Isto não funcionou para mim. Eu executei isso dentro do meu Docker Container, que é exigido pelo nvidia-docker e etcetc. No entanto, não recebo nenhum erro e a CPU é quem faz o trabalho. Aumentei um pouco as matrizes (10k * 10k) para garantir que calcule por um tempo. O utilitário da CPU subiu para 100%, mas a GPU permaneceu fria como sempre.
Pascalwhoop
Eu recebi o erro "nenhum dispositivo correspondente" ao executá-lo no console. No IDE, como pycharm, não há erro. Acho que está relacionado à sessão que usei, que é diferente no console.
cn123h
Fácil de entender. Se a GPU disponível, ela imprimirá algo comoFound device 0 with properties: name: GeForce GTX 1080 Ti major: 6 minor: 1 memoryClockRate(GHz): 1.582 pciBusID: 0000:02:00.0 totalMemory: 10.92GiB freeMemory: 10.76GiB
#
166

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

Sheraz
fonte
9
Esta é a melhor resposta.
Lolski 18/10/19
3
e se esse comando não retornar nenhuma entrada com "GPU", isso significa que minha máquina simplesmente possui GPU ou o tensorflow não pode localizá-lo?
mercury0114
@ mercury0114 pode ser também. por exemplo, você pode ter uma gpu, mas não ter o tensorflow-gpu instalado corretamente.
Jimijazz # 7/19
4
Eu discordo, isso não responde à pergunta: não se trata de dispositivos disponíveis, mas de aparelhos usados . E isso pode ser uma história totalmente diferente! (por exemplo, TF usará apenas 1 GPU por padrão.
Mayou36
nome: "/ dispositivo: GPU: 0" device_type: "GPU" memory_limit: 10711446324 localidade {bus_id: 1 links {}} encarnação: 17935632445266485019 physical_device_desc: "device: 0, nome: GeForce RTX 2080 Ti, ID do barramento pci: 0000: 01: 00.0, capacidade de computação: 7,5 "]
kamran kausar em 11/06
89

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.

Ishan Bhatt
fonte
Acordado. Mais fácil do que as abordagens descritas acima. Imprime a lista de GPUs em uso. Graças
user907629
2
Melhor incrível de tudo
echan00
Este não é um teste válido. Ele retornará à instrução else mesmo se você tiver a versão GPU do tensorflow instalada.
Goddard
68

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.

ma3oun
fonte
Isso também funciona com o TF 1.14 (talvez até algumas versões mais antigas)!
Overdrivr
6
Agora é recomendado fazertf.config.list_physical_devices('GPU')
Roy Shilkrot 04/01
@Roy Shilkrot Acho que 'tf.config.list_physical_devices (' GPU ')' não funciona no Tensorflow 2.0
joselquin 05/01
1
@joselquin Os documentos do TF v2.x afirmam que deve funcionar: tensorflow.org/api_docs/python/tf/config/experimental/… , e posso verificar se funciona para mim.
Roy Shilkrot
29

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
himanshurobo
fonte
5
Por favor, inclua uma pequena explicação do motivo pelo qual sua resposta está funcionando (o que log_device_placementfaz e como ver CPU vs. GPU na saída?). Isso melhorará a qualidade da sua resposta!
Nander Speerstra
25

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())
karaspd
fonte
7
Aviso: Isso informa se o TensorFlow é compilado com GPU. Não se a GPU está sendo usada. (Se os controladores não estão instalados corretamente por exemplo, em seguida, a CPU é usado, mesmo se "is_built_with_cuda ()" é verdade.)
Ricardo Cruz
19

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:

uso de não-gpu

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:

tf gpu-watch

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.

kmario23
fonte
1
Eu gostaria de poder estrelar respostas. Este é de ouro
Zain Rizvi
18

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)
f0nzie
fonte
Cara, eu diminuí a votação da sua pergunta por engano ... se você editar a sua pergunta, eu cancelarei o meu voto negativo #
Francesco Boi
14

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.

Scott Huang
fonte
Esta é uma forma indireta
papabiceps
Como você usa o nvdia-smi para monitorar o uso da GPU?
Razin
depois de instalar o cuda. A nvidia-smi deve estar no seu sistema. Eu normalmente uso 'nvidia-smi -l' para monitorar o uso.
scott huang
3
Você também pode usar relógio nvidia-SMI, atualiza a tela a cada 2 segundos
Perseus14
assistir nvidia-smi funciona bem para mim. Eu também pode ver na saída que o meu processo de python está usando a GPU
fórmica
9

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

Soufiane Chami
fonte
8

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.

wafflecat
fonte
Jupyter não é necessário em tudo, por favor, não adicionar complexidade à questão
Patrizio Bertoni
1
Alguns usuários podem querer garantir que a GPU seja utilizável no Jupyter. Além disso, isso pode ser executado a partir de um script Python.
wafflecat
8

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

Tim
fonte
6

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()
Hu Xixi
fonte
Se a saída é ' ', então o que devemos fazer?
Jason
@ Jason Basta reinstalar uma versão da GPU.
Hu Xixi 23/01
6

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 .

Paul Williams
fonte
5

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')
CaosPredictor
fonte
1
is_gpu_available(de tensorflow.python.framework.test_util) foi descontinuado e será removido em uma versão futura.
Himanshu Teotia 18/01
5

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.

Timbus Calin
fonte
3

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
y.selivonchyk
fonte
3

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))
ajayramesh
fonte
3

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

import tensorflow as tf
tf.test.gpu_device_name()
Maz
fonte
Se a saída deste comando for uma string vazia ... como faço para depurar?
zthomas.nc 5/04
3

Com tensotflow 2.0> =

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

insira a descrição da imagem aqui

Leplandelaville
fonte
3
>>> 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')]
bLeDy
fonte
Seria útil se você apontar para as seções na saída que indicam se uma GPU é usada.
Amitai Irron
@AmitaiIrron Obrigado pela sugestão, espero que esteja um pouco mais claro agora.
bLeDy
2

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

simpleParadox
fonte
2

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))
cannin
fonte
1

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
Doug
fonte
1

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

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

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

Tenzin Jinsel
fonte
Como essa resposta ajuda com o restante das respostas aqui?
ComputerScientist