Zainstalowałem tensorflow na moim Ubuntu 16.04, używając drugiej odpowiedzi tutaj z wbudowaną instalacją apt cuda w Ubuntu .

Teraz moje pytanie brzmi: jak mogę sprawdzić, czy tensorflow naprawdę używa GPU? Mam GTX 960m GPU. Kiedy ja import tensorflowto jest wynik

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

Czy to wyjście wystarczy, aby sprawdzić, czy tensorflow korzysta z GPU?

Nie, nie sądzę, że „otwarta biblioteka CUDA” wystarczy, aby powiedzieć, ponieważ różne węzły wykresu mogą znajdować się na różnych urządzeniach.

Aby dowiedzieć się, które urządzenie jest używane, możesz włączyć umiejscowienie urządzenia rejestrującego w następujący sposób:

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

Sprawdź konsolę pod kątem tego rodzaju wyników.

Oprócz użycia, sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))który jest opisany w innych odpowiedziach, a także w oficjalnej dokumentacji TensorFlow , możesz spróbować przypisać obliczenia do gpu i sprawdzić, czy masz błąd.

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

Tutaj

• „/ cpu: 0”: procesor komputera.
• „/ gpu: 0”: GPU twojego komputera, jeśli go masz.

Jeśli masz GPU i możesz go użyć, zobaczysz wynik. W przeciwnym razie zobaczysz błąd z długim śledzeniem stosu. Na koniec będziesz mieć coś takiego:

Nie można przypisać urządzenia do węzła „MatMul”: Nie można spełnić jawnej specyfikacji urządzenia ”/ device: GPU: 0”, ponieważ w tym procesie nie są zarejestrowane żadne urządzenia spełniające tę specyfikację

Ostatnio pojawiło się kilka pomocnych funkcji w TF:

• tf.test.is_gpu_available informuje, czy GPU jest dostępny
• tf.test.gpu_device_name zwraca nazwę urządzenia GPU

Możesz również sprawdzić dostępność urządzeń w sesji:

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

devices zwróci ci coś takiego

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

Poniższy fragment kodu powinien dać ci wszystkie urządzenia dostępne dla tensorflow.

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

Przykładowe dane wyjściowe

[name: "/ cpu: 0" device_type: "CPU" limit_pamięci: 268435456 lokalizacja {} inkarnacja: 4402277519343584096,

nazwa: "/ gpu: 0" typ_urządzenia: "GPU" limit_pamięci: 6772842168 lokalizacja {identyfikator_biznesu: 1} inkarnacja: 7471795903849088328 physical_device_desc: "urządzenie: 0, nazwa: GeForce GTX 1070, identyfikator magistrali pci: 0000: 05: 00.0"]

Myślę, że jest łatwiejszy sposób na osiągnięcie tego.

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

Zwykle drukuje jak

Default GPU Device: /device:GPU:0

Wydaje mi się to łatwiejsze niż te pełne dzienniki.

Tensorflow 2.0

Sesje nie są już używane w wersji 2.0. Zamiast tego można użyć tf.test.is_gpu_available:

import tensorflow as tf

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

Jeśli pojawi się błąd, musisz sprawdzić instalację.

Potwierdzi to przepływ tensor przy użyciu GPU podczas treningu?

Kod

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

Wynik

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

Oprócz innych odpowiedzi, poniższe powinny pomóc ci upewnić się, że twoja wersja tensorflow zawiera obsługę GPU.

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

Ok, najpierw uruchom ipython shellz terminala i 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

Teraz możemy obserwować użycie pamięci GPU w konsoli za pomocą następującego polecenia:

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

Ponieważ importedytowaliśmy tylko TensorFlow, ale nie korzystaliśmy jeszcze z żadnych GPU, statystyki użytkowania będą następujące:

Zauważ, że użycie pamięci GPU jest bardzo mniejsze (~ 700 MB); Czasami użycie pamięci GPU może wynosić nawet 0 MB.

Teraz załadujmy GPU do naszego kodu. Jak wskazano w tf documentation, wykonaj:

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

Teraz statystyki zegarka powinny pokazywać zaktualizowaną pamięć użytkowania GPU, jak poniżej:

Zobacz teraz, jak nasz proces Python z powłoki ipython zużywa ~ 7 GB pamięci GPU.

PS Możesz nadal obserwować te statystyki w trakcie działania kodu, aby zobaczyć, jak intensywne jest użycie GPU w czasie.

Powinno to dać listę urządzeń dostępnych dla Tensorflow (zgodnie z 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)

Wolę używać nvidia-smi do monitorowania użycia GPU. jeśli znacząco wzrośnie po uruchomieniu programu, to silny znak, że twój tensorflow korzysta z GPU.

Dzięki najnowszym aktualizacjom Tensorflow możesz to sprawdzić w następujący sposób:

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

Zwróci to, Truejeśli GPU jest w użyciu Tensorflow, i zwróci w Falseinny sposób.

Jeśli chcesz urządzenie device_namemożna wpisać: tf.test.gpu_device_name(). Uzyskać więcej szczegółów z tutaj

Uruchom następujące polecenie w Jupyter,

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

Jeśli poprawnie skonfigurowałeś swoje środowisko, otrzymasz następujące dane wyjściowe w terminalu, w którym uruchomiłeś „notatnik 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

Tutaj możesz zobaczyć, że korzystam z TensorFlow z Nvidią Quodro K620.

Uważam, że samo zapytanie GPU z wiersza poleceń jest najłatwiejsze:

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

jeśli nauka jest procesem w tle, pid z jobs -ppowinien pasować do pid znvidia-smi

Możesz sprawdzić, czy obecnie korzystasz z GPU, uruchamiając następujący kod:

import tensorflow as tf
tf.test.gpu_device_name()

Jeśli wynikiem jest '', oznacza to, że używasz CPUtylko;
Jeśli wynik jest podobny /device:GPU:0, oznacza to, że GPUdziała.

I użyj następującego kodu, aby sprawdzić, którego GPUużywasz:

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

Umieść to w górnej części notebooka jupyter. Skomentuj to, czego nie potrzebujesz.

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

UWAGA: Wraz z wydaniem TensorFlow 2.0, Keras jest teraz włączony jako część TF API.

Pierwotnie odpowiedziano tutaj .

Dla Tensorflow 2.0

import tensorflow as tf

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

źródło tutaj

inna opcja to:

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

AKTUALIZACJA PRZEPŁYWU TENSORA> = 2.1.

Zalecany sposób sprawdzenia, czy TensorFlow korzysta z GPU, jest następujący:

tf.config.list_physical_devices('GPU') 

Od wersji TensorFlow 2.1 tf.test.gpu_device_name()został wycofany na rzecz wyżej wymienionych.

Oto linia, której używam do wyświetlania listy urządzeń dostępnych tf.sessionbezpośrednio z 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__);"

Wydrukuje dostępne urządzenia i wersję tensorflow, na przykład:

_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

Odkryłem, że fragment kodu jest bardzo przydatny do testowania GPU ..

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

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

Poniższe spowoduje również zwrócenie nazwy urządzeń GPU.

import tensorflow as tf
tf.test.gpu_device_name()

Z tensotflow 2.0> =

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

Masz kilka opcji, aby sprawdzić, czy akceleracja GPU jest używana przez instalację TensorFlow.

Możesz wpisać następujące polecenia na trzech różnych platformach.

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

1. Jupyter Notebook - Sprawdź konsolę, na której działa Notatnik Jupyter. Zobaczysz używany procesor graficzny.
2. Python Shell - Będziesz mógł bezpośrednio zobaczyć wynik. (Uwaga - nie przypisuj wyjścia drugiego polecenia do zmiennej „sess”; jeśli to pomaga).

3. Spyder - Wpisz następujące polecenie w konsoli.

   import tensorflow as tf tf.test.is_gpu_available()

Przepływ Tensor 2.1

Proste obliczenie, które można zweryfikować za pomocą nvidia-smi dla zużycia pamięci 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))

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

Zgodnie z sugestią @AmitaiIrron:

Ta sekcja wskazuje, że znaleziono GPU

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

I tutaj został dodany jako dostępne urządzenie fizyczne

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

Jeśli używasz TensorFlow 2.0, możesz użyć tego dla pętli, aby pokazać urządzenia:

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

jeśli używasz tensorflow 2.x użyj:

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

Uruchom to polecenie w Jupyter lub IDE, aby sprawdzić, czy Tensorflow używa procesora graficznego, czy nie: tf.config.list_physical_devices('GPU')