it-swarm.com.de

Wie kann man feststellen, ob der Tensorflow die GPU-Beschleunigung innerhalb der python-Shell verwendet?

Ich habe tensorflow in meinem ubuntu 16.04 mit der zweiten antwort installiert hier mit ubuntus eingebauter apt cuda installation.

Nun ist meine Frage, wie kann ich testen, ob Tensorflow wirklich GPU verwendet? Ich habe eine GTX 960m GPU. Wenn ich import tensorflow das ist die Ausgabe

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

Reicht diese Ausgabe aus, um zu überprüfen, ob Tensorflow GPU verwendet?

219
Tamim Addari

Nein, ich denke nicht, dass "CUDA-Bibliothek öffnen" ausreicht, um dies zu erkennen, da sich verschiedene Knoten des Diagramms möglicherweise auf verschiedenen Geräten befinden.

Um herauszufinden, welches Gerät verwendet wird, können Sie die Platzierung von Protokollgeräten wie folgt aktivieren:

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

Überprüfen Sie Ihre Konsole auf diesen Ausgabetyp.

233
Yao Zhang

Abgesehen von der Verwendung von sess = tf.Session(config=tf.ConfigProto(log_device_placement=True)), die in anderen Antworten sowie im offiziellen TensorFlow Dokumentation beschrieben ist, können Sie versuchen, der GPU eine Berechnung zuzuweisen, um festzustellen, ob Sie einen Fehler haben.

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

Hier

  • "/ cpu: 0": Die CPU Ihres Rechners.
  • "/ gpu: 0": Die GPU Ihres Computers, falls vorhanden.

Wenn Sie eine GPU haben und diese verwenden können, sehen Sie das Ergebnis. Andernfalls wird bei einem langen Stacktrace ein Fehler angezeigt. Am Ende werden Sie so etwas haben:

Ein Gerät kann dem Knoten 'MatMul' nicht zugewiesen werden: Die explizite Gerätespezifikation '/ device: GPU: 0' konnte nicht erfüllt werden, da in diesem Prozess keine Geräte registriert werden, die dieser Spezifikation entsprechen


Kürzlich sind einige hilfreiche Funktionen in TF erschienen:

Sie können in der Sitzung auch nach verfügbaren Geräten suchen:

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

devices gibt Ihnen so etwas zurück

[_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)
237
Salvador Dali

Der folgende Code sollte Ihnen alle Geräte geben, die für Tensorflow verfügbar sind.

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

Beispielausgabe

[name: "/ cpu: 0" device_type: "CPU" memory_limit: 268435456 locality {} incarnation: 4402277519343584096,

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

113
Sheraz

Ich denke, es gibt einen einfacheren Weg, dies zu erreichen.

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

Es druckt normalerweise wie

Default GPU Device: /device:GPU:0

Dies scheint mir einfacher zu sein als diese ausführlichen Protokolle.

52
Ishan Bhatt

Dies wird bestätigen, dass Tensorflow mit GPU auch während des Trainings?

Code

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

Ausgabe

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
27
himanshurobo

Zusätzlich zu anderen Antworten sollten Sie anhand der folgenden Informationen sicherstellen, dass Ihre Version von tensorflow GPU-Unterstützung enthält.

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

Tensorflow 2.

Ab Tensorflow 2.0 werden Sitzungen nicht mehr verwendet. Eine immer noch funktionierende Methode zum Testen der GPU-Funktionalität ist:

import tensorflow as tf

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

Wenn Sie eine Fehlermeldung erhalten, müssen Sie Ihre Installation überprüfen.

20
ma3oun

Dies sollte die Liste der für Tensorflow verfügbaren Geräte (unter Py-3.6) enthalten:

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

Ich bevorzuge die Verwendung von nvidia-smi, um die GPU-Nutzung zu überwachen. Wenn es beim Start Ihres Programms deutlich ansteigt, ist dies ein starkes Zeichen dafür, dass Ihr Tensorflow eine GPU verwendet.

13
scott huang

Ok, starte zuerst einen _ipython Shell_ vom Terminal und 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
_

Jetzt können wir die GPU-Speichernutzung mit dem folgenden Befehl beobachten :

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

Da wir nur TensorFlow imported haben, aber noch keine GPU verwendet haben, lauten die Nutzungsstatistiken:

tf non-gpu usage

Beobachten Sie, wie der GPU-Speicherbedarf sehr gering ist (~ 200 MB).



Laden wir nun die GPU in unseren Code. Führen Sie wie in tf documentation angegeben Folgendes aus:

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

Jetzt sollte die Watch Statistik den aktualisierten GPU-Nutzungsspeicher wie folgt anzeigen:

tf gpu-watch

Beobachten Sie, wie unser Python -Prozess in der ipython-Shell 7,7 GB GPU-Speicher verwendet.


P.S. Sie können diese Statistiken weiter beobachten , während der Code ausgeführt wird, um festzustellen, wie intensiv die GPU-Nutzung ist.

11
kmario23

Ich finde es am einfachsten, die GPU von der Kommandozeile aus abzufragen:

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

wenn es sich beim Lernen um einen Hintergrundprozess handelt, sollte die PID von jobs -p mit der PID von nvidia-smi übereinstimmen.

8
Tim

Führen Sie in Jupyter Folgendes aus:

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

Wenn Sie Ihre Umgebung richtig eingerichtet haben, erhalten Sie Folgendes Ausgabe in dem Terminal, in dem Sie "jupyter notebook" ausgeführt haben,

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

Sie können hier sehen, dass ich TensorFlow mit einem Nvidia Quodro K620 verwende.

7
wafflecat

Sie können überprüfen, ob Sie derzeit die GPU verwenden, indem Sie den folgenden Code ausführen:

import tensorflow as tf
tf.test.gpu_device_name()

Wenn die Ausgabe '' ist, bedeutet dies, dass Sie nur CPU verwenden.
Wenn die Ausgabe so etwas wie /device:GPU:0 ist, bedeutet dies, dass GPU funktioniert.


Verwenden Sie den folgenden Code, um zu überprüfen, welches GPU Sie verwenden:

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

Mit den letzten Updates von Tensorflow können Sie dies wie folgt überprüfen:

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

Dies gibt True zurück, wenn die GPU von Tensorflow verwendet wird, andernfalls False.

Wenn Sie das Gerät device_name möchten, können Sie Folgendes eingeben: tf.test.gpu_device_name(). Weitere Informationen erhalten Sie von hier

5
Cs20

Dies ist die Zeile, die ich verwende, um Geräte aufzulisten, die tf.session direkt von bash zur Verfügung stehen:

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

Es werden verfügbare Geräte und Tensorflow-Versionen gedruckt, zum Beispiel:

_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
2
y.selivonchyk

Legen Sie dies in der Nähe der Oberseite Ihres Jupyter-Notebooks. Kommentiere aus, was du nicht brauchst.

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

Ursprünglich beantwortet hier .

1
Paul Williams

Führen Sie einfach über die Eingabeaufforderung oder die Linux-Umgebung den folgenden Befehl aus.

python -c 'import torch; print(torch.cuda.is_available())' Oben sollte 'True' stehen

python -c 'import torch; print(torch.Rand(2,3).cuda())' Dieser sollte folgendes ausgeben

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

0
DSBLR