303

मैंने दूसरे उत्तर का उपयोग करके अपने ubuntu 16.04 में टैंसरफ़्लो स्थापित किया है साथ यहां का ।

अब मेरा सवाल यह है कि अगर टेंसरफ़्लो वास्तव में जीपीयू का उपयोग कर रहा है तो मैं कैसे परीक्षण कर सकता हूं? मेरे पास एक gtx 960m gpu है। जब मैं import tensorflowयह आउटपुट है

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

क्या यह आउटपुट यह जांचने के लिए पर्याप्त है कि क्या टेंसरफ़्लो जीपीयू का उपयोग कर रहा है?

— तमीम अडारी
स्रोत

1

आपको अपने लॉग में कुछ इस तरह से देखना चाहिए: मैं टेंसरफ़्लो / कोर / कॉमन /runtime / gpu / gpu_device.cc: 838] TensorFlow डिवाइस बनाना (/ gpu: 0) -> (डिवाइस: 0), नाम: GeForce GTX 980, pci bus id : 0000: 03: 00.0)

— यारोस्लाव बुलटोव

2

नहीं है log_device_placementजवाब में दृष्टिकोण। सबसे विश्वसनीय तरीका इस टिप्पणी में निर्दिष्ट समयरेखा को देखना है: github.com/tensorflow/tensorflow/issues/…

— यारोस्लाव बुलटोव

हां, मुझे यह आउटपुट याओ झांग के जवाब के बाद मिला है ...

— तमीम एडारी

@YaroslavBulatov किस लॉग में है? क्या यह इसे एक फाइल पर लिखता है या मैं यह जाँचता हूं कि क्या ऐसा स्टेटमेंट दिखाई देता है?

— चार्ली पार्कर

1

यह stdout या stderr को लिखता है

— यारोस्लाव बुलटोव

290

नहीं, मुझे नहीं लगता कि "ओपन CUDA लाइब्रेरी" बताने के लिए पर्याप्त है, क्योंकि विभिन्न उपकरणों पर ग्राफ के विभिन्न नोड्स हो सकते हैं।

यह पता लगाने के लिए कि किस उपकरण का उपयोग किया जाता है, आप लॉग डिवाइस प्लेसमेंट को इस तरह से सक्षम कर सकते हैं:

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

इस प्रकार के आउटपुट के लिए अपना कंसोल देखें।

— याओ झांग
स्रोत

17

मैंने यह कोशिश की और यह बिल्कुल कुछ भी नहीं छापता है। किसी भी विचार क्यों हो सकता है?

— क़ुबिक्स

8

क्या आपने इसे ज्यूपिटर नोटबुक पर किया था?

— तमीम अदारी

27

आउटपुट कंसोल पर निर्मित किया जा सकता है जहाँ से आपने Jupyter नोटबुक चलाया था।

— मुसिल_ट

18

क्या हमें Tensorflow V2 (जहाँ tf.Session समर्थित नहीं हैं) के लिए एक अद्यतन उत्तर मिल सकता है।

— अयोप 45

6

@ iyop45 लिए tensorflow V2, आदेश थोड़ा संशोधित किया गया है:sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))

— वंदन

276

इसका उपयोग करने के अलावा, sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))जो अन्य उत्तरों के साथ-साथ आधिकारिक TensorFlow प्रलेखन में उल्लिखित है , आप जीपीयू के लिए एक गणना असाइन करने और यह देखने की कोशिश कर सकते हैं कि क्या आपके पास कोई त्रुटि है।

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

यहाँ

"" cpu: 0 ": आपकी मशीन का CPU।
"" gpu: 0 ": आपकी मशीन का GPU, यदि आपके पास एक है।

यदि आपके पास एक gpu है और इसका उपयोग कर सकते हैं, तो आप परिणाम देखेंगे। अन्यथा आप एक लंबे स्टैकट्रेस के साथ एक त्रुटि देखेंगे। अंत में आपके पास कुछ इस तरह होगा:

किसी डिवाइस को 'MatMul' नोड में असाइन नहीं किया जा सकता: स्पष्ट डिवाइस विनिर्देशन को संतुष्ट नहीं कर सका '/ डिवाइस: GPU: 0' क्योंकि उस विनिर्देश से मेल खाने वाला कोई भी उपकरण इस प्रक्रिया में पंजीकृत नहीं हैं

हाल ही में TF में कुछ उपयोगी कार्य दिखाई दिए:

tf.test.is_gpu_available बताता है कि क्या gpu उपलब्ध है
tf.test.gpu_device_name gpu डिवाइस का नाम देता है

आप सत्र में उपलब्ध उपकरणों के लिए भी जाँच कर सकते हैं:

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

devices आपको कुछ इस तरह लौटाएगा

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

— साल्वाडोर डाली
स्रोत

17

परिणाम: [[२२। २ ].] [४ ९। ६४.]]

— जॉर्ज प्लिगोपोपुलोस

6

@GeorgePligor का परिणाम वास्तव में यहाँ महत्वपूर्ण नहीं है। या तो आपके पास एक परिणाम है और GPU का उपयोग किया गया था या आपके पास एक त्रुटि है, जिसका अर्थ है कि इसका उपयोग नहीं किया गया था

— सल्वाडोर डाली

1

इसने मेरे लिए काम नहीं किया। मैंने इसे अपने डॉकर कंटेनर के अंदर दौड़ाया जो कि एनवीडिया-डॉकटर और वेटेक द्वारा एक्सपेक्टेड है। हालाँकि मुझे कोई त्रुटि नहीं है और सीपीयू वह है जो काम करता है। मैंने थोड़ी देर के लिए गणना करने के लिए मेट्रिसेस को थोड़ा (10k * 10k) ऊपर कर दिया। CPU उपयोग 100% तक चला गया लेकिन GPU हमेशा की तरह शांत रहा।

— पास्कलवॉप

कंसोल में चलने पर मुझे "कोई उपकरण मिलान नहीं" त्रुटि मिली। IDE में pycharm की तरह कोई त्रुटि नहीं है। मुझे लगता है कि यह मेरे द्वारा उपयोग किए गए सत्र से संबंधित है, जो कंसोल में अलग है।

— cn123h

समझने में आसान। यदि GPU उपलब्ध है, तो यह कुछ प्रिंट करेगा

Found 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

— Leoli

166

कोड के टुकड़े के बाद आपको टेंसोफ़्लो को सभी उपकरण उपलब्ध होने चाहिए।

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

नमूना आउटपुट

[नाम: "/ सीपीयू: ०" डिवाइस_ टाइप: "सीपीयू" मेमोरी_लिमिट: २६35४३५४५६ स्थानीयता {} अवतार: ४४२२719५१ ९ ३४३५40४०६०,

नाम: "/ gpu: 0" device_type: "GPU" memory_limit: 6772842168 स्थान {Bus_id: 1} अवतार: 7471795903849088328 physical_device anddesc: "डिवाइस: 0, नाम: GeForce GTX 1070, pci बस आईडी: 0000: 0500:

— Sheraz
स्रोत

9

यह सबसे अच्छा जवाब है।

— लोलस्की

3

और अगर यह कमांड "GPU" के साथ किसी भी प्रविष्टि को वापस नहीं करता है, तो क्या इसका मतलब है कि मेरी मशीन में बस GPU है, या टेंसरफ़्लो इसे खोजने में सक्षम नहीं है?

— पारा ०११४

@ पारा ०११४ यह या तो हो सकता है। उदाहरण के लिए, आपके पास एक gpu हो सकता है लेकिन ठीक से स्थापित टेंसरफ़्लो-gpu नहीं है।

— jimijazz

4

मैं असहमत हूं, यह सवाल का जवाब नहीं देता है : यह उपलब्ध उपकरणों के बारे में नहीं है, लेकिन उपयोग किए गए डेविस हैं । और यह एक पूरी तरह से अलग कहानी हो सकती है! (उदाहरण के लिए TF केवल डिफ़ॉल्ट रूप से 1 GPU का उपयोग करेगा।

— Mayou36

नाम: "/ डिवाइस: GPU: 0" device_type: "GPU" memory_limit: 10711446324 इलाके {Bus_id: 1 लिंक {}} अवतार: 179356324456485859 physical.device_desc: "डिवाइस: 0, नाम: GeForce RTX 2080 Ti, pci bus id: 0000 01: 00.0, गणना क्षमता: 7.5 "]

— कामरान कौसर

89

मुझे लगता है कि इसे हासिल करने का एक आसान तरीका है।

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

यह आमतौर पर प्रिंट करता है

Default GPU Device: /device:GPU:0

यह उन क्रिया लॉग के बजाय मुझे आसान लगता है।

— इशान भट्ट
स्रोत

माना। ऊपर वर्णित दृष्टिकोणों की तुलना में आसान है। GPU के उपयोग की सूची प्रिंट करता है। धन्यवाद

— user907629

2

सभी का सबसे अच्छा कमाल

— echan00

यह एक वैध परीक्षण नहीं है। भले ही आपके पास टेंसरफ़्लो का GPU संस्करण स्थापित हो, यह दूसरे विवरण में वापस आ जाएगा।

— गोडार्ड

68

टेंसरफ्लो 2.0

अब 2.0 में सत्र का उपयोग नहीं किया जाता है। इसके बजाय, एक का उपयोग कर सकते हैं tf.test.is_gpu_available:

import tensorflow as tf

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

यदि आपको कोई त्रुटि मिलती है, तो आपको अपनी स्थापना की जांच करने की आवश्यकता है।

— ma3oun
स्रोत

यह TF 1.14 के साथ भी काम करता है (शायद कुछ पुराने संस्करण भी)!

— ओवरड्रिव

6

अब यह करने की सिफारिश की गई हैtf.config.list_physical_devices('GPU')

— रॉय शिलक्रोट

@ रोयिल शकरोट मुझे लगता है कि 'tf.config.list_physical_devices (' GPU ')' Tensorflow 2.0 में काम नहीं करता है

— joselquin

1

@joselquin TF v2.x डॉक्स स्थिति में यह काम करना चाहिए: tensorflow.org/api_docs/python/tf/config/experimental/… , और मैं सत्यापित कर सकता हूं कि यह मेरे लिए काम करता है।

— रॉय शिलक्रोट

29

यह इस बात की पुष्टि करेगा कि प्रशिक्षण के दौरान GPU का उपयोग करने वाले टेंसरफ्लो भी?

कोड

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

उत्पादन

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
स्रोत

5

कृपया थोड़ा स्पष्टीकरण जोड़ें कि आपका उत्तर क्यों काम कर रहा है ( log_device_placementआउटपुट में CPU बनाम GPU को क्या करना है और कैसे देखना है?)। यह आपके उत्तर की गुणवत्ता में सुधार करेगा!

— नंदेर स्पैस्त्र शास्त्र

25

अन्य उत्तरों के अलावा, निम्नलिखित को यह सुनिश्चित करने में मदद करनी चाहिए कि आपके संस्करण में टेंसरफ़्लो का GPU समर्थन शामिल है।

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

— karaspd
स्रोत

7

चेतावनी: यह बताता है कि क्या TensorFlow GPU के साथ संकलित है। जीपीयू का उपयोग नहीं किया जा रहा है या नहीं। (यदि ड्राइवरों को उदाहरण के लिए ठीक से स्थापित नहीं किया गया है, तो सीपीयू का उपयोग किया जाता है, भले ही "is_built_with_cuda ()" सच हो।)

— रिकार्डो क्रूज़

19

ठीक है, पहले ipython shellटर्मिनल और 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

अब, हम निम्नलिखित कमांड का उपयोग करके कंसोल में GPU मेमोरी उपयोग देख सकते हैं :

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

चूँकि हमने केवल importTensorFlow को एड किया है, लेकिन अभी तक किसी भी GPU का उपयोग नहीं किया है, उपयोग आँकड़े निम्न होंगे:

गौर करें कि GPU मेमोरी का उपयोग कैसे बहुत कम है (~ 700MB); कभी-कभी GPU मेमोरी का उपयोग 0 एमबी से भी कम हो सकता है।

अब, हमारे कोड में GPU लोड करें। जैसा कि संकेत दिया गया है tf documentation, करें:

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

अब, घड़ी के आँकड़े नीचे अद्यतन GPU उपयोग स्मृति दिखाना चाहिए:

अब निरीक्षण करें कि ipython शेल से हमारी पायथन प्रक्रिया ~ 7 GB GPU मेमोरी का उपयोग कैसे कर रही है।

PS आप इन आँकड़ों को देखना जारी रख सकते हैं क्योंकि कोड चल रहा है, यह देखने के लिए कि समय के साथ GPU उपयोग कितना तीव्र है।

— kmario23
स्रोत

1

काश कि मैं जवाब दे पाता। यह एक सुनहरा है

— ज़ैन रिज़वी

18

यह Tensorflow (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
स्रोत

यार मैंने गलती से आपके सवाल को गलत कर दिया ... अगर आप अपने सवाल को संपादित करते हैं तो मैं अपना पद छोड़ दूंगा

— फ्रांसेस्को बोई

14

मैं GPU के उपयोग की निगरानी के लिए एनवीडिया-एसएमआई का उपयोग करना पसंद करता हूं। यदि यह काफी बढ़ जाता है जब आप प्रोग्राम शुरू करते हैं, तो यह एक मजबूत संकेत है कि आपका टेंसरफ्लो GPU का उपयोग कर रहा है।

— स्कॉट ह्वांग
स्रोत

यह एक अप्रत्यक्ष तरीका है

— papabiceps

GPU के उपयोग की निगरानी के लिए आप nvdia-smi का उपयोग कैसे करते हैं?

— रज़िन

के बाद आप कोडा स्थापित करें। nvidia-smi आपके सिस्टम में होना चाहिए। मैं आमतौर पर उपयोग की निगरानी के लिए 'एनवीडिया-एसआईएल-एल' का उपयोग करता हूं।

— स्कूट हुआंग

3

तुम भी घड़ी nvidia-smi का उपयोग कर सकते हैं, स्क्रीन को हर 2 सेकंड में अपडेट करता है

— Perseus14

मेरे लिए एनवीडिया-एसआई काम करता है। मैं आउटपुट में यह भी देख सकता हूं कि मेरी अजगर प्रक्रिया

— formica

9

Tensorflow के हालिया अपडेट के साथ, आप इसे निम्नानुसार देख सकते हैं:

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

Trueयदि GPU का उपयोग किया जा रहा है Tensorflow, और वापस लौटेगा तो यह वापस आ जाएगाFalse अन्यथा।

आप डिवाइस चाहते हैं device_nameआप टाइप कर सकते हैं: tf.test.gpu_device_name()। अधिक जानकारी यहाँ से प्राप्त करें

— सौफियाने चमी
स्रोत

8

जुपिटर में निम्नलिखित को चलाएँ,

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

यदि आपने अपना वातावरण ठीक से स्थापित कर लिया है, तो आपको टर्मिनल में निम्नलिखित आउटपुट मिलेंगे, जहाँ आप "ज्यूपिटर नोटबुक" चलाते हैं ,

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

आप यहाँ देख सकते हैं कि मैं Nvidia Quodro K620 के साथ TensorFlow का उपयोग कर रहा हूँ।

— wafflecat
स्रोत

Jupyter बिल्कुल आवश्यक नहीं है, सवाल करने के लिए जटिलता बढ़ नहीं करते कृपया

— पत्रीजियो बर्टोनी

1

कुछ उपयोगकर्ता यह सुनिश्चित करना चाहते हैं कि Jupyter में GPU प्रयोग करने योग्य है। इसके अतिरिक्त, इसे पायथन स्क्रिप्ट से चलाया जा सकता है।

— wafflecat

8

मुझे लगता है कि कमांड लाइन से केवल gpu क्वेरी करना सबसे आसान है:

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

यदि आपकी सीख एक पृष्ठभूमि प्रक्रिया है, तो जिस पिड से पीआईडी का jobs -pमिलान होना चाहिएnvidia-smi

— टिम
स्रोत

6

यदि आप वर्तमान में निम्न कोड चलाकर GPU का उपयोग कर रहे हैं, तो आप देख सकते हैं:

import tensorflow as tf
tf.test.gpu_device_name()

यदि आउटपुट है '', तो इसका मतलब है कि आप CPUकेवल उपयोग कर रहे हैं ;
यदि आउटपुट कुछ ऐसा है /device:GPU:0, तो इसका मतलब है कि GPUकाम करता है।

और जो GPUआप उपयोग कर रहे हैं उसे जांचने के लिए निम्न कोड का उपयोग करें:

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

— हू जिक्सी
स्रोत

यदि आउटपुट है ' ', तो हमें क्या करना चाहिए?

— जेसन

@ जेसन बस एक GPU संस्करण को पुनर्स्थापित करें।

— हू जिक्सी

6

इसे अपने ज्यूपिटर नोटबुक के शीर्ष के पास रखें। टिप्पणी करें कि आपको क्या ज़रूरत नहीं है।

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

ध्यान दें: TensorFlow 2.0 की रिलीज के साथ, केरस को अब TF API के भाग के रूप में शामिल किया गया है।

मूल रूप से यहाँ जवाब दिया ।

— पॉल विलियम्स
स्रोत

5

Tensorflow 2.0 के लिए

import tensorflow as tf

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

स्रोत यहाँ

अन्य विकल्प है:

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

— ChaosPredictor
स्रोत

1

is_gpu_available(tanorflow.python.framework.test_util से) को हटा दिया गया है और भविष्य के संस्करण में हटा दिया जाएगा।

— हिमांशु तेतिया

5

TENSORFLOW> = 2.1 के लिए अद्यतन।

अनुशंसित तरीका है जिसमें यह जांचने के लिए कि क्या TensorFlow GPU का उपयोग कर रहा है, निम्नलिखित है:

tf.config.list_physical_devices('GPU')

TensorFlow 2.1 के रूप में, tf.test.gpu_device_name()उपर्युक्त के पक्ष में पदावनत किया गया है।

— टिम्बस कैलिन
स्रोत

3

यह वह रेखा है जिसका उपयोग मैं tf.sessionसीधे 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__);"

यह उपलब्ध उपकरणों और टेंसोफ़्लो संस्करण को प्रिंट करेगा, उदाहरण के लिए:

_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
स्रोत

3

स्निपेट के नीचे मैंने पाया कि जीपीयू का परीक्षण करना बहुत आसान है।

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

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
स्रोत

3

निम्नलिखित आपके GPU उपकरणों का नाम भी लौटाएगा।

import tensorflow as tf
tf.test.gpu_device_name()

— Maz
स्रोत

यदि इस कमांड का आउटपुट एक खाली स्ट्रिंग है ... मैं डीबग कैसे करूं?

— zthomas.nc

3

टेनसफ़्लो 2.0 के साथ = =

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

— leplandelaville
स्रोत

2

आपके पास यह परीक्षण करने के लिए कुछ विकल्प हैं कि क्या GPU त्वरण का उपयोग आपके TensorFlow स्थापना द्वारा किया जा रहा है।

आप तीन अलग-अलग प्लेटफार्मों में निम्नलिखित कमांड टाइप कर सकते हैं।

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

Jupyter नोटबुक - कंसोल को चेक करें जो Jupyter नोटबुक चला रहा है। आप उपयोग किए जा रहे जीपीयू को देख पाएंगे।
पायथन शेल - आप सीधे आउटपुट देख पाएंगे। (नोट- चर output सेस ’को दूसरी कमांड के आउटपुट को असाइन न करें; यदि वह मदद करता है)।
स्पाइडर - कंसोल में निम्न कमांड टाइप करें।

import tensorflow as tf tf.test.is_gpu_available()

— simpleParadox
स्रोत

2

टेन्सफ़्लोअर 2.1

एक साधारण गणना जिसे 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
स्रोत

2

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

जैसा कि @AmitaiIrron ने सुझाव दिया है:

यह खंड इंगित करता है कि एक 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

और यहाँ यह उपलब्ध भौतिक उपकरण के रूप में जुड़ गया

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
स्रोत

यह उपयोगी होगा यदि आप आउटपुट में उन वर्गों को इंगित करते हैं जो इंगित करते हैं कि क्या एक GPU का उपयोग किया जाता है।

— अमिताई इरोन

@AmitaiIrron सुझाव के लिए धन्यवाद, मुझे आशा है कि यह थोड़ा और स्पष्ट है।

— bLeDy

1

यदि आप TensorFlow 2.0 का उपयोग कर रहे हैं, तो आप उपकरणों को दिखाने के लिए लूप के लिए इसका उपयोग कर सकते हैं:

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

— डौग
स्रोत

1

यदि आप टेंसरफ़्लो 2.x का उपयोग कर रहे हैं:

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

— Cheptii
स्रोत

0

Tensorflow GPU का उपयोग कर रहा है या नहीं, यह जाँचने के लिए Jupyter या अपने IDE में इस कमांड को चलाएँ: tf.config.list_physical_devices('GPU')

— तेनजिन जिंसेल
स्रोत

यह उत्तर बाकी उत्तरों के साथ कैसे मदद करता है?

— कम्प्यूटर

कैसे बताएं कि क्या टेंसोरफ्लो अजगर के खोल के अंदर से जीपीयू त्वरण का उपयोग कर रहा है?

Tensorflow 2.0 के लिए

Tensorflow 2.0 टेस्ट

Tensorflow 1 टेस्ट

टेन्सफ़्लोअर 2.1