Ich habe Tensorflow in meinem Ubuntu 16.04 installiert, wobei ich die zweite Antwort hier mit Ubuntus integrierter Apt Cuda-Installation verwendet habe.

Meine Frage ist nun, wie ich testen kann, ob Tensorflow wirklich GPU verwendet. Ich habe eine GTX 960m GPU. Wenn ich import tensorflowdas 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?

Nein, ich denke nicht, dass "offene CUDA-Bibliothek" ausreicht, um dies zu sagen, 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 diese Art der Ausgabe.

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

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 Computers.
• "/ gpu: 0": Die GPU Ihres Computers, falls vorhanden.

Wenn Sie eine GPU haben und diese verwenden können, sehen Sie das Ergebnis. Andernfalls wird ein Fehler mit einer langen Stapelverfolgung angezeigt. Am Ende wirst du 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 in TF einige hilfreiche Funktionen erschienen:

• tf.test.is_gpu_available gibt an , ob die GPU verfügbar ist
• tf.test.gpu_device_name gibt den Namen des GPU-Geräts zurück

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

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

devices Ich werde dir so etwas zurückgeben

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

Der folgende Code sollte Ihnen alle Geräte zur Verfügung stellen, die für Tensorflow verfügbar sind.

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

Beispielausgabe

[Name: "/ CPU: 0" Gerätetyp: "CPU" Speicherlimit: 268435456 Lokalität {} Inkarnation: 4402277519343584096,

Name: "/ gpu: 0" Gerätetyp: "GPU" Speicherlimit: 6772842168 Lokalität {Bus-ID: 1} Inkarnation: 7471795903849088328 physischer_ Geräte-Desc: "Gerät: 0, Name: GeForce GTX 1070, PCI-Bus-ID: 0000: 05: 00.0"]

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.

Tensorflow 2.0

Sitzungen werden in 2.0 nicht mehr verwendet. Stattdessen kann man verwenden tf.test.is_gpu_available:

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.

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

Neben anderen Antworten soll Ihnen Folgendes helfen, um sicherzustellen, dass Ihre Version von Tensorflow GPU-Unterstützung enthält.

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

Ok, starten Sie zuerst eine ipython shellvom Terminal und 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

Jetzt können wir die GPU-Speichernutzung in einer Konsole mit dem folgenden Befehl überwachen :

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

Da wir nur importTensorFlow bearbeitet haben, aber noch keine GPU verwendet haben, lauten die Nutzungsstatistiken wie folgt:

Beachten Sie, dass die GPU-Speichernutzung sehr gering ist (~ 700 MB). Manchmal beträgt die GPU-Speichernutzung sogar nur 0 MB.

Laden wir nun die GPU in unseren Code. Gehen Sie wie in tf documentation:

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

Nun werden die Uhr sollten Statistiken zeigen eine aktualisierte GPU Nutzung Speicher wie folgt:

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

PS : Sie können weiterhin beobachten diese Statistiken als der Code ausgeführt wird , um zu sehen , wie intensiv die GPU Nutzung im Laufe der Zeit ist.

Dies sollte die Liste der für Tensorflow verfügbaren Geräte enthalten (unter 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)

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

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 wird zurückgegeben, Truewenn die GPU von verwendet wird Tensorflow, und wird zurückgegebenFalse anderweitig zurückgegeben.

Wenn Sie ein Gerät möchten, können device_nameSie Folgendes eingeben : tf.test.gpu_device_name(). Weitere Details erhalten Sie hier

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 ordnungsgemäß eingerichtet haben, erhalten Sie die folgende 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.

Ich finde es am einfachsten, nur die GPU über die Befehlszeile 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 Ihr Lernen ein Hintergrundprozess ist, jobs -psollte die PID von der PID von übereinstimmennvidia-smi

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 CPUnur verwenden;
Wenn die Ausgabe so ähnlich ist /device:GPU:0, bedeutet dies, dass sie GPUfunktioniert.

Verwenden Sie den folgenden Code, um zu überprüfen, welchen GPUSie verwenden:

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

Stellen Sie dies oben auf Ihr Jupyter-Notizbuch. Kommentieren Sie aus, was Sie nicht brauchen.

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

HINWEIS: Mit der Veröffentlichung von TensorFlow 2.0 ist Keras jetzt Teil der TF-API.

Ursprünglich hier beantwortet .

Für Tensorflow 2.0

import tensorflow as tf

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

Quelle hier

andere Option ist:

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

UPDATE FÜR TENSORFLOW> = 2.1.

Es wird empfohlen, zu überprüfen, ob TensorFlow eine GPU verwendet:

tf.config.list_physical_devices('GPU') 

Ab TensorFlow 2.1 wurde tf.test.gpu_device_name()zugunsten der oben genannten veraltet.

Dies ist die Zeile, die ich verwende, um Geräte aufzulisten, die tf.sessiondirekt von bash verfügbar sind :

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 die Tensorflow-Version 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

Ich fand unten Snippet ist sehr praktisch, um die GPU zu testen ..

Tensorflow 2.0 Test

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

Tensorflow 1 Test

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

Im Folgenden wird auch der Name Ihrer GPU-Geräte zurückgegeben.

import tensorflow as tf
tf.test.gpu_device_name()

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

Wie von @AmitaiIrron vorgeschlagen:

Dieser Abschnitt zeigt an, dass eine GPU gefunden wurde

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

Und hier wurde es als verfügbares physisches Gerät hinzugefügt

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

Sie haben einige Optionen, um zu testen, ob die GPU-Beschleunigung von Ihrer TensorFlow-Installation verwendet wird.

Sie können die folgenden Befehle auf drei verschiedenen Plattformen eingeben.

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

1. Jupyter Notebook - Überprüfen Sie die Konsole, auf der das Jupyter Notebook ausgeführt wird. Sie können sehen, welche GPU verwendet wird.
2. Python Shell - Sie können die Ausgabe direkt sehen. (Hinweis: Weisen Sie die Ausgabe des zweiten Befehls nicht der Variablen 'sess' zu. Wenn dies hilfreich ist.)

3. Spyder - Geben Sie den folgenden Befehl in die Konsole ein.

   import tensorflow as tf tf.test.is_gpu_available()

Tensorflow 2.1

Eine einfache Berechnung, die mit nvidia-smi für die Speichernutzung auf der GPU überprüft werden kann.

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

Wenn Sie TensorFlow 2.0 verwenden, können Sie diese for-Schleife verwenden, um die Geräte anzuzeigen:

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

Wenn Sie Tensorflow 2.x verwenden, verwenden Sie:

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

Führen Sie diesen Befehl in Jupyter oder Ihrer IDE aus, um zu überprüfen, ob Tensorflow eine GPU verwendet oder nicht: tf.config.list_physical_devices('GPU')